@foldspace_npm/harness 0.1.2 → 0.1.3

package/bin/cli.mjs

@@ -1,43 +1,29 @@
 #!/usr/bin/env node
 
 import { spawn } from "node:child_process";
+import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { initUsage, runInit } from "../src/init.mjs";
+import { runInit } from "../src/init.mjs";
+import {
+  CLI_COMMANDS,
+  createCliRegistry,
+  commandByName,
+} from "../src/cli-registry.mjs";
+import {
+  helpDocument,
+  renderCommandHelp,
+  renderGeneralHelp,
+} from "../src/cli-help.mjs";
 
 const here = path.dirname(fileURLToPath(import.meta.url));
-
-const commands = {
-  init: "Create a configured Foldspace actions project",
-  build: "Bundle agent actions to dist/index.js",
-  inject: "Launch the dedicated Chrome profile",
-  attach: "Load the SDK and local actions over CDP",
-  deploy: "Publish the built bundle",
-  "package-extension": "Package the browser extension",
-};
-
-const scriptByCommand = {
-  build: "build-cli.mjs",
-  inject: "inject.mjs",
-  attach: "attach.mjs",
-  deploy: "deploy.mjs",
-  "package-extension": "packageExtension.mjs",
-};
-
-const usage = `Usage:
-  foldspace <command> [args]
-  ${initUsage}
-  foldspace build [--watch]
-  foldspace inject [options]
-  foldspace attach [options]
-  foldspace deploy [options]
-  foldspace package-extension
-
-Commands:
-${Object.entries(commands)
-  .map(([name, description]) => `  ${name.padEnd(18)} ${description}`)
-  .join("\n")}
-`;
+const packageManifest = JSON.parse(
+  fs.readFileSync(path.resolve(here, "..", "package.json"), "utf8"),
+);
+const registry = createCliRegistry({
+  packageName: packageManifest.name,
+  packageVersion: packageManifest.version,
+});
 
 function fail(message) {
   console.error(`foldspace: ${message}`);
@@ -58,26 +44,118 @@ function runScript(scriptName, args) {
   });
 }
 
+function printHelp(topic, json) {
+  const document = helpDocument(registry, topic);
+  if (!document) {
+    fail(
+      `unknown help topic '${topic}'. Run 'foldspace help' to list commands.`,
+    );
+    return;
+  }
+  if (json) {
+    console.log(JSON.stringify(document, null, 2));
+    return;
+  }
+  console.log(
+    topic ? renderCommandHelp(registry, topic) : renderGeneralHelp(registry),
+  );
+}
+
+function normalizeCommandArgs(command, args) {
+  const options = new Map(
+    command.options.map((option) => [option.name, option]),
+  );
+  const seen = new Set();
+  const normalized = [];
+  let positionals = 0;
+  for (let index = 0; index < args.length; index++) {
+    const token = args[index];
+    if (!token.startsWith("--")) {
+      if (positionals >= command.positionals.length) {
+        throw new Error(`unexpected argument '${token}'`);
+      }
+      positionals += 1;
+      normalized.push(token);
+      continue;
+    }
+
+    const separator = token.indexOf("=");
+    const name = separator > -1 ? token.slice(0, separator) : token;
+    const option = options.get(name);
+    if (!option) throw new Error(`unknown option '${name}'`);
+    if (seen.has(name)) throw new Error(`option '${name}' was provided twice`);
+    seen.add(name);
+
+    if (option.kind === "flag") {
+      if (separator > -1) throw new Error(`option '${name}' takes no value`);
+      normalized.push(name);
+      continue;
+    }
+
+    const optionValue =
+      separator > -1 ? token.slice(separator + 1) : args[++index];
+    if (!optionValue || optionValue.startsWith("--")) {
+      throw new Error(`option '${name}' requires a value`);
+    }
+    normalized.push(name, optionValue);
+  }
+  return normalized;
+}
+
 const [command, ...args] = process.argv.slice(2);
 
 if (!command || command === "--help" || command === "-h") {
-  console.log(usage);
+  printHelp(null, args.includes("--json"));
+} else if (command === "--version" || command === "-v") {
+  console.log(
+    `${registry.package.name} ${registry.package.version} ` +
+      `(protocol ${registry.protocolVersion}, CLI schema ${registry.schemaVersion})`,
+  );
+} else if (command === "help") {
+  const unknown = args.filter(
+    (arg) => arg.startsWith("-") && arg !== "--json",
+  );
+  const topics = args.filter((arg) => !arg.startsWith("-"));
+  if (unknown.length || topics.length > 1) {
+    fail(
+      `usage: foldspace help [<command>] [--json]`,
+    );
+  } else {
+    printHelp(topics[0] || null, args.includes("--json"));
+  }
 } else if (command === "init") {
   if (args.includes("--help") || args.includes("-h")) {
-    console.log(`Usage: ${initUsage}`);
+    printHelp("init", args.includes("--json"));
   } else {
-    Promise.resolve()
-      .then(() => runInit(args))
-      .catch((error) => {
-        fail(error instanceof Error ? error.message : String(error));
-      });
+    try {
+      const normalized = normalizeCommandArgs(commandByName("init"), args);
+      Promise.resolve()
+        .then(() => runInit(normalized))
+        .catch((error) => {
+          fail(error instanceof Error ? error.message : String(error));
+        });
+    } catch (error) {
+      fail(error instanceof Error ? error.message : String(error));
+    }
   }
-} else if (scriptByCommand[command]) {
+} else if (commandByName(command)) {
   if (args.includes("--help") || args.includes("-h")) {
-    console.log(`Usage: foldspace ${command} [options]`);
+    printHelp(command, args.includes("--json"));
   } else {
-    runScript(scriptByCommand[command], args);
+    try {
+      const definition = commandByName(command);
+      runScript(
+        definition.entry,
+        normalizeCommandArgs(definition, args),
+      );
+    } catch (error) {
+      fail(error instanceof Error ? error.message : String(error));
+    }
   }
 } else {
-  fail(`unknown command '${command}'\n\n${usage}`);
+  const names = CLI_COMMANDS.map((entry) => entry.name).join(", ");
+  fail(
+    `unknown command '${command}'. Available commands: ${names}. ` +
+      `Run 'foldspace help'.`,
+  );
 }

package/bin/deploy.mjs

@@ -1,9 +1,11 @@
 import { execFileSync, execSync } from "child_process";
 import fs from "fs";
 import path from "path";
-import { fileURLToPath } from "url";
+import {
+  readProjectConfig,
+  resolveConfiguredTarget,
+} from "../src/project-config.mjs";
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const projectDir = process.env.FOLDSPACE_PROJECT_DIR || process.cwd();
 
 const GCS_BUCKET = "prod-us1-eucera-public-scripts";
@@ -12,35 +14,15 @@ function parseArgs(argv) {
   const args = {};
   for (let i = 0; i < argv.length; i++) {
     if (argv[i] === "--env" && argv[i + 1]) args.env = argv[++i];
+    else if (argv[i] === "--target" && argv[i + 1]) {
+      args.target = argv[++i];
+    } else {
+      throw new Error(`unknown or incomplete option '${argv[i]}'`);
+    }
   }
   return args;
 }
 
-function readExtensionConfig() {
-  const indexPath = path.join(projectDir, "extension", "index.js");
-  if (!fs.existsSync(indexPath)) {
-    console.error("deploy: extension/index.js not found");
-    process.exit(1);
-  }
-  const src = fs.readFileSync(indexPath, "utf8");
-
-  const productMatch = src.match(/const\s+PRODUCT_ID\s*=\s*["'](.+?)["']/);
-  const agentMatch = src.match(/const\s+AGENT_API_NAME\s*=\s*["'](.+?)["']/);
-
-  if (!productMatch || !productMatch[1]) {
-    console.error("deploy: could not read PRODUCT_ID from extension/index.js");
-    process.exit(1);
-  }
-  if (!agentMatch || !agentMatch[1]) {
-    console.error(
-      "deploy: could not read AGENT_API_NAME from extension/index.js",
-    );
-    process.exit(1);
-  }
-
-  return { productId: productMatch[1], agentApiName: agentMatch[1] };
-}
-
 function validate(args) {
   const errors = [];
   if (args.env !== "dev" && args.env !== "prod")
@@ -48,7 +30,9 @@ function validate(args) {
   if (errors.length) {
     console.error("deploy: validation failed:");
     errors.forEach((e) => console.error(`  - ${e}`));
-    console.error("\nUsage: node scripts/deploy.mjs [--env <dev|prod>]");
+    console.error(
+      "\nUsage: foldspace deploy [--target <name>] [--env <dev|prod>]",
+    );
     process.exit(1);
   }
 }
@@ -181,12 +165,32 @@ function updateDeployments(env, version) {
 }
 
 function deploy() {
-  const args = parseArgs(process.argv.slice(2));
+  let args;
+  try {
+    args = parseArgs(process.argv.slice(2));
+  } catch (error) {
+    console.error(
+      `deploy: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    process.exit(1);
+  }
   if (!args.env) args.env = "dev";
 
-  const { productId, agentApiName } = readExtensionConfig();
-  args.productId = productId;
-  args.agentApiName = agentApiName;
+  let resolved;
+  try {
+    resolved = resolveConfiguredTarget(
+      readProjectConfig(projectDir),
+      args.target,
+    );
+  } catch (error) {
+    console.error(
+      `deploy: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    process.exit(1);
+  }
+  args.target = resolved.targetName;
+  args.productId = resolved.target.productId;
+  args.agentApiName = resolved.target.agentApiName;
 
   validate(args);
 
@@ -200,7 +204,7 @@ function deploy() {
 
   const basePath = gcsBasePath(args.env, args.productId, args.agentApiName);
 
-  console.log(`deploy: ${version} -> ${args.env}`);
+  console.log(`deploy: ${version} -> ${args.env} (${args.target})`);
   console.log(`deploy: bucket ${GCS_BUCKET}`);
   console.log(`deploy: path   ${basePath}`);