run-spaceapp 0.1.0

package/src/cli.mjs

@@ -0,0 +1,540 @@
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import process from "node:process";
+import {
+  addWorkspace,
+  composeCommand,
+  credentialProviders,
+  initializeInstallation,
+  inspectSystemResources,
+  installResourceChecks,
+  loadConfig,
+  removeCredential,
+  removeWorkspace,
+  resolveInstallProfile,
+  resolveSpaceAppHome,
+  saveConfig,
+  selectLatestBackupId,
+  writeCredential,
+  writeRuntimeFiles,
+  writeSetupToken
+} from "./index.mjs";
+
+export async function run(argv, {
+  env = process.env,
+  platform = process.platform,
+  stdout = process.stdout,
+  stderr = process.stderr,
+  stdin = process.stdin,
+  execute = executeCommand,
+  inspectResources = inspectSystemResources
+} = {}) {
+  const [command = "help", ...args] = argv;
+  const root = resolveSpaceAppHome({ env, platform });
+  const version = await packageVersion();
+
+  if (command === "help" || command === "--help" || command === "-h") {
+    stdout.write(helpText());
+    return 0;
+  }
+  if (command === "--version" || command === "-v") {
+    stdout.write(`${version}\n`);
+    return 0;
+  }
+  if (command === "install") {
+    return installCommand(args, {
+      root,
+      version,
+      platform,
+      stdin,
+      stdout,
+      stderr,
+      execute,
+      inspectResources
+    });
+  }
+  if (command === "init") {
+    assertNoArgs(args, "init");
+    const result = await initializeInstallation(root, { version });
+    stdout.write(`SpaceApp initialized at ${root}\n`);
+    if (result.setupToken) {
+      stdout.write(`One-time setup token: ${result.setupToken}\n`);
+      stdout.write("Store it temporarily; it expires after first owner setup.\n");
+    }
+    stdout.write("Next: spaceapp doctor && spaceapp up && spaceapp open\n");
+    return 0;
+  }
+
+  const config = await loadConfig(root);
+  await writeRuntimeFiles(root, config);
+
+  if (["up", "down", "status", "logs"].includes(command)) {
+    assertNoArgs(args, command);
+    return execute(composeCommand(command, root, { profile: config.profile }), { stdin, stdout, stderr });
+  }
+  if (command === "open") {
+    assertNoArgs(args, "open");
+    return openBrowser(`http://${config.bindHost}:${config.port}`, platform, execute, { stdin, stdout, stderr });
+  }
+  if (command === "doctor") {
+    assertNoArgs(args, "doctor");
+    return doctor({ root, platform, stdout, stderr, execute, stdin, inspectResources });
+  }
+  if (command === "workspace") {
+    return workspaceCommand(args, { root, config, stdout });
+  }
+  if (command === "credentials") {
+    return credentialsCommand(args, { root, config, stdin, stdout, stderr, execute });
+  }
+  if (command === "provider") {
+    return providerCommand(args, { root, config, stdin, stdout, stderr, execute });
+  }
+  if (command === "owner") {
+    return ownerCommand(args, { root, config, stdin, stdout, stderr, execute });
+  }
+  if (command === "update") {
+    return updateCommand(args, { root, config, version, stdin, stdout, stderr, execute });
+  }
+  if (command === "rollback") {
+    assertNoArgs(args, "rollback");
+    if (!config.previousVersion) {
+      throw new Error("No previous SpaceApp version is recorded.");
+    }
+    const rollback = {
+      ...config,
+      version: config.previousVersion,
+      previousVersion: config.version
+    };
+    await writeRuntimeFiles(root, rollback);
+    const pullCode = await execute(composeCommand("pull", root, { profile: rollback.profile }), { stdin, stdout, stderr });
+    if (pullCode !== 0) {
+      await writeRuntimeFiles(root, config);
+      return pullCode;
+    }
+    const upCode = await execute(composeCommand("up", root, { profile: rollback.profile }), { stdin, stdout, stderr });
+    if (upCode !== 0) {
+      await writeRuntimeFiles(root, config);
+      return upCode;
+    }
+    await saveConfig(root, rollback);
+    stdout.write(`Rolled back to SpaceApp ${rollback.version}.\n`);
+    return 0;
+  }
+  if (command === "backup") {
+    assertNoArgs(args, command);
+    return execute(composeCommand("backup", root, { profile: config.profile }), { stdin, stdout, stderr });
+  }
+  if (command === "restore") {
+    assertNoArgs(args, command);
+    const confirmation = await readSecret(
+      stdin,
+      stdout,
+      "Type RESTORE to replace current SpaceApp data with the latest backup: ",
+      { mask: false }
+    );
+    if (confirmation !== "RESTORE") {
+      throw new Error("Restore cancelled.");
+    }
+    const backupId = await selectLatestBackupId(root);
+    const backupCode = await execute(composeCommand("backup", root, { profile: config.profile }), { stdin, stdout, stderr });
+    if (backupCode !== 0) return backupCode;
+    const stopCode = await execute(composeCommand("stopForRestore", root, { profile: config.profile }), { stdin, stdout, stderr });
+    if (stopCode !== 0) return stopCode;
+    const restoreCode = await execute(
+      composeCommand("restore", root, { backupId, profile: config.profile }),
+      { stdin, stdout, stderr }
+    );
+    if (restoreCode !== 0) return restoreCode;
+    return execute(composeCommand("up", root, { profile: config.profile }), { stdin, stdout, stderr });
+  }
+  if (command === "uninstall") {
+    if (args.length === 0) {
+      const code = await execute(composeCommand("down", root, { profile: config.profile }), { stdin, stdout, stderr });
+      if (code === 0) {
+        stdout.write(`Containers removed. Data and configuration remain at ${root}.\n`);
+      }
+      return code;
+    }
+    if (args.length === 1 && args[0] === "--purge-data") {
+      const confirmation = await readSecret(stdin, stdout, "Type DELETE to remove Docker volumes: ", { mask: false });
+      if (confirmation !== "DELETE") {
+        throw new Error("Purge cancelled.");
+      }
+      return execute(composeCommand("purge", root, { profile: config.profile }), { stdin, stdout, stderr });
+    }
+    throw new Error("Usage: spaceapp uninstall [--purge-data]");
+  }
+
+  throw new Error(`Unknown command "${command}". Run "spaceapp help".`);
+}
+
+async function installCommand(args, {
+  root,
+  version,
+  platform,
+  stdin,
+  stdout,
+  stderr,
+  execute,
+  inspectResources
+}) {
+  const { requestedProfile, noOpen } = parseInstallArgs(args);
+  const resources = await inspectResources(root);
+  const profile = resolveInstallProfile(requestedProfile, resources.totalMemoryBytes);
+  const result = await initializeInstallation(root, { version, profile });
+
+  stdout.write(
+    `Selected profile: ${profile} (${formatGigabytes(resources.totalMemoryBytes)} GB system memory detected).\n`
+  );
+  stdout.write(`SpaceApp installation root: ${root}\n`);
+  if (result.setupToken) {
+    stdout.write(`One-time setup token: ${result.setupToken}\n`);
+    stdout.write("Store it temporarily; it expires after first owner setup.\n");
+  }
+
+  const doctorCode = await doctor({
+    root,
+    platform,
+    stdout,
+    stderr,
+    execute,
+    stdin,
+    inspectResources,
+    resources
+  });
+  if (doctorCode !== 0) {
+    stderr.write("Installation stopped before downloading images. Fix the failed checks and run the same command again.\n");
+    return doctorCode;
+  }
+  const pullCode = await execute(composeCommand("pull", root, { profile }), { stdin, stdout, stderr });
+  if (pullCode !== 0) return pullCode;
+  const upCode = await execute(composeCommand("up", root, { profile }), { stdin, stdout, stderr });
+  if (upCode !== 0) return upCode;
+
+  const url = `http://${result.config.bindHost}:${result.config.port}`;
+  stdout.write(`SpaceApp is running at ${url}\n`);
+  stdout.write('Next: add CLI credentials with "spaceapp credentials set <provider>".\n');
+  if (noOpen) return 0;
+  return openBrowser(url, platform, execute, { stdin, stdout, stderr });
+}
+
+function parseInstallArgs(args) {
+  let requestedProfile = "auto";
+  let noOpen = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === "--no-open" && !noOpen) {
+      noOpen = true;
+      continue;
+    }
+    if (argument === "--profile" && index + 1 < args.length) {
+      requestedProfile = args[index + 1];
+      index += 1;
+      continue;
+    }
+    if (argument.startsWith("--profile=")) {
+      requestedProfile = argument.slice("--profile=".length);
+      continue;
+    }
+    throw new Error("Usage: spaceapp install [--profile auto|light|standard] [--no-open]");
+  }
+  if (!["auto", "light", "standard"].includes(requestedProfile)) {
+    throw new Error("Usage: spaceapp install [--profile auto|light|standard] [--no-open]");
+  }
+  return { requestedProfile, noOpen };
+}
+
+async function workspaceCommand(args, { root, config, stdout }) {
+  const [action, identity, ...rest] = args;
+  if (action === "add") {
+    if (!identity || rest.some((arg) => arg !== "--read-only")) {
+      throw new Error("Usage: spaceapp workspace add <absolute-path> [--read-only]");
+    }
+    const updated = await addWorkspace(config, identity, { readOnly: rest.includes("--read-only") });
+    await saveConfig(root, updated);
+    await writeRuntimeFiles(root, updated);
+    stdout.write(`Workspace registered: ${identity}\n`);
+    return 0;
+  }
+  if (action === "remove") {
+    if (!identity || rest.length > 0) {
+      throw new Error("Usage: spaceapp workspace remove <id-or-absolute-path>");
+    }
+    const updated = removeWorkspace(config, identity);
+    await saveConfig(root, updated);
+    await writeRuntimeFiles(root, updated);
+    stdout.write(`Workspace removed: ${identity}\n`);
+    return 0;
+  }
+  if (action === "list" && args.length === 1) {
+    stdout.write(`${JSON.stringify(config.workspaces, null, 2)}\n`);
+    return 0;
+  }
+  throw new Error("Usage: spaceapp workspace <add|remove|list>");
+}
+
+async function credentialsCommand(args, { root, config, stdin, stdout, stderr, execute }) {
+  const [action, provider, ...rest] = args;
+  if (action === "list" && args.length === 1) {
+    stdout.write(`${JSON.stringify(credentialProviders(), null, 2)}\n`);
+    return 0;
+  }
+  if (action === "set") {
+    if (!provider || rest.length > 0) {
+      throw new Error("Usage: spaceapp credentials set <provider> (the value is read from stdin)");
+    }
+    const value = await readSecret(stdin, stdout, `Enter ${provider} credential: `);
+    await writeCredential(root, provider, value);
+    const syncCode = await execute(
+      composeCommand("syncCredentials", root, { profile: config.profile }),
+      { stdin, stdout, stderr }
+    );
+    if (syncCode !== 0) {
+      stderr.write(`Credential stored for ${provider}, but the CLI service could not be refreshed.\n`);
+      return syncCode;
+    }
+    stdout.write(`Credential stored and applied for ${provider}.\n`);
+    return syncCode;
+  }
+  if (action === "remove") {
+    if (!provider || rest.length > 0) {
+      throw new Error("Usage: spaceapp credentials remove <provider>");
+    }
+    const removed = await removeCredential(root, provider);
+    const syncCode = await execute(
+      composeCommand("syncCredentials", root, { profile: config.profile }),
+      { stdin, stdout, stderr }
+    );
+    if (syncCode !== 0) {
+      stderr.write(`Credential file state changed for ${provider}, but the CLI service could not be refreshed.\n`);
+      return syncCode;
+    }
+    stdout.write(removed ? `Credential removed and applied for ${provider}.\n` : `No credential stored for ${provider}.\n`);
+    return syncCode;
+  }
+  throw new Error("Usage: spaceapp credentials <set|remove|list>");
+}
+
+async function providerCommand(args, { root, config, stdin, stdout, stderr, execute }) {
+  if (args.length !== 2 || args[0] !== "install" || args[1] !== "claude") {
+    throw new Error("Usage: spaceapp provider install claude");
+  }
+  stdout.write("Installing Claude Code from Anthropic into this installation's private provider volume.\n");
+  return execute(composeCommand("installClaude", root, { profile: config.profile }), { stdin, stdout, stderr });
+}
+
+async function ownerCommand(args, { root, config, stdin, stdout, stderr, execute }) {
+  if (args.length === 1 && args[0] === "rotate-setup-token") {
+    const token = randomBytes(32).toString("base64url");
+    const code = await execute(composeCommand("rotateOwnerSetupToken", root, { profile: config.profile }), {
+      stdin,
+      stdout,
+      stderr,
+      input: `${token}\n`
+    });
+    if (code !== 0) return code;
+    await writeSetupToken(root, token);
+    stdout.write(`New one-time setup token: ${token}\n`);
+    stdout.write("It expires in 15 minutes and only works before the first owner is claimed.\n");
+    return 0;
+  }
+  if (args.length !== 1 || args[0] !== "reset-password") {
+    throw new Error("Usage: spaceapp owner <reset-password|rotate-setup-token>");
+  }
+  const password = await readSecret(stdin, stdout, "New owner password: ");
+  if (password.length < 12) {
+    throw new Error("Owner password must be at least 12 characters.");
+  }
+  return execute(composeCommand("resetOwnerPassword", root, { profile: config.profile }), {
+    stdin,
+    stdout,
+    stderr,
+    input: `${password}\n`
+  });
+}
+
+async function updateCommand(args, { root, config, version, stdin, stdout, stderr, execute }) {
+  if (args.length > 1) {
+    throw new Error("Usage: spaceapp update [version]");
+  }
+  const targetVersion = args[0] || version;
+  const updated = {
+    ...config,
+    version: targetVersion,
+    previousVersion: config.version
+  };
+  await writeRuntimeFiles(root, updated);
+  const pullCode = await execute(composeCommand("pull", root, { profile: updated.profile }), { stdin, stdout, stderr });
+  if (pullCode !== 0) {
+    await writeRuntimeFiles(root, config);
+    return pullCode;
+  }
+  const upCode = await execute(composeCommand("up", root, { profile: updated.profile }), { stdin, stdout, stderr });
+  if (upCode !== 0) {
+    await writeRuntimeFiles(root, config);
+    return upCode;
+  }
+  await saveConfig(root, updated);
+  stdout.write(`Updated to SpaceApp ${targetVersion}.\n`);
+  return 0;
+}
+
+async function doctor({
+  root,
+  platform,
+  stdout,
+  stderr,
+  execute,
+  stdin,
+  inspectResources,
+  resources
+}) {
+  const detectedResources = resources ?? await inspectResources(root);
+  const checks = [
+    { name: "Node.js", ok: Number(process.versions.node.split(".")[0]) >= 20, detail: process.version },
+    { name: "Configuration", ok: true, detail: root },
+    ...installResourceChecks(detectedResources)
+  ];
+  let dockerMissing = false;
+  for (const probe of [
+    { name: "Docker", command: "docker", args: ["--version"] },
+    { name: "Docker Compose", command: "docker", args: ["compose", "version"] }
+  ]) {
+    const code = await execute(probe, { stdin, stdout: null, stderr: null });
+    if (code !== 0) dockerMissing = true;
+    checks.push({ name: probe.name, ok: code === 0, detail: code === 0 ? "available" : "missing" });
+  }
+  for (const check of checks) {
+    (check.ok ? stdout : stderr).write(`${check.ok ? "PASS" : "FAIL"} ${check.name}: ${check.detail}\n`);
+  }
+  if (dockerMissing) {
+    stderr.write(`${dockerInstallHelp(platform)}\n`);
+  }
+  return checks.every((check) => check.ok) ? 0 : 1;
+}
+
+export async function readSecret(stdin, stdout, prompt, { mask = true } = {}) {
+  stdout.write(prompt);
+  if (!stdin.isTTY || typeof stdin.setRawMode !== "function") {
+    let value = "";
+    for await (const chunk of stdin) {
+      value += chunk;
+    }
+    stdout.write("\n");
+    return value.replace(/[\r\n]+$/, "");
+  }
+  stdin.setRawMode(true);
+  stdin.resume();
+  stdin.setEncoding("utf8");
+  let value = "";
+  try {
+    for await (const chunk of stdin) {
+      for (const character of chunk) {
+        if (character === "\u0003") {
+          throw new Error("Input cancelled.");
+        }
+        if (character === "\r" || character === "\n") {
+          stdout.write("\n");
+          return value;
+        }
+        if (character === "\u007f") {
+          if (value.length > 0) {
+            value = value.slice(0, -1);
+            if (mask) stdout.write("\b \b");
+          }
+          continue;
+        }
+        value += character;
+        if (mask) stdout.write("*");
+      }
+    }
+    return value;
+  } finally {
+    stdin.setRawMode(false);
+    stdin.pause();
+  }
+}
+
+export function executeCommand(spec, { stdin, stdout, stderr, input } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(spec.command, spec.args, {
+      shell: false,
+      stdio: [input === undefined ? (stdin || "inherit") : "pipe", stdout || "ignore", stderr || "ignore"]
+    });
+    child.once("error", (error) => {
+      if (error?.code === "ENOENT") {
+        resolve(127);
+      } else {
+        reject(error);
+      }
+    });
+    child.once("exit", (code, signal) => {
+      resolve(code ?? (signal ? 1 : 0));
+    });
+    if (input !== undefined) {
+      child.stdin.end(input);
+    }
+  });
+}
+
+function openBrowser(url, platform, execute, io) {
+  if (platform === "darwin") {
+    return execute({ command: "open", args: [url] }, io);
+  }
+  if (platform === "win32") {
+    return execute({ command: "cmd", args: ["/d", "/s", "/c", "start", "", url] }, io);
+  }
+  return execute({ command: "xdg-open", args: [url] }, io);
+}
+
+function assertNoArgs(args, command) {
+  if (args.length > 0) {
+    throw new Error(`Usage: spaceapp ${command}`);
+  }
+}
+
+function dockerInstallHelp(platform) {
+  if (platform === "win32") {
+    return "Install Docker Desktop with its WSL2 backend, start it, then run spaceapp install again: https://docs.docker.com/desktop/setup/install/windows-install/";
+  }
+  if (platform === "darwin") {
+    return "Install and start Docker Desktop for macOS, then run spaceapp install again: https://docs.docker.com/desktop/setup/install/mac-install/";
+  }
+  return "Install Docker Engine and the Docker Compose plugin, then run spaceapp install again: https://docs.docker.com/engine/install/";
+}
+
+function formatGigabytes(bytes) {
+  return Math.floor((bytes / 1024 ** 3) * 10) / 10;
+}
+
+async function packageVersion() {
+  const packageJson = new URL("../package.json", import.meta.url);
+  return JSON.parse(await readFile(packageJson, "utf8")).version;
+}
+
+function helpText() {
+  return `SpaceApp self-hosted launcher
+
+Usage: spaceapp <command>
+
+  init                              Create a local SpaceApp installation
+  install [--profile auto|light|standard] [--no-open]
+                                    Initialize, check, download, start, and open
+  up | down | status | logs         Manage the Docker application
+  open                              Open the local web application
+  doctor                            Check Node, Docker, and Compose
+  update [version] | rollback       Update or roll back images
+  backup | restore                  Back up or restore persistent state
+  workspace add <path> [--read-only]
+  workspace remove <id-or-path>
+  workspace list
+  credentials set <provider>        Read a credential from masked stdin
+  credentials remove <provider>
+  credentials list
+  provider install claude           Owner-initiated Anthropic package install
+  owner reset-password              Read the new password from masked stdin
+  owner rotate-setup-token          Replace an expired unclaimed setup token
+  uninstall [--purge-data]          Remove containers; keep data by default
+`;
+}