@linzumi/cli 0.0.1-beta → 0.0.2-beta

package/src/cli.js

@@ -1,240 +0,0 @@
-import { spawnSync } from "node:child_process";
-
-const version = "0.0.1-beta";
-
-const requiredEnv = {
-  linzBin: "LINZUMI_LOCAL_CODEX_RUNNER_LINZ_BIN",
-  vmId: "LINZUMI_LOCAL_CODEX_RUNNER_VM_ID",
-  remoteCodexBin: "LINZUMI_LOCAL_CODEX_RUNNER_REMOTE_CODEX_BIN",
-  remoteEnv: "LINZUMI_LOCAL_CODEX_RUNNER_REMOTE_ENV",
-};
-
-const usage = `linzumi connect [OPTIONS]
-
-Connects this machine to Kandan as the local Codex runner.
-
-This command runs on your local computer. Use the command shown by Kandan's
-local runner connection flow to start the local Codex runner here.
-
-Options:
-  --linz-bin <path>            LINZ CLI or bridge wrapper to execute
-  --vm-id <id>                 LINZ runner VM id
-  --remote-codex-bin <path>    Remote Codex binary path
-  --remote-env <path>          Remote env-file path
-  --remote-kandan-linz <path>  Remote kandan_linz path
-  --help                       Show this help
-  --version                    Show CLI version
-
-Environment defaults:
-  ${requiredEnv.linzBin}
-  ${requiredEnv.vmId}
-  ${requiredEnv.remoteCodexBin}
-  ${requiredEnv.remoteEnv}
-  LINZUMI_LOCAL_CODEX_RUNNER_REMOTE_KANDAN_LINZ
-
-Internal runner protocol:
-  linzumi connect [OPTIONS] app-server --listen <url>
-`;
-
-const defaultRemoteKandanLinz = "/home/linz/.kandan/runner/bin/kandan_linz";
-
-const connectGuide = `linzumi connect
-
-This command connects this machine to Kandan as a local Codex runner.
-
-Open Kandan, start the local runner connection flow, and follow the command it
-shows you. Run that command on this computer.
-
-For help:
-  linzumi connect --help
-`;
-
-const isBlank = (value) => typeof value !== "string" || value.trim() === "";
-
-const readOptionValue = (tokens, index, name) => {
-  const value = tokens[index + 1];
-  if (isBlank(value)) {
-    return { ok: false, error: `${name} requires a value` };
-  }
-
-  return { ok: true, value, nextIndex: index + 2 };
-};
-
-const shellQuote = (value) => `'${value.replaceAll("'", "'\"'\"'")}'`;
-
-export const buildRemoteCommand = ({ remoteKandanLinz, remoteEnv, remoteCodexBin, listenUrl }) => {
-  const rendered = [
-    "exec",
-    shellQuote(remoteKandanLinz),
-    "app-server",
-    "--env-file",
-    shellQuote(remoteEnv),
-    shellQuote(remoteCodexBin),
-    shellQuote(listenUrl),
-  ];
-
-  return rendered.join(" ");
-};
-
-const normalizeRemotePath = (path) => {
-  if (path.startsWith("/")) {
-    return path;
-  }
-
-  return `/home/linz/${path}`;
-};
-
-export const parseLocalCodexRunnerArgs = ({ argv, env }) => {
-  const options = {
-    linzBin: env[requiredEnv.linzBin],
-    vmId: env[requiredEnv.vmId],
-    remoteCodexBin: env[requiredEnv.remoteCodexBin],
-    remoteEnv: env[requiredEnv.remoteEnv],
-    remoteKandanLinz:
-      env.LINZUMI_LOCAL_CODEX_RUNNER_REMOTE_KANDAN_LINZ ?? defaultRemoteKandanLinz,
-  };
-  const command = [];
-
-  let index = 0;
-  while (index < argv.length) {
-    const token = argv[index];
-
-    switch (token) {
-      case "--help":
-      case "-h":
-        return { ok: true, help: true };
-      case "--version":
-        return { ok: true, version: true };
-      case "--linz-bin": {
-        const parsed = readOptionValue(argv, index, "--linz-bin");
-        if (!parsed.ok) return parsed;
-        options.linzBin = parsed.value;
-        index = parsed.nextIndex;
-        break;
-      }
-      case "--vm-id": {
-        const parsed = readOptionValue(argv, index, "--vm-id");
-        if (!parsed.ok) return parsed;
-        options.vmId = parsed.value;
-        index = parsed.nextIndex;
-        break;
-      }
-      case "--remote-codex-bin": {
-        const parsed = readOptionValue(argv, index, "--remote-codex-bin");
-        if (!parsed.ok) return parsed;
-        options.remoteCodexBin = parsed.value;
-        index = parsed.nextIndex;
-        break;
-      }
-      case "--remote-env": {
-        const parsed = readOptionValue(argv, index, "--remote-env");
-        if (!parsed.ok) return parsed;
-        options.remoteEnv = parsed.value;
-        index = parsed.nextIndex;
-        break;
-      }
-      case "--remote-kandan-linz": {
-        const parsed = readOptionValue(argv, index, "--remote-kandan-linz");
-        if (!parsed.ok) return parsed;
-        options.remoteKandanLinz = parsed.value;
-        index = parsed.nextIndex;
-        break;
-      }
-      case "--":
-        command.push(...argv.slice(index + 1));
-        index = argv.length;
-        break;
-      default:
-        command.push(...argv.slice(index));
-        index = argv.length;
-        break;
-    }
-  }
-
-  const [subcommand, listenFlag, listenUrl, ...extra] = command;
-  if (subcommand !== "app-server" || listenFlag !== "--listen" || isBlank(listenUrl) || extra.length > 0) {
-    return {
-      ok: false,
-      error: "connect must be launched by Kandan with the internal runner protocol",
-    };
-  }
-
-  const missing = Object.entries(options)
-    .filter(([, value]) => isBlank(value))
-    .map(([name]) => name);
-
-  if (missing.length > 0) {
-    return { ok: false, error: `missing connect option(s): ${missing.join(", ")}` };
-  }
-
-  return {
-    ok: true,
-    options: {
-      ...options,
-      remoteCodexBin: normalizeRemotePath(options.remoteCodexBin),
-      remoteEnv: normalizeRemotePath(options.remoteEnv),
-      remoteKandanLinz: normalizeRemotePath(options.remoteKandanLinz),
-      listenUrl,
-    },
-  };
-};
-
-export const runLocalCodexRunner = ({ argv, env, cwd, spawn = spawnSync }) => {
-  if (argv.length === 0) {
-    return { exitCode: 0, stdout: connectGuide, stderr: "" };
-  }
-
-  const parsed = parseLocalCodexRunnerArgs({ argv, env });
-
-  if (!parsed.ok) {
-    return { exitCode: 64, stdout: "", stderr: `${parsed.error}\n` };
-  }
-
-  if (parsed.help) {
-    return { exitCode: 0, stdout: usage, stderr: "" };
-  }
-
-  if (parsed.version) {
-    return { exitCode: 0, stdout: `linzumi ${version}\n`, stderr: "" };
-  }
-
-  const { linzBin, vmId, remoteKandanLinz, remoteEnv, remoteCodexBin, listenUrl } = parsed.options;
-  const remoteCommand = buildRemoteCommand({ remoteKandanLinz, remoteEnv, remoteCodexBin, listenUrl });
-  const result = spawn(linzBin, ["exec", vmId, "--", "sh", "-lc", remoteCommand], {
-    cwd,
-    encoding: "utf8",
-    stdio: ["ignore", "inherit", "inherit"],
-  });
-
-  if (result.error) {
-    return { exitCode: 127, stdout: "", stderr: `${result.error.message}\n` };
-  }
-
-  return { exitCode: result.status ?? 1, stdout: "", stderr: "" };
-};
-
-export const runCliToResult = ({ argv, env, cwd, spawn = spawnSync }) => {
-  const [command, ...rest] = argv;
-
-  switch (command) {
-    case undefined:
-      return runLocalCodexRunner({ argv: [], env, cwd, spawn });
-    case "connect":
-    case "local-codex-runner":
-      return runLocalCodexRunner({ argv: rest, env, cwd, spawn });
-    case "--help":
-    case "-h":
-      return { exitCode: 0, stdout: usage, stderr: "" };
-    case "--version":
-      return { exitCode: 0, stdout: `linzumi ${version}\n`, stderr: "" };
-    default:
-      return { exitCode: 64, stdout: "", stderr: `unknown linzumi command: ${command}\n${usage}` };
-  }
-};
-
-export const runCli = ({ argv, env, cwd, stdout, stderr, spawn = spawnSync }) => {
-  const result = runCliToResult({ argv, env, cwd, spawn });
-  if (result.stdout !== "") stdout.write(result.stdout);
-  if (result.stderr !== "") stderr.write(result.stderr);
-  return { exitCode: result.exitCode };
-};