pikasTech-unidesk/scripts/cli.ts

import { readConfig } from "./src/config";
import { debugDispatch, debugHealth, debugTask, isDebugDispatchCommand, type DebugDispatchCommand } from "./src/debug";
import { isRebuildableService, rebuildService, stackLogs, stackStatus, startStack, stopStack } from "./src/docker";
import { runE2E } from "./src/e2e";
import { emitError, emitJson } from "./src/output";
import { jobWithTail, listJobs, readJob, runJob } from "./src/jobs";
import { runChecks } from "./src/check";
import { runSsh } from "./src/ssh";
import { extractRemoteCliOptions, runRemoteCli } from "./src/remote";

const remoteOptions = extractRemoteCliOptions(process.argv.slice(2));
const args = remoteOptions.args;
const commandName = args.join(" ") || "help";

function help(): unknown {
  return {
    entry: "bun scripts/cli.ts",
    output: "json",
    commands: [
      { command: "help", description: "List supported commands." },
      { command: "--main-server-ip <ip> <command>", description: "Run selected commands through the public frontend API; use --main-server-key only for legacy SSH transport." },
      { command: "config show", description: "Validate and print config.json as the single source of truth." },
      { command: "check", description: "Run config, TypeScript, file presence, and docker-compose config checks." },
      { command: "server start", description: "Fire-and-forget build/start for database, backend-core, frontend, and provider gateway." },
      { command: "server stop", description: "Fire-and-forget docker-compose down for the fixed UniDesk stack." },
      { command: "server status", description: "Show fixed ports, containers, service health, and public URLs." },
      { command: "server logs [--tail-bytes N]", description: "Return bounded tails from file logs and docker logs." },
      { command: "server rebuild <backend-core|frontend|provider-gateway>", description: "Build first, then label-replace one service without Docker Compose v1 recreate fallback." },
      { command: "ssh <providerId> [ssh-like args...]", description: "Open a Host SSH / WSL SSH maintenance session through the provider-gateway bridge." },
      { command: "job list", description: "List async jobs from .state/jobs." },
      { command: "job status <jobId|latest> [--tail-bytes N]", description: "Show job state with bounded stdout/stderr tails." },
      { command: "debug health", description: "Probe internal core, nodes, system/Docker status, frontend, provider ingress, and public boundary." },
      { command: "debug dispatch [providerId] [docker.ps|provider.upgrade|host.ssh|echo] [--wait-ms N]", description: "Submit a real internal-core dispatch request for CLI debugging." },
      { command: "debug task <taskId|latest>", description: "Read a dispatched task record from internal core for CLI debugging." },
      { command: "e2e run", description: "Run public frontend/provider, internal core/database, and Playwright login E2E checks." },
    ],
  };
}

function numberOption(name: string, defaultValue: number): number {
  const index = args.indexOf(name);
  if (index === -1) return defaultValue;
  const raw = args[index + 1];
  const value = Number(raw);
  if (!Number.isInteger(value) || value <= 0) throw new Error(`${name} must be a positive integer`);
  return value;
}

function stringOption(name: string): string | undefined {
  const index = args.indexOf(name);
  if (index === -1) return undefined;
  const raw = args[index + 1];
  if (raw === undefined || raw.length === 0) throw new Error(`${name} requires a non-empty value`);
  return raw;
}

function jsonOption(name: string): Record<string, unknown> | undefined {
  const raw = stringOption(name);
  if (raw === undefined) return undefined;
  const parsed = JSON.parse(raw) as unknown;
  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error(`${name} must be a JSON object`);
  return parsed as Record<string, unknown>;
}

function dispatchPayload(command: DebugDispatchCommand): Record<string, unknown> {
  const explicit = jsonOption("--payload-json") ?? {};
  if (command === "provider.upgrade") {
    return { source: "cli-debug", mode: stringOption("--mode") ?? stringOption("--upgrade-mode") ?? "plan", ...explicit };
  }
  if (command === "host.ssh") {
    const sshCommand = stringOption("--ssh-command");
    return {
      source: "cli-debug",
      mode: sshCommand === undefined ? "probe" : "exec",
      ...(sshCommand === undefined ? {} : { command: sshCommand }),
      ...(stringOption("--cwd") === undefined ? {} : { cwd: stringOption("--cwd") }),
      ...(args.includes("--timeout-ms") ? { timeoutMs: numberOption("--timeout-ms", 8000) } : {}),
      ...explicit,
    };
  }
  return { source: "cli-debug", ...explicit };
}

function latestJobId(): string {
  const jobs = listJobs();
  if (jobs.length === 0) throw new Error("No jobs found");
  return jobs[0].id;
}

async function main(): Promise<void> {
  if (remoteOptions.host !== null) {
    process.exitCode = await runRemoteCli(remoteOptions, readConfig());
    return;
  }

  const [top, sub, third, fourth] = args;
  if (top === undefined || top === "help" || top === "--help" || top === "-h") {
    emitJson(commandName, help());
    return;
  }

  if (top === "internal" && sub === "run-job") {
    if (!third) throw new Error("internal run-job requires job id");
    emitJson(commandName, await runJob(third));
    return;
  }

  const config = readConfig();

  if (top === "ssh") {
    const exitCode = await runSsh(config, sub ?? "", args.slice(2));
    process.exitCode = exitCode;
    return;
  }

  if (top === "config" && sub === "show") {
    emitJson(commandName, { config });
    return;
  }

  if (top === "check") {
    const result = runChecks(config);
    emitJson(commandName, result, result.ok);
    if (!result.ok) process.exitCode = 1;
    return;
  }

  if (top === "server") {
    if (sub === "start") {
      emitJson(commandName, startStack(config));
      return;
    }
    if (sub === "stop") {
      emitJson(commandName, stopStack(config));
      return;
    }
    if (sub === "status") {
      emitJson(commandName, await stackStatus(config));
      return;
    }
    if (sub === "logs") {
      emitJson(commandName, stackLogs(config, numberOption("--tail-bytes", 3000)));
      return;
    }
    if (sub === "rebuild") {
      if (!isRebuildableService(third)) {
        throw new Error("server rebuild requires one of: backend-core, frontend, provider-gateway");
      }
      emitJson(commandName, rebuildService(config, third));
      return;
    }
  }

  if (top === "job") {
    if (sub === "list") {
      emitJson(commandName, { jobs: listJobs() });
      return;
    }
    if (sub === "status") {
      const id = third === "latest" || third === undefined ? latestJobId() : third;
      emitJson(commandName, { job: jobWithTail(readJob(id), numberOption("--tail-bytes", 12000)) });
      return;
    }
  }

  if (top === "debug") {
    if (sub === "health") {
      emitJson(commandName, await debugHealth(config));
      return;
    }
    if (sub === "dispatch") {
      const providerId = isDebugDispatchCommand(third) ? config.providerGateway.id : third ?? config.providerGateway.id;
      const commandArg = isDebugDispatchCommand(third) ? third : fourth;
      const dispatchCommand = isDebugDispatchCommand(commandArg) ? commandArg : "docker.ps";
      emitJson(commandName, await debugDispatch(config, providerId, dispatchCommand, dispatchPayload(dispatchCommand), numberOption("--wait-ms", 0)));
      return;
    }
    if (sub === "task") {
      emitJson(commandName, await debugTask(config, third ?? "latest"));
      return;
    }
  }

  if (top === "e2e" && sub === "run") {
    const result = await runE2E(config);
    const ok = (result as { ok?: unknown }).ok === true;
    emitJson(commandName, result, ok);
    if (!ok) process.exitCode = 1;
    return;
  }

  throw new Error(`Unknown command: ${commandName}`);
}

main().catch((error) => {
  emitError(commandName, error);
  process.exitCode = 1;
});