W-20014590 "webapp" CLI commands scaffolding (#3)

* feat: implement webapp commands for One Runtime Apps with Agentforce Vibes

- Add webapp:generate command with name, label, target, template, and wizard flags
- Add webapp:deploy command with name and options (build/value) flags
- Add webapp:retrieve command with name flag
- Add webapp:dev command with optional name and port flags
- Remove hello world example code
- Add comprehensive unit tests and NUT tests (18 tests total, all passing)
- Add message files with examples for all commands
- Generate JSON schemas for all webapp commands
- Update command snapshot for deprecation policy
- Update package.json topics from 'hello' to 'webapp'

All commands support JSON output and follow Salesforce CLI conventions.
Commands include TODO comments for future business logic implementation.

* docs: use generic context instead of Agentforce Vibes references

- Update webapp:generate description to use generic web app language
- Update webapp:deploy description to remove One Runtime App references
- Make messaging product-agnostic

* fix: change deploy options from 'value' to 'validate'

- Update webapp:deploy --options flag to use 'build' or 'validate'
- Update message file and test to reflect correct option
- Regenerate JSON schemas

* feat: add webapp version create command with optional version flag

* feat: add --no-overwrite and --ignore flags to webapp retrieve command

* feat: update webapp dev command with target, root-dir, host, and no-open flags

* docs: simplify webapp generate description

* docs: simplify webapp deploy description

* docs: update webapp deploy description to avoid duplication

* docs: revert webapp deploy description to match summary

* docs: simplify webapp dev name flag description

* docs: simplify webapp dev description

* docs: add detailed description and validate example for webapp deploy

* docs: refine webapp deploy description wording

* docs: add detailed description for webapp generate

* docs: simplify webapp generate description

* docs: add .ignore file explanation to webapp retrieve

* revert: remove .ignore file documentation from webapp retrieve

* docs: add comprehensive command reference documentation

* docs: align command documentation with spec requirements

* docs: add proper description for webapp version topic

* refactor: remove webapp version create command

* refactor: update webapp commands - simplify generate and dev

- Changed webapp generate: -t flag now for template (was target)
- Removed target platform options from generate command
- Updated webapp dev: simplified flags, default port to 5173
- Removed host/root-dir/no-open flags from dev command
- Removed webapp deploy and retrieve commands for now
- Updated all tests, schemas, and documentation
- All tests passing

---------

Co-authored-by: shinoni <lturanscaia@salesforce.com>

Author: Shinoni

COMMANDS.md

@@ -0,0 +1,83 @@
+# Commands
+
+<!-- commands -->
+
+- [`sf webapp dev`](#sf-webapp-dev)
+- [`sf webapp generate`](#sf-webapp-generate)
+
+## `sf webapp dev`
+
+Preview a web app locally without needing to deploy
+
+```
+USAGE
+  $ sf webapp dev -n <value> [--json] [--flags-dir <value>] [-t <value>] [-p <value>]
+
+FLAGS
+  -n, --name=<value>    (required) Identifies the Web Application
+  -p, --port=<value>    [default: 5173] Port for the dev server
+  -t, --target=<value>  Selects which Web Application target to use for the preview (e.g., Lightning App, Site)
+
+GLOBAL FLAGS
+  --flags-dir=<value>  Import flag values from a directory.
+  --json               Format output as json.
+
+DESCRIPTION
+  Preview a web app locally without needing to deploy
+
+  Starts a local development server for a Web Application, using the local project files. This enables rapid
+  development with hot reloading and immediate feedback.
+
+EXAMPLES
+  Start the development server:
+
+    $ sf webapp dev --name myWebApp
+
+  Start the development server with a specific target:
+
+    $ sf webapp dev --name myWebApp --target "LightningApp"
+
+  Start the development server on a custom port:
+
+    $ sf webapp dev --name myWebApp --port 8080
+```
+
+## `sf webapp generate`
+
+Create a web app and associated metadata.
+
+```
+USAGE
+  $ sf webapp generate -n <value> -l <value> [--json] [--flags-dir <value>] [-t <value>] [-w]
+
+FLAGS
+  -l, --label=<value>     (required) Human readable name of your web app
+  -n, --name=<value>      (required) Name of your web app
+  -t, --template=<value>  [default: empty] Template to use for web app generation (pulls from central solution)
+  -w, --wizard            Run in interactive wizard mode
+
+GLOBAL FLAGS
+  --flags-dir=<value>  Import flag values from a directory.
+  --json               Format output as json.
+
+DESCRIPTION
+  Create a web app and associated metadata.
+
+  This command creates a new web app with the specified configuration, including the basic structure and metadata
+  files.
+
+EXAMPLES
+  Create an empty web app:
+
+    $ sf webapp generate --name "myWebApp" --label "My first Web App"
+
+  Create a web app with a specific template:
+
+    $ sf webapp generate --name "myWebApp" --label "My Web App" --template "React app starter"
+
+  Create a web app using the wizard:
+
+    $ sf webapp generate --name "myWebApp" --label "My Web App" --wizard
+```
+
+<!-- commandsstop -->

command-snapshot.json

@@ -1,10 +1,18 @@
 [
   {
     "alias": [],
-    "command": "hello:world",
+    "command": "webapp:dev",
     "flagAliases": [],
-    "flagChars": ["n"],
-    "flags": ["flags-dir", "json", "name"],
+    "flagChars": ["n", "p", "t"],
+    "flags": ["flags-dir", "json", "name", "port", "target"],
+    "plugin": "@salesforce/plugin-webapp"
+  },
+  {
+    "alias": [],
+    "command": "webapp:generate",
+    "flagAliases": [],
+    "flagChars": ["l", "n", "t", "w"],
+    "flags": ["flags-dir", "json", "label", "name", "template", "wizard"],
     "plugin": "@salesforce/plugin-webapp"
   }
 ]

messages/hello.world.md

@@ -0,0 +1,33 @@
+# summary
+
+Preview a web app locally without needing to deploy
+
+# description
+
+Starts a local development server for a Web Application, using the local project files. This enables rapid development with hot reloading and immediate feedback.
+
+# flags.name.summary
+
+Identifies the Web Application
+
+# flags.target.summary
+
+Selects which Web Application target to use for the preview (e.g., Lightning App, Site)
+
+# flags.port.summary
+
+Port for the dev server
+
+# examples
+
+- Start the development server:
+
+  <%= config.bin %> <%= command.id %> --name myWebApp
+
+- Start the development server with a specific target:
+
+  <%= config.bin %> <%= command.id %> --name myWebApp --target "LightningApp"
+
+- Start the development server on a custom port:
+
+  <%= config.bin %> <%= command.id %> --name myWebApp --port 8080

messages/webapp.dev.md

@@ -0,0 +1,37 @@
+# summary
+
+Create a web app and associated metadata.
+
+# description
+
+This command creates a new web app with the specified configuration, including the basic structure and metadata files.
+
+# flags.name.summary
+
+Name of your web app
+
+# flags.label.summary
+
+Human readable name of your web app
+
+# flags.template.summary
+
+Template to use for web app generation (pulls from central solution)
+
+# flags.wizard.summary
+
+Run in interactive wizard mode
+
+# examples
+
+- Create an empty web app:
+
+  <%= config.bin %> <%= command.id %> --name "myWebApp" --label "My first Web App"
+
+- Create a web app with a specific template:
+
+  <%= config.bin %> <%= command.id %> --name "myWebApp" --label "My Web App" --template "React app starter"
+
+- Create a web app using the wizard:
+
+  <%= config.bin %> <%= command.id %> --name "myWebApp" --label "My Web App" --wizard

messages/webapp.generate.md

@@ -52,8 +52,8 @@
       "@salesforce/plugin-command-reference"
     ],
     "topics": {
-      "hello": {
-        "description": "Commands to say hello."
+      "webapp": {
+        "description": "Work with Salesforce Web Apps"
       }
     },
     "flexibleTaxonomy": true

package.json

@@ -1,18 +1,21 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "$ref": "#/definitions/HelloWorldResult",
+  "$ref": "#/definitions/WebappDevResult",
   "definitions": {
-    "HelloWorldResult": {
+    "WebappDevResult": {
       "type": "object",
       "properties": {
         "name": {
           "type": "string"
         },
-        "time": {
+        "target": {
+          "type": "string"
+        },
+        "url": {
           "type": "string"
         }
       },
-      "required": ["name", "time"],
+      "required": ["name", "url"],
       "additionalProperties": false
     }
   }

schemas/hello-world.json schemas/webapp-dev.jsonschemas/hello-world.json renamed to schemas/webapp-dev.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$ref": "#/definitions/WebappGenerateResult",
+  "definitions": {
+    "WebappGenerateResult": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "label": {
+          "type": "string"
+        },
+        "template": {
+          "type": "string"
+        },
+        "wizard": {
+          "type": "boolean"
+        }
+      },
+      "required": ["name", "label", "template", "wizard"],
+      "additionalProperties": false
+    }
+  }
+}

schemas/webapp-generate.json

@@ -18,34 +18,60 @@ import { SfCommand, Flags } from '@salesforce/sf-plugins-core';
 import { Messages } from '@salesforce/core';
 
 Messages.importMessagesDirectoryFromMetaUrl(import.meta.url);
-const messages = Messages.loadMessages('@salesforce/plugin-webapp', 'hello.world');
+const messages = Messages.loadMessages('@salesforce/plugin-webapp', 'webapp.dev');
 
-export type HelloWorldResult = {
+export type WebappDevResult = {
   name: string;
-  time: string;
+  target?: string;
+  url: string;
 };
 
-export default class World extends SfCommand<HelloWorldResult> {
+export default class WebappDev extends SfCommand<WebappDevResult> {
   public static readonly summary = messages.getMessage('summary');
   public static readonly description = messages.getMessage('description');
   public static readonly examples = messages.getMessages('examples');
 
   public static readonly flags = {
     name: Flags.string({
-      char: 'n',
       summary: messages.getMessage('flags.name.summary'),
-      description: messages.getMessage('flags.name.description'),
-      default: 'World',
+      char: 'n',
+      required: true,
+    }),
+    target: Flags.string({
+      summary: messages.getMessage('flags.target.summary'),
+      char: 't',
+      required: false,
+    }),
+    port: Flags.integer({
+      summary: messages.getMessage('flags.port.summary'),
+      char: 'p',
+      default: 5173,
     }),
   };
 
-  public async run(): Promise<HelloWorldResult> {
-    const { flags } = await this.parse(World);
-    const time = new Date().toDateString();
-    this.log(messages.getMessage('info.hello', [flags.name, time]));
+  public async run(): Promise<WebappDevResult> {
+    const { flags } = await this.parse(WebappDev);
+
+    this.log(`Starting development server for web app: ${flags.name}`);
+    if (flags.target) {
+      this.log(`Using target: ${flags.target}`);
+    }
+
+    const url = `http://localhost:${flags.port}`;
+    this.log(`Server running on ${url}`);
+    this.log('Opening browser...');
+
+    // TODO: Implement dev server logic
+    // This would typically involve:
+    // 1. Starting a local development server
+    // 2. Watching for file changes
+    // 3. Hot reloading
+    // 4. Opening browser
+
     return {
       name: flags.name,
-      time,
+      target: flags.target,
+      url,
     };
   }
 }