@touchtechclub/simbox 0.0.0-stage → 0.1.7

package/dist/cli.js

@@ -0,0 +1,585 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import pc4 from "picocolors";
+
+// src/config.ts
+import { mkdirSync, readFileSync, writeFileSync, chmodSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+
+// ../../packages/shared/src/constants.ts
+var PROD_API_URL = "https://api.simbox.touchtech.club";
+// src/config.ts
+var DEFAULT_WEB_URL = "https://simbox.touchtech.club";
+function stripTrailingSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+function apiBaseUrl() {
+  return stripTrailingSlash(process.env.SIMBOX_API_URL ?? PROD_API_URL);
+}
+function webBaseUrl() {
+  return stripTrailingSlash(process.env.SIMBOX_WEB_URL ?? DEFAULT_WEB_URL);
+}
+function configDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg && xdg.length > 0)
+    return join(xdg, "simbox");
+  return join(homedir(), ".config", "simbox");
+}
+function authPath() {
+  return join(configDir(), "auth.json");
+}
+function loadToken() {
+  try {
+    const raw = readFileSync(authPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.token === "string" && parsed.token.length > 0) {
+      return parsed.token;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function saveToken(token, login) {
+  mkdirSync(configDir(), { recursive: true });
+  const data = { token, login, createdAt: Date.now() };
+  writeFileSync(authPath(), JSON.stringify(data, null, 2) + `
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  try {
+    chmodSync(authPath(), 384);
+  } catch {
+    if (platform() === "win32")
+      return;
+  }
+}
+function requireToken() {
+  const token = loadToken();
+  if (!token) {
+    process.stderr.write("Not logged in. Run `simbox login` first.\n");
+    process.exit(1);
+  }
+  return token;
+}
+
+// src/client.ts
+class CliError extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+}
+
+class ApiRequestError extends Error {
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "ApiRequestError";
+  }
+}
+async function api(path, opts = {}) {
+  const headers = {
+    accept: "application/json"
+  };
+  const useAuth = opts.auth !== false;
+  const token = opts.token ?? (useAuth ? loadToken() : null);
+  if (token)
+    headers.authorization = `Bearer ${token}`;
+  if (opts.body !== undefined)
+    headers["content-type"] = "application/json";
+  let res;
+  try {
+    res = await fetch(`${apiBaseUrl()}${path}`, {
+      method: opts.method ?? "GET",
+      headers,
+      body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined
+    });
+  } catch (err) {
+    throw new CliError(`Could not reach ${apiBaseUrl()} — check your connection. (${err.message})`);
+  }
+  if (res.status === 401 || res.status === 403) {
+    throw new ApiRequestError(res.status, "unauthorized", "Your session is invalid or expired. Run `simbox login`.");
+  }
+  if (res.status === 404) {
+    const body = await parseErrorBody(res);
+    throw new ApiRequestError(404, body?.error ?? "not_found", body?.message ?? "Not found.");
+  }
+  if (!res.ok) {
+    const body = await parseErrorBody(res);
+    throw new ApiRequestError(res.status, body?.error ?? `http_${res.status}`, body?.message ?? `Request failed (HTTP ${res.status}).`);
+  }
+  return await res.json();
+}
+async function parseErrorBody(res) {
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+var CLI_CLIENT_ID = "simbox-cli";
+var startDeviceFlow = () => api("/api/auth/device/code", {
+  method: "POST",
+  auth: false,
+  body: { client_id: CLI_CLIENT_ID }
+});
+async function pollDeviceToken(deviceCode) {
+  let res;
+  try {
+    res = await fetch(`${apiBaseUrl()}/api/auth/device/token`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: deviceCode,
+        client_id: CLI_CLIENT_ID
+      })
+    });
+  } catch (err) {
+    throw new CliError(`Could not reach ${apiBaseUrl()} — check your connection. (${err.message})`);
+  }
+  const body = await res.json().catch(() => null);
+  if (res.ok && body?.access_token)
+    return { ok: true, token: body.access_token };
+  return {
+    ok: false,
+    error: body?.error ?? `http_${res.status}`,
+    description: body?.error_description
+  };
+}
+var me = async (token) => (await api("/v1/me", { token })).user;
+var repoStatus = () => api("/v1/repo/status");
+var repairRepo = () => api("/v1/repo/repair", {
+  method: "POST"
+});
+var ensureRun = (fresh) => api("/v1/runs/ensure", { method: "POST", body: { new: fresh } });
+async function currentRun() {
+  try {
+    const res = await api("/v1/runs/current");
+    return res.run;
+  } catch (err) {
+    if (err instanceof ApiRequestError && (err.status === 404 || err.code === "no_run")) {
+      return null;
+    }
+    throw err;
+  }
+}
+var stopRun = (runId) => api(`/v1/runs/${encodeURIComponent(runId)}/stop`, {
+  method: "POST"
+});
+function friendlyError(err) {
+  if (err instanceof CliError)
+    return err;
+  if (err instanceof ApiRequestError) {
+    if (err.code === "repo_not_connected" || err.code === "no_repo") {
+      return new CliError(`${err.message}
+Run \`simbox init\` to connect a repo.`);
+    }
+    if (err.code === "at_capacity") {
+      return new CliError(`${err.message}
+That run is full — try \`simbox sim --new\` for a fresh one.`);
+    }
+    if (err.code === "needs_repair" || err.code === "repo_needs_repair" || err.code === "repo_not_ready" || err.code === "dispatch_failed") {
+      return new CliError(`${err.message}
+Run \`simbox repair\` to fix the repo setup.`);
+    }
+    return new CliError(err.message);
+  }
+  if (err instanceof Error)
+    return new CliError(err.message);
+  return new CliError(String(err));
+}
+
+// src/commands.ts
+import { rmSync } from "node:fs";
+import pc3 from "picocolors";
+
+// src/connect.ts
+import { spawnSync } from "node:child_process";
+import pc from "picocolors";
+function daemonBaseUrl(tunnelUrl) {
+  return `${tunnelUrl.replace(/\/+$/, "")}/agent-device`;
+}
+function findAgentDevice() {
+  const which = process.platform === "win32" ? "where" : "which";
+  const res = spawnSync(which, ["agent-device"], { encoding: "utf8" });
+  if (res.status !== 0)
+    return null;
+  const first = (res.stdout ?? "").split(/\r?\n/).find((l) => l.trim().length > 0);
+  return first?.trim() ?? null;
+}
+function connectFlow(info, quiet = false) {
+  const out = quiet ? process.stderr : process.stdout;
+  const base = daemonBaseUrl(info.tunnelUrl);
+  const bin = findAgentDevice();
+  if (bin) {
+    out.write(`${pc.green("▶")} Connecting via ${pc.bold("agent-device")}…
+`);
+    const res = spawnSync(bin, ["connect", "proxy", "--daemon-base-url", base], {
+      stdio: quiet ? ["inherit", "ignore", "inherit"] : "inherit",
+      env: { ...process.env, AGENT_DEVICE_DAEMON_AUTH_TOKEN: info.daemonToken }
+    });
+    if (res.error || res.status !== 0) {
+      out.write(pc.yellow(`  agent-device connect failed — use the manual commands below.
+`));
+    } else {
+      out.write(`
+Next: ${pc.cyan("agent-device open <app> --platform ios")} ${pc.dim("(or --platform android)")}
+
+`);
+    }
+  } else {
+    out.write(`${pc.yellow("!")} ${pc.bold("agent-device")} not found on PATH — install it, then:
+`);
+  }
+  out.write(pc.dim(`  manual connect:
+`));
+  out.write(`  ${pc.cyan(`export AGENT_DEVICE_DAEMON_AUTH_TOKEN=${info.daemonToken}`)}
+`);
+  out.write(`  ${pc.cyan(`agent-device connect proxy --daemon-base-url ${base}`)}
+`);
+  out.write(`  ${pc.cyan("agent-device open <app> --platform ios")}
+`);
+}
+
+// src/open.ts
+import open from "open";
+async function openInBrowser(url) {
+  try {
+    await open(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/util.ts
+import pc2 from "picocolors";
+var isTTY = process.stderr.isTTY === true;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function fmtElapsed(ms) {
+  const s = Math.max(0, Math.floor(ms / 1000));
+  const m = Math.floor(s / 60);
+  const r = s % 60;
+  return `${m}:${String(r).padStart(2, "0")}`;
+}
+function fmtCountdown(expiresAt) {
+  const ms = expiresAt - Date.now();
+  if (ms <= 0)
+    return "expired";
+  const s = Math.floor(ms / 1000);
+  const h = Math.floor(s / 3600);
+  const m = Math.floor(s % 3600 / 60);
+  const sec = s % 60;
+  if (h > 0)
+    return `${h}h ${m}m`;
+  if (m > 0)
+    return `${m}m ${sec}s`;
+  return `${sec}s`;
+}
+var FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+class Spinner {
+  label;
+  frame = 0;
+  timer = null;
+  lastMsg = "";
+  start = Date.now();
+  constructor(label) {
+    this.label = label;
+  }
+  begin() {
+    this.start = Date.now();
+    if (!isTTY) {
+      process.stderr.write(`${this.label}
+`);
+      this.lastMsg = this.label;
+      return;
+    }
+    this.render();
+    this.timer = setInterval(() => this.render(), 80);
+  }
+  set(label) {
+    if (label === this.label)
+      return;
+    this.label = label;
+    if (!isTTY) {
+      process.stderr.write(`${label}
+`);
+      this.lastMsg = label;
+      return;
+    }
+    this.render();
+  }
+  render() {
+    const glyph = FRAMES[this.frame++ % FRAMES.length] ?? "⠋";
+    const elapsed = pc2.dim(`(${fmtElapsed(Date.now() - this.start)})`);
+    this.clearLine();
+    process.stderr.write(`${pc2.cyan(glyph)} ${this.label} ${elapsed}`);
+  }
+  clearLine() {
+    if (isTTY)
+      process.stderr.write("\r\x1B[K");
+  }
+  stop() {
+    if (this.timer)
+      clearInterval(this.timer);
+    this.timer = null;
+    this.clearLine();
+  }
+  succeed(msg) {
+    this.finish(pc2.green("✔"), msg);
+  }
+  fail(msg) {
+    this.finish(pc2.red("✖"), msg);
+  }
+  finish(symbol, msg) {
+    if (this.timer)
+      clearInterval(this.timer);
+    this.timer = null;
+    this.clearLine();
+    const elapsed = pc2.dim(`(${fmtElapsed(Date.now() - this.start)})`);
+    process.stderr.write(`${symbol} ${msg} ${elapsed}
+`);
+  }
+}
+
+// src/commands.ts
+async function cmdLogin() {
+  const flow = await startDeviceFlow();
+  console.log(`
+Your login code: ${pc3.bold(pc3.cyan(flow.user_code))}
+`);
+  const verifyUrl = flow.verification_uri_complete ?? flow.verification_uri;
+  const opened = await openInBrowser(verifyUrl);
+  console.log(opened ? `Opened ${pc3.underline(verifyUrl)} — approve the code in your browser.` : `Open ${pc3.underline(verifyUrl)} to approve the code.`);
+  const spinner = new Spinner("Waiting for approval");
+  spinner.begin();
+  const deadline = Date.now() + flow.expires_in * 1000;
+  let interval = Math.max(1, flow.interval) * 1000;
+  let token = null;
+  while (Date.now() < deadline) {
+    await sleep(interval);
+    const res = await pollDeviceToken(flow.device_code);
+    if (res.ok) {
+      token = res.token;
+      break;
+    }
+    switch (res.error) {
+      case "authorization_pending":
+        continue;
+      case "slow_down":
+        interval += 5000;
+        continue;
+      case "access_denied":
+        spinner.fail("Denied");
+        throw new CliError("Login was denied in the browser.");
+      case "expired_token":
+        spinner.fail("Device code expired");
+        throw new CliError("Login code expired — run `simbox login` again.");
+      default:
+        spinner.fail("Login failed");
+        throw new CliError(`Login failed: ${res.description ?? res.error}. Run \`simbox login\` again.`);
+    }
+  }
+  if (!token) {
+    spinner.fail("Timed out");
+    throw new CliError("Login timed out — run `simbox login` again.");
+  }
+  const user = await me(token);
+  saveToken(token, user.login);
+  spinner.succeed(`Logged in as ${pc3.bold(user.login)}`);
+}
+var INIT_TIMEOUT_MS = 10 * 60 * 1000;
+var INIT_POLL_MS = 3000;
+async function cmdInit() {
+  const first = await repoStatus();
+  if (first.connected && first.repo) {
+    printRepoConnected(first.repo);
+    return;
+  }
+  const url = `${webBaseUrl()}/onboarding`;
+  const opened = await openInBrowser(url);
+  console.log(opened ? `Opened ${pc3.underline(url)} — install the GitHub App and pick a repo.` : `Open ${pc3.underline(url)} to install the GitHub App and pick a repo.`);
+  const spinner = new Spinner("Waiting for repo connection");
+  spinner.begin();
+  const deadline = Date.now() + INIT_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    await sleep(INIT_POLL_MS);
+    const status = await repoStatus();
+    if (status.connected && status.repo) {
+      spinner.succeed("Repo connected");
+      printRepoConnected(status.repo);
+      return;
+    }
+  }
+  spinner.fail("Timed out waiting for repo connection");
+  throw new CliError(`No repo connected after 10 minutes. Finish onboarding at ${webBaseUrl()}/onboarding then re-run \`simbox init\`.`);
+}
+function printRepoConnected(repo) {
+  console.log(`Repo connected: ${pc3.bold(repo.fullName)} ${pc3.dim(`(${repo.state})`)}`);
+  if (repo.state === "pending_pr" && repo.prUrl) {
+    console.log(`Your default branch is protected — merge ${pc3.underline(repo.prUrl)} to activate Simbox.`);
+  }
+  if (repo.private) {
+    console.log(pc3.yellow("Note: private repos are billed at the 10× macOS minute multiplier by GitHub."));
+  }
+  console.log(`Run ${pc3.cyan("simbox sim")} to boot a simulator.`);
+}
+var SIM_TIMEOUT_MS = 8 * 60 * 1000;
+var SIM_POLL_MS = 3000;
+async function cmdSim(opts) {
+  const json = opts.json === true;
+  const out = json ? process.stderr : process.stdout;
+  const first = await ensureRun(opts.new === true);
+  let info;
+  if (first.state === "live") {
+    info = {
+      runId: first.runId,
+      tunnelUrl: first.tunnelUrl,
+      daemonToken: first.daemonToken,
+      expiresAt: first.expiresAt
+    };
+  } else {
+    const spinner = new Spinner(`Run ${first.state}`);
+    spinner.begin();
+    const deadline = Date.now() + SIM_TIMEOUT_MS;
+    let live = null;
+    while (Date.now() < deadline) {
+      await sleep(SIM_POLL_MS);
+      const run = await currentRun();
+      if (!run)
+        continue;
+      if (run.state === "live" && run.tunnelUrl && run.daemonToken) {
+        live = { run, tunnelUrl: run.tunnelUrl, daemonToken: run.daemonToken };
+        break;
+      }
+      if (run.state === "failed" || run.state === "ended" || run.state === "closing") {
+        spinner.fail(`Run ${run.state}`);
+        throw new CliError(`The run ${run.state} before coming online (${run.endReason ?? "no reason given"}). Try \`simbox sim --new\`.`);
+      }
+      spinner.set(`Run ${run.state}`);
+    }
+    if (!live) {
+      spinner.fail("Timed out");
+      throw new CliError("Run didn't come online within 8 minutes. Check the workflow run in your repo's Actions tab, then try `simbox sim` again (or `--new`).");
+    }
+    spinner.succeed("Run is live");
+    info = {
+      runId: live.run.id,
+      tunnelUrl: live.tunnelUrl,
+      daemonToken: live.daemonToken,
+      expiresAt: live.run.expiresAt
+    };
+  }
+  if (json) {
+    const payload = {
+      tunnel_url: info.tunnelUrl,
+      daemon_token: info.daemonToken,
+      run_id: info.runId,
+      expires_at: info.expiresAt
+    };
+    process.stdout.write(JSON.stringify(payload) + `
+`);
+    return;
+  }
+  out.write(`Run ${pc3.bold(info.runId)} is ${pc3.green("live")}` + (info.expiresAt ? ` — expires in ${fmtCountdown(info.expiresAt)}` : "") + `
+
+`);
+  connectFlow(info, false);
+}
+async function cmdPs() {
+  const run = await currentRun();
+  if (!run) {
+    console.log(`No active run. Start one with ${pc3.cyan("simbox sim")}.`);
+    return;
+  }
+  const stateColor = run.state === "live" ? pc3.green : run.state === "failed" ? pc3.red : pc3.yellow;
+  console.log(`${pc3.bold("run")} ${run.id}`);
+  console.log(`  state:          ${stateColor(run.state)}`);
+  console.log(`  gh_run_id:      ${run.ghRunId ?? pc3.dim("pending")}`);
+  console.log(`  active_devices: ${run.activeDevices}`);
+  console.log(`  android_ready:  ${run.androidReady ? "yes" : "no"}`);
+  console.log(`  expires:        ${run.expiresAt ? fmtCountdown(run.expiresAt) : pc3.dim("n/a")}`);
+  if (run.endReason)
+    console.log(`  end_reason:     ${run.endReason}`);
+}
+async function cmdStop() {
+  const run = await currentRun();
+  if (!run) {
+    console.log("No active run to stop.");
+    return;
+  }
+  await stopRun(run.id);
+  console.log(`${pc3.green("✔")} Stop requested for run ${pc3.bold(run.id)}.`);
+}
+async function cmdRepair() {
+  const spinner = new Spinner("Repairing repo");
+  spinner.begin();
+  const res = await repairRepo();
+  spinner.succeed("Repair complete");
+  if (res.message)
+    console.log(res.message);
+  else
+    console.log("Workflow re-committed, secret rotated, installation verified.");
+}
+async function cmdLogout() {
+  try {
+    rmSync(authPath());
+    console.log(`${pc3.green("✔")} Logged out.`);
+  } catch {
+    console.log("Already logged out.");
+  }
+}
+
+// src/cli.ts
+var program = new Command;
+program.name("simbox").description("On-demand iOS simulators & Android emulators on your own GitHub Actions minutes.").version("0.1.0");
+program.command("login").description("Authenticate via device flow").action(() => run(cmdLogin()));
+program.command("init").description("Open onboarding and wait until a repo is connected").action(() => {
+  requireToken();
+  return run(cmdInit());
+});
+program.command("sim").description("Ensure a run is live and connect agent-device to it").option("--new", "force a fresh run even if one is live").option("--json", "print {tunnel_url, daemon_token, run_id, expires_at} as JSON only").action((opts) => {
+  requireToken();
+  return run(cmdSim(opts));
+});
+program.command("ps").description("Show the current run").action(() => {
+  requireToken();
+  return run(cmdPs());
+});
+program.command("stop").description("Cancel the active run").action(() => {
+  requireToken();
+  return run(cmdStop());
+});
+program.command("repair").description("Re-commit the workflow, rotate the repo secret, re-verify the installation").action(() => {
+  requireToken();
+  return run(cmdRepair());
+});
+program.command("logout").description("Delete the saved auth token").action(() => run(cmdLogout()));
+async function run(p) {
+  try {
+    await p;
+  } catch (err) {
+    process.stderr.write(`${pc4.red("✖")} ${friendlyError(err).message}
+`);
+    process.exitCode = 1;
+  }
+}
+program.parseAsync(process.argv).catch((err) => {
+  process.stderr.write(`${pc4.red("✖")} ${friendlyError(err).message}
+`);
+  process.exitCode = 1;
+});

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "@touchtechclub/simbox",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.7",
+  "description": "On-demand iOS simulators & Android emulators on your own GitHub Actions minutes.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TouchTechClub/simbox",
+    "directory": "apps/cli"
+  },
+  "bin": {
+    "simbox": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bun build src/cli.ts --outdir dist --target node --format esm --external commander --external open --external picocolors && chmod +x dist/cli.js",
+    "dev": "bun run src/cli.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "open": "^10.1.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@simbox/shared": "*",
+    "@types/node": "^20.0.0",
+    "typescript": "catalog:"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.