me2lon 0.0.0-stage → 0.1.0

package/src/cli.ts

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+
+import { readFile, realpath } from "node:fs/promises";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+
+import { Me2lonAgentClient } from "./client.js";
+import { resolveRuntimeConfig } from "./config.js";
+import { Me2lonClientError, publicError } from "./errors.js";
+import { installSkill } from "./skill.js";
+import { humanOutput, waitForJob } from "./presentation.js";
+import { setupProject } from "./setup.js";
+import type { JsonValue } from "./types.js";
+
+const HELP = `me2lon — CLI client for /api/agent/v1
+
+Usage:
+  me2lon setup [--base-url URL] [--project-name NAME] [--new-credential]
+  me2lon skill install [--agent generic|codex|claude] [--path DIRECTORY] [--force]
+  --json                 machine-readable output
+  --wait                 wait for analyze/get-job (default timeout: 7200 seconds)
+  --timeout-seconds N     override waiting timeout
+  --version              print client version
+  me2lon capabilities [connection options]
+  me2lon analyze [--project-root PATH] [--revision-id ID] [connection options]
+  me2lon check-workspace [connection options]
+  me2lon get-job --job-id ID [connection options]
+  me2lon translate --check-job-id ID --project-id ID [connection options]
+  me2lon verify --translation-job-id ID --expected-policy-set-digest DIGEST [connection options]
+  me2lon get-policy [--policy-unit-id ID] [connection options]
+  me2lon propose-policy --policy-unit-id ID --expected-policy-set-digest DIGEST --policy-file FILE [--rationale TEXT] [connection options]
+  me2lon cancel-job --job-id ID [connection options]
+
+Connection options:
+  --base-url URL          API origin (or ME2LON_AGENT_URL)
+  --workspace-root PATH   exact Git root (or ME2LON_WORKSPACE_ROOT; default cwd)
+  --repository-id ID      bound repository (or ME2LON_REPOSITORY_ID)
+  --base-commit SHA       full 40-character commit (or ME2LON_BASE_COMMIT)
+  --config FILE           mode-0600 JSON config (or ME2LON_AGENT_CONFIG)
+  --token-stdin           read the token from stdin
+
+The token is accepted only from ME2LON_AGENT_TOKEN, a protected config file,
+or stdin for one-shot CLI calls. A token option is deliberately not supported.
+`;
+
+const options = {
+  json: { type: "boolean" as const },
+  wait: { type: "boolean" as const },
+  version: { type: "boolean" as const },
+  "timeout-seconds": { type: "string" as const },
+  agent: { type: "string" as const },
+  path: { type: "string" as const },
+  force: { type: "boolean" as const },
+  "project-name": { type: "string" as const },
+  "new-credential": { type: "boolean" as const, default: false },
+  "base-url": { type: "string" as const },
+  "workspace-root": { type: "string" as const },
+  "repository-id": { type: "string" as const },
+  "base-commit": { type: "string" as const },
+  config: { type: "string" as const },
+  "token-stdin": { type: "boolean" as const, default: false },
+  "job-id": { type: "string" as const },
+  "check-job-id": { type: "string" as const },
+  "translation-job-id": { type: "string" as const },
+  "project-root": { type: "string" as const },
+  "revision-id": { type: "string" as const },
+  "project-id": { type: "string" as const },
+  "policy-unit-id": { type: "string" as const },
+  "expected-policy-set-digest": { type: "string" as const },
+  "policy-file": { type: "string" as const },
+  rationale: { type: "string" as const },
+  help: { type: "boolean" as const, short: "h", default: false },
+};
+
+function rejectSecretArguments(argv: string[]): void {
+  if (
+    argv.some(
+      (argument) =>
+        argument === "--token" ||
+        argument.startsWith("--token=") ||
+        argument === "--api-key" ||
+        argument.startsWith("--api-key="),
+    )
+  ) {
+    throw new Me2lonClientError(
+      "ME2LON_TOKEN_ON_ARGV",
+      "Me2lon tokens are never accepted on the command line. Use ME2LON_AGENT_TOKEN, a protected config file, or --token-stdin.",
+    );
+  }
+}
+
+async function tokenFromStdin(): Promise<string> {
+  const chunks: Buffer[] = [];
+  let bytes = 0;
+  for await (const chunk of process.stdin) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    bytes += buffer.length;
+    if (bytes > 8_192) {
+      throw new Me2lonClientError(
+        "ME2LON_TOKEN_INVALID",
+        "The stdin token exceeds the Me2lon client safety limit.",
+      );
+    }
+    chunks.push(buffer);
+  }
+  return Buffer.concat(chunks).toString("utf8").trim();
+}
+
+function requiredOption(
+  values: Record<string, string | boolean | undefined>,
+  name: string,
+): string {
+  const value = values[name];
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Me2lonClientError(
+      "ME2LON_CLI_INPUT_MISSING",
+      `Missing --${name}.`,
+    );
+  }
+  return value.trim();
+}
+
+async function readPolicy(path: string): Promise<JsonValue> {
+  const bytes = await readFile(path);
+  if (bytes.length > 1024 * 1024) {
+    throw new Me2lonClientError(
+      "ME2LON_POLICY_FILE_LIMIT",
+      "The policy proposal exceeds the 1 MiB client limit.",
+    );
+  }
+  try {
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes)) as JsonValue;
+  } catch (error) {
+    throw new Me2lonClientError(
+      "ME2LON_POLICY_FILE_INVALID",
+      "The policy proposal file must contain valid UTF-8 JSON.",
+      { cause: error },
+    );
+  }
+}
+
+export async function runCli(argv: string[]): Promise<number> {
+  rejectSecretArguments(argv);
+  const parsed = parseArgs({
+    args: argv,
+    options,
+    allowPositionals: true,
+    strict: true,
+  });
+  const [command, ...extraPositionals] = parsed.positionals;
+  const print = (value: JsonValue) => process.stdout.write(`${parsed.values.json ? JSON.stringify(value) : humanOutput(value)}\n`);
+  if (parsed.values.version) {
+    const { version } = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8'));
+    print(parsed.values.json ? { version } : version); return 0;
+  }
+  if (command === 'skill' && extraPositionals.length === 1 && extraPositionals[0] === 'install') {
+    const path = await installSkill(parsed.values.agent, parsed.values.path, parsed.values.force);
+    print({ installed: path }); return 0;
+  }
+  if (parsed.values.wait && !['analyze', 'get-job'].includes(command ?? '')) throw new Me2lonClientError("ME2LON_CLI_INPUT_INVALID", '--wait requires analyze or get-job.');
+  const timeout = Number(parsed.values['timeout-seconds'] ?? 7200);
+  if (!Number.isFinite(timeout) || timeout <= 0) throw new Me2lonClientError("ME2LON_CLI_INPUT_INVALID", '--timeout-seconds must be a positive number.');
+  if (parsed.values.help || !command) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  if (extraPositionals.length > 0) {
+    throw new Me2lonClientError(
+      "ME2LON_CLI_INPUT_INVALID",
+      "Unexpected positional command arguments.",
+    );
+  }
+  if (command === "setup") {
+    const result = await setupProject({
+      directory: parsed.values["workspace-root"], baseUrl: parsed.values["base-url"],
+      configPath: parsed.values.config, projectName: parsed.values["project-name"],
+      newCredential: parsed.values["new-credential"],
+    }, { notify: (value) => process.stderr.write(`${parsed.values.json ? JSON.stringify(value) : humanOutput(value)}\n`) });
+    print(result);
+    return 0;
+  }
+  const stdinToken = parsed.values["token-stdin"]
+    ? await tokenFromStdin()
+    : undefined;
+  const config = await resolveRuntimeConfig({
+    ...(parsed.values["base-url"]
+      ? { baseUrl: parsed.values["base-url"] }
+      : {}),
+    ...(parsed.values["workspace-root"]
+      ? { workspaceRoot: parsed.values["workspace-root"] }
+      : {}),
+    ...(parsed.values["repository-id"]
+      ? { repositoryId: parsed.values["repository-id"] }
+      : {}),
+    ...(parsed.values["base-commit"]
+      ? { baseCommitSha: parsed.values["base-commit"] }
+      : {}),
+    ...(parsed.values.config ? { configPath: parsed.values.config } : {}),
+    ...(stdinToken ? { tokenFromStdin: stdinToken } : {}),
+  });
+  const client = new Me2lonAgentClient(config);
+  let result;
+  switch (command) {
+    case "capabilities":
+      result = await client.capabilities();
+      break;
+    case "analyze":
+      result = await client.analyzeWorkspace(parsed.values["project-root"], parsed.values["revision-id"]);
+      break;
+    case "check-workspace":
+      result = await client.checkWorkspace();
+      break;
+    case "get-job":
+      result = await client.getJob(requiredOption(parsed.values, "job-id"));
+      break;
+    case "translate":
+      result = await client.translate(
+        requiredOption(parsed.values, "check-job-id"),
+        requiredOption(parsed.values, "project-id"),
+      );
+      break;
+    case "verify":
+      result = await client.verify(
+        requiredOption(parsed.values, "translation-job-id"),
+        requiredOption(parsed.values, "expected-policy-set-digest"),
+      );
+      break;
+    case "get-policy":
+      result = await client.getPolicy(
+        typeof parsed.values["policy-unit-id"] === "string"
+          ? parsed.values["policy-unit-id"]
+          : undefined,
+      );
+      break;
+    case "propose-policy": {
+      const rationale = parsed.values.rationale;
+      result = await client.proposePolicy({
+        policyUnitId: requiredOption(parsed.values, "policy-unit-id"),
+        expectedPolicySetDigest: requiredOption(
+          parsed.values,
+          "expected-policy-set-digest",
+        ),
+        policy: await readPolicy(requiredOption(parsed.values, "policy-file")),
+        ...(typeof rationale === "string" ? { rationale } : {}),
+      });
+      break;
+    }
+    case "cancel-job":
+      result = await client.cancelJob(requiredOption(parsed.values, "job-id"));
+      break;
+    default:
+      throw new Me2lonClientError(
+        "ME2LON_CLI_COMMAND_UNKNOWN",
+        `Unknown Me2lon command: ${command}.`,
+      );
+  }
+  if (parsed.values.wait) {
+    const initial = command === 'analyze' ? result.job : result;
+    if (!initial || typeof initial !== 'object' || Array.isArray(initial)) throw new Me2lonClientError("ME2LON_CLI_INPUT_INVALID", 'Missing job response.');
+    const controller = new AbortController();
+    const interrupt = () => controller.abort();
+    process.once('SIGINT', interrupt);
+    try {
+      const completed = await waitForJob(initial, id => client.getJob(id), {
+        timeoutMs: timeout * 1000, signal: controller.signal,
+        notify: message => process.stderr.write(`${message}\n`),
+      });
+      print(completed.result); return completed.exitCode;
+    } finally { process.removeListener('SIGINT', interrupt); }
+  }
+  print(result);
+  return 0;
+}
+
+async function main(): Promise<void> {
+  try {
+    process.exitCode = await runCli(process.argv.slice(2));
+  } catch (error) {
+    const safe = publicError(error);
+    process.stderr.write(`${process.argv.includes("--json") ? JSON.stringify(safe) : safe.message}\n`);
+    process.exitCode = 1;
+  }
+}
+
+export async function isMainModule(
+  moduleUrl: string,
+  entrypoint: string | undefined,
+): Promise<boolean> {
+  if (!entrypoint) {
+    return false;
+  }
+  try {
+    const [modulePath, entrypointPath] = await Promise.all([
+      realpath(fileURLToPath(moduleUrl)),
+      realpath(entrypoint),
+    ]);
+    return modulePath === entrypointPath;
+  } catch {
+    return moduleUrl === pathToFileURL(entrypoint).href;
+  }
+}
+
+if (await isMainModule(import.meta.url, process.argv[1])) {
+  await main();
+}