feat: Added apt, npm login, nvm and pnpm

Author: kevinwang5658

CLAUDE.md

@@ -374,6 +374,69 @@ parameterSettings: {
 }
 ```
 
+### defaultConfig and exampleConfigs
+
+Every resource should have a `defaultConfig` and `exampleConfigs`. These are surfaced in the Codify Editor to help users get started quickly.
+
+**`defaultConfig`** — pre-fills the resource form with sensible starting values:
+- Use Syncthing's/asdf's/AWS's own documented defaults where applicable
+- For required fields with no sensible default (e.g. `deviceId`, `plugin`, `awsAccessKeyId`), use the placeholder string `'<Replace me here!'>`
+- For optional array fields that default to empty (e.g. `plugins`, `aliases`, `paths`), set them to `[]`
+- Omit fields that are purely user-specific (e.g. paths, names, credentials) — don't guess
+- If the resource declares `operatingSystems: [OS.Darwin]` or `operatingSystems: [OS.Linux]` (i.e. only one OS, not both), do NOT add `os` to `defaultConfig` (it's not on the typed config interface). Instead, add `os: ['darwin']` or `os: ['linux']` only to the config entries inside `exampleConfigs`. Skip entirely when the resource supports both OS.
+
+**`exampleConfigs`** — up to two named examples (`example1`, `example2`):
+- `example1`: a minimal, focused single-resource example showing the most common use case
+- `example2`: either a more advanced single-resource variant, OR a multi-resource example that shows the full end-to-end setup (e.g. install the tool + configure it)
+- Multi-resource examples (configs array with multiple types) are especially useful when the resource `dependsOn` another — show installing the dependency too
+- Every example needs a `title` (short, noun-phrase) and a `description` (one sentence explaining what it does and why)
+- Use realistic but obviously-placeholder values for sensitive fields (`'<Replace me here!'>`), not real credentials
+- Don't add step-numbering ("Step 1 of 3") in descriptions — it doesn't make sense when viewed from a single resource page
+- If the resource is OS-specific (only Darwin or only Linux), add `os: ['darwin']` or `os: ['linux']` to each config entry in the example so the editor filters it correctly
+
+**Structure:**
+```typescript
+import { ExampleConfig } from '@codifycli/plugin-core';
+
+const defaultConfig: Partial<MyConfig> = {
+  someField: 'sensible-default',
+  optionalArray: [],
+  // Add os: ['darwin'] or os: ['linux'] if operatingSystems is not [OS.Darwin, OS.Linux]
+}
+
+const exampleBasic: ExampleConfig = {
+  title: 'Basic my-resource setup',
+  description: 'One sentence explaining what this example does and who it is for.',
+  configs: [{
+    type: 'my-resource',
+    someField: 'example-value',
+    // Add os: ['darwin'] or os: ['linux'] if the resource is OS-specific
+  }]
+}
+
+const exampleWithDependency: ExampleConfig = {
+  title: 'Full my-resource setup',
+  description: 'Install the prerequisite and configure my-resource in one go.',
+  configs: [
+    { type: 'prerequisite-resource' },
+    { type: 'my-resource', someField: 'example-value' },
+  ]
+}
+
+// Inside getSettings():
+return {
+  id: 'my-resource',
+  defaultConfig,
+  exampleConfigs: {
+    example1: exampleBasic,
+    example2: exampleWithDependency,
+  },
+  // ...
+}
+```
+
+**When there is a shared multi-resource example** (e.g. the asdf full-install example used across `asdf`, `asdf-plugin`, and `asdf-install`): define it once in a separate `examples.ts` file in the resource folder and spread it into `exampleConfigs` using `...exampleSharedConfigs`. Use a consistent description across all three rather than per-resource step labels.
+
 ### Dependencies
 
 Resources can declare dependencies on other resources:

src/resources/apt/apt.ts

@@ -1,5 +1,5 @@
-import { CreatePlan, Resource, ResourceSettings, SpawnStatus, getPty } from '@codifycli/plugin-core';
-import { OS, ResourceConfig } from '@codifycli/schemas';
+import { CreatePlan, ExampleConfig, Resource, ResourceSettings, SpawnStatus, getPty } from '@codifycli/plugin-core';
+import { OS, ResourceConfig, ResourceOs } from '@codifycli/schemas';
 
 import schema from './apt-schema.json';
 import { AptInstallParameter, AptPackage } from './install-parameter.js';
@@ -9,11 +9,45 @@ export interface AptConfig extends ResourceConfig {
   update?: boolean;
 }
 
+const defaultConfig: Partial<AptConfig> = {
+  install: [],
+  os: [ResourceOs.LINUX]
+}
+
+const exampleBasic: ExampleConfig = {
+  title: 'Install apt packages',
+  description: 'Install a set of common development packages using apt on a Debian-based system.',
+  configs: [{
+    type: 'apt',
+    os: [ResourceOs.LINUX],
+    install: ['curl', 'git', 'build-essential'],
+  }]
+}
+
+const exampleVersionPinned: ExampleConfig = {
+  title: 'Install apt packages with pinned versions',
+  description: 'Install packages using apt, with specific versions pinned for reproducibility.',
+  configs: [{
+    type: 'apt',
+    os: [ResourceOs.LINUX],
+    install: [
+      'curl',
+      { name: 'nodejs', version: '20.*' },
+      { name: 'python3', version: '3.12.*' },
+    ],
+  }]
+}
+
 export class AptResource extends Resource<AptConfig> {
 
   override getSettings(): ResourceSettings<AptConfig> {
     return {
       id: 'apt',
+      defaultConfig,
+      exampleConfigs: {
+        example1: exampleBasic,
+        example2: exampleVersionPinned,
+      },
       operatingSystems: [OS.Linux],
       schema,
       removeStatefulParametersBeforeDestroy: true,

src/resources/javascript/npm/npm-login-schema.json

@@ -8,7 +8,7 @@
   "properties": {
     "authToken": {
       "type": "string",
-      "description": "The npm auth token used for authenticating with the registry. If not provided, then web login is assumed"
+      "description": "The npm auth token used for authenticating with the registry. If not provided, then web login is assumed. Generate one at https://www.npmjs.com/settings/<username>/tokens by creating a 'Classic Token' (Automation or Read/Write). Tokens look like: npm_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
     },
     "scope": {
       "type": "string",

src/resources/javascript/npm/npm-login.ts

@@ -1,6 +1,7 @@
 import {
   CreatePlan,
   DestroyPlan,
+  ExampleConfig,
   getPty,
   ModifyPlan,
   ParameterChange,
@@ -21,10 +22,40 @@ export interface NpmLoginConfig extends ResourceConfig {
   registry?: string; // Example: "https://registry.npmjs.org/"
 }
 
+const defaultConfig: Partial<NpmLoginConfig> = {
+  registry: 'https://registry.npmjs.org/',
+}
+
+const exampleBasicLogin: ExampleConfig = {
+  title: 'npm registry login',
+  description: 'Authenticate with the public npm registry using a personal access token stored in ~/.npmrc. Tokens are generated at https://www.npmjs.com/settings/<username>/tokens by creating a Classic Token',
+  configs: [{
+    type: 'npm-login',
+    authToken: '<Replace me here!>',
+    registry: 'https://registry.npmjs.org/',
+  }]
+}
+
+const exampleScopedLogin: ExampleConfig = {
+  title: 'Scoped private registry login',
+  description: 'Authenticate with a private npm registry and bind it to a package scope, so all @myorg/* packages resolve to that registry. Tokens are generated at https://www.npmjs.com/settings/<username>/tokens by creating a Classic Token',
+  configs: [{
+    type: 'npm-login',
+    authToken: '<Replace me here!>',
+    scope: '@myorg',
+    registry: 'https://npm.pkg.github.com/',
+  }]
+}
+
 export class NpmLoginResource extends Resource<NpmLoginConfig> {
   getSettings(): ResourceSettings<NpmLoginConfig> {
     return {
       id: 'npm-login',
+      defaultConfig,
+      exampleConfigs: {
+        example1: exampleBasicLogin,
+        example2: exampleScopedLogin,
+      },
       operatingSystems: [OS.Darwin, OS.Linux],
       schema,
       isSensitive: true,

src/resources/javascript/nvm/nvm.ts

@@ -1,4 +1,4 @@
-import { getPty, Resource, ResourceSettings, SpawnStatus } from '@codifycli/plugin-core';
+import { ExampleConfig, getPty, Resource, ResourceSettings, SpawnStatus } from '@codifycli/plugin-core';
 import { OS, ResourceConfig } from '@codifycli/schemas';
 import * as os from 'node:os';
 
@@ -13,11 +13,40 @@ export interface NvmConfig extends ResourceConfig {
   nodeVersions?: string[],
 }
 
+const defaultConfig: Partial<NvmConfig> = {
+  nodeVersions: [],
+}
+
+const exampleLts: ExampleConfig = {
+  title: 'Install Node.js LTS via nvm',
+  description: 'Install nvm and set the latest LTS release as the global Node.js version.',
+  configs: [{
+    type: 'nvm',
+    nodeVersions: ['lts'],
+    global: 'lts',
+  }]
+}
+
+const exampleMultiVersion: ExampleConfig = {
+  title: 'Install multiple Node.js versions via nvm',
+  description: 'Install nvm with multiple Node.js versions side by side, using Node.js 22 as the global default.',
+  configs: [{
+    type: 'nvm',
+    nodeVersions: ['18', '20', '22'],
+    global: '22',
+  }]
+}
+
 export class NvmResource extends Resource<NvmConfig> {
 
   getSettings(): ResourceSettings<NvmConfig> {
     return {
       id: 'nvm',
+      defaultConfig,
+      exampleConfigs: {
+        example1: exampleLts,
+        example2: exampleMultiVersion,
+      },
       operatingSystems: [OS.Darwin, OS.Linux],
       schema: Schema,
       parameterSettings: {

src/resources/javascript/pnpm/pnpm.ts

@@ -1,4 +1,4 @@
-import { CreatePlan, DestroyPlan, RefreshContext, Resource, ResourceSettings, getPty } from '@codifycli/plugin-core';
+import { CreatePlan, DestroyPlan, ExampleConfig, RefreshContext, Resource, ResourceSettings, getPty } from '@codifycli/plugin-core';
 import { OS, ResourceConfig } from '@codifycli/schemas';
 import fs from 'node:fs/promises';
 import os from 'node:os';
@@ -14,10 +14,23 @@ export interface PnpmConfig extends ResourceConfig {
   globalEnvNodeVersion?: string;
 }
 
+const exampleWithNode: ExampleConfig = {
+  title: 'Install pnpm with a global Node.js version',
+  description: 'Install a specific version of pnpm and activate a global Node.js version via pnpm env.',
+  configs: [{
+    type: 'pnpm',
+    version: '10',
+    globalEnvNodeVersion: '22.0.0',
+  }]
+}
+
 export class Pnpm extends Resource<PnpmConfig> {
   getSettings(): ResourceSettings<PnpmConfig> {
     return {
       id: 'pnpm',
+      exampleConfigs: {
+        example1: exampleWithNode,
+      },
       operatingSystems: [OS.Darwin, OS.Linux],
       schema,
       parameterSettings: {