@codeyam-editor/codeyam-editor 0.1.0-staging.3db0f53 → 0.1.0-staging.4d8da9a

package/npm/cli.js

@@ -1,14 +1,17 @@
 #!/usr/bin/env node
 
 const { spawn } = require("child_process");
-const { ensureBinary, uiDistDir } = require("./utils");
+const { ensureBinary } = require("./utils");
 
 const binary = ensureBinary();
 
+// The Rust binary embeds `ui/dist` at build time, so no `CODEYAM_EDITOR_UI_DIR`
+// is required. Devs who want to override the bundle can still export the env
+// var manually — the binary's resolver checks it first.
 const child = spawn(binary, process.argv.slice(2), {
   stdio: "inherit",
   cwd: process.cwd(),
-  env: { ...process.env, CODEYAM_EDITOR_UI_DIR: uiDistDir() },
+  env: process.env,
 });
 
 child.on("exit", (code) => {

package/npm/cloud-branch-switch.js

@@ -0,0 +1,442 @@
+#!/usr/bin/env node
+'use strict';
+
+// npm/cloud-branch-switch.js — switch the whole fleet to a new branch in one command.
+//
+// Orchestrates:
+//   1. Verify the new branch exists on origin.
+//   2. Print the launchd repoint command (operator runs it; auto-mode classifier
+//      blocks ~/Library/LaunchAgents writes from Claude Code).
+//   3. Fire the dashboard's Reconfigure action for each idle VM in the roster,
+//      passing the new branch as both clientBranch + editorBranch so no dashboard
+//      restart is needed for the operation itself.
+//   4. Poll /data until all fired Reconfigure jobs reach a terminal state.
+//   5. Run fixup-vm-creds on each successfully reconfigured VM (if the script exists).
+//
+// Usage:
+//   npm run cloud:branch-switch editor-improvements-N [--dry-run] [--force]
+//
+// Env overrides:
+//   URLS_FILE                 cloudflared URL JSON (default .codeyam/logs/cloudflared-urls.json)
+//   TOKEN_FILE                dashboard bearer-token file
+//   VMS_STATE_FILE            roster JSON (default .codeyam/logs/fleet-vms.json)
+//   DASH_PORT                 dashboard port for localhost fallback (default 8787)
+//   BRANCH_SWITCH_POLL_SEC    /data poll interval in seconds (default 15)
+//   BRANCH_SWITCH_TIMEOUT_SEC per-job deadline (default 2400)
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+const https = require('https');
+
+const { rootDir } = require('./utils');
+// Shared roster reader — the roster file is a fleet-wide contract, so its
+// read+write logic lives in one module the CLI, the dashboard, and this
+// orchestrator all import (see npm/fleet-roster.js).
+const { readRoster } = require('./fleet-roster');
+
+const CANONICAL_EDITOR_REPO = 'https://github.com/codeyam-ai/codeyam-editor.git';
+const DASH_PORT = Number(process.env.DASH_PORT) || 8787;
+const URLS_FILE = process.env.URLS_FILE
+  || path.join(rootDir, '.codeyam', 'logs', 'cloudflared-urls.json');
+const TOKEN_FILE = process.env.TOKEN_FILE
+  || path.join(rootDir, 'scripts', 'operator', 'fleet-dashboard', '.token');
+const POLL_SEC = Number(process.env.BRANCH_SWITCH_POLL_SEC) || 15;
+const TIMEOUT_SEC = Number(process.env.BRANCH_SWITCH_TIMEOUT_SEC) || 2400;
+const FIXUP_SCRIPT = path.join(rootDir, 'scripts', 'operator', 'fixup-vm-creds.sh');
+
+// ── Pure helpers (unit-tested in cloud-branch-switch.test.js) ──────────────
+
+/** Parse argv slice for cloud:branch-switch. Returns { newBranch, dryRun, force }. */
+function parseBranchSwitchArgs(argv) {
+  const args = { newBranch: null, dryRun: false, force: false };
+  for (const a of argv) {
+    if (a === '--dry-run') { args.dryRun = true; continue; }
+    if (a === '--force')   { args.force = true;  continue; }
+    if (a.startsWith('--')) throw new Error(`Unknown flag: ${a}`);
+    if (args.newBranch) {
+      throw new Error(
+        `Unexpected positional arg '${a}' (branch already set to '${args.newBranch}')`,
+      );
+    }
+    args.newBranch = a;
+  }
+  return args;
+}
+
+/** True for non-empty branch names composed only of safe git-ref characters. */
+function isValidBranchName(branch) {
+  return typeof branch === 'string' && branch.length > 0
+    && /^[a-zA-Z0-9._/-]+$/.test(branch);
+}
+
+/** Find a VM by number in the /data vms array (which is ordered, not keyed). */
+function findVm(vms, n) {
+  return Array.isArray(vms) ? vms.find((v) => v && v.n === n) : undefined;
+}
+
+/**
+ * True when a VM's active reconfigure job has reached a terminal state, OR no
+ * reconfigure job is present (a later job may have taken its slot, meaning the
+ * reconfigure completed). Never blocks indefinitely in the poller.
+ */
+function isReconfigureTerminal(vm) {
+  const job = vm && vm.job;
+  if (!job || job.action !== 'reconfigure') return true;
+  return job.state === 'done' || job.state === 'error';
+}
+
+/** Extract the terminal result ('done' / 'error') for a VM's reconfigure job. */
+function reconfigureResult(vm) {
+  const job = vm && vm.job;
+  if (!job || job.action !== 'reconfigure') return 'done';
+  return job.state === 'done' ? 'done' : 'error';
+}
+
+/** True when the /data vms array shows an active session on this VM. */
+function vmHasActiveSession(vms, n) {
+  const vm = findVm(vms, n);
+  return !!(vm && vm.hasSession);
+}
+
+/** Current client branch for a VM, from cardIdentity (live wins over history). */
+function vmClientBranch(vms, n) {
+  const vm = findVm(vms, n);
+  return (vm && vm.cardIdentity && vm.cardIdentity.clientBranch) || null;
+}
+
+/** Build the /action/reconfigure query string for a VM + branch. */
+function buildReconfigureQuery(n, newBranch, force) {
+  const p = new URLSearchParams({
+    vm: String(n),
+    clientRepo: CANONICAL_EDITOR_REPO,
+    clientBranch: newBranch,
+    editorVariant: 'dev',
+    editorBranch: newBranch,
+  });
+  if (force) p.set('force', '1');
+  return p.toString();
+}
+
+// ── I/O helpers ─────────────────────────────────────────────────────────────
+
+function readToken() {
+  try { return fs.readFileSync(TOKEN_FILE, 'utf8').trim(); } catch { return ''; }
+}
+
+function readDashboardBaseUrl() {
+  try {
+    const urls = JSON.parse(fs.readFileSync(URLS_FILE, 'utf8'));
+    const dash = urls && typeof urls.dashboard === 'string' ? urls.dashboard.trim() : '';
+    if (dash) return dash;
+  } catch { /* fall through to localhost */ }
+  return `http://127.0.0.1:${DASH_PORT}`;
+}
+
+function branchExistsOnOrigin(branch) {
+  const r = spawnSync('git', ['ls-remote', '--heads', 'origin', branch], {
+    encoding: 'utf8', cwd: rootDir,
+  });
+  if (r.error || r.status !== 0) return false;
+  return String(r.stdout || '').includes(`refs/heads/${branch}`);
+}
+
+// ── HTTP ────────────────────────────────────────────────────────────────────
+
+function httpFetch(urlStr, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(urlStr);
+    const lib = parsed.protocol === 'https:' ? https : http;
+    const reqOpts = {
+      hostname: parsed.hostname,
+      port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+      path: parsed.pathname + parsed.search,
+      method: opts.method || 'GET',
+      headers: opts.headers || {},
+    };
+    const req = lib.request(reqOpts, (res) => {
+      let body = '';
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        try { resolve({ status: res.statusCode, body: JSON.parse(body) }); }
+        catch { resolve({ status: res.statusCode, body }); }
+      });
+    });
+    req.setTimeout(opts.timeoutMs || 15000, () => {
+      req.destroy();
+      reject(new Error(`Timeout fetching ${urlStr}`));
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+function authHeaders(tok) {
+  return { Authorization: `Bearer ${tok}` };
+}
+
+async function fetchDashboardData(baseUrl, tok) {
+  const r = await httpFetch(`${baseUrl}/data`, { headers: authHeaders(tok) });
+  if (r.status !== 200 || !r.body || typeof r.body !== 'object') {
+    throw new Error(`Dashboard /data returned HTTP ${r.status}`);
+  }
+  return r.body;
+}
+
+async function postReconfigure(baseUrl, tok, n, newBranch, force) {
+  const q = buildReconfigureQuery(n, newBranch, force);
+  return httpFetch(`${baseUrl}/action/reconfigure?${q}`, {
+    method: 'POST',
+    headers: { ...authHeaders(tok), 'Content-Length': '0' },
+  });
+}
+
+// ── Job poller ───────────────────────────────────────────────────────────────
+
+function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
+
+/** Poll /data until every VM in `ns` has a terminal reconfigure job state.
+ *  Returns an object mapping each n to 'done' or 'error' or 'timeout'. */
+async function waitForReconfigureJobs(baseUrl, tok, ns, pollSec, timeoutSec) {
+  const deadline = Date.now() + timeoutSec * 1000;
+  const pending = new Set(ns);
+  const results = {};
+
+  while (pending.size > 0) {
+    if (Date.now() >= deadline) {
+      for (const n of pending) {
+        results[n] = 'timeout';
+        process.stdout.write(`  VM-${n}: TIMEOUT\n`);
+      }
+      break;
+    }
+
+    let data;
+    try {
+      data = await fetchDashboardData(baseUrl, tok);
+    } catch (e) {
+      process.stdout.write(`  (poll error: ${e.message}; retrying in ${pollSec}s)\n`);
+      await sleep(pollSec * 1000);
+      continue;
+    }
+
+    for (const n of [...pending]) {
+      const vm = findVm(data.vms, n);
+      if (isReconfigureTerminal(vm)) {
+        results[n] = reconfigureResult(vm);
+        pending.delete(n);
+        process.stdout.write(`  VM-${n}: ${results[n]}\n`);
+      }
+    }
+    if (pending.size > 0) {
+      const elapsed = Math.round((Date.now() - (deadline - timeoutSec * 1000)) / 1000);
+      process.stdout.write(
+        `  waiting (${[...pending].map((n) => `VM-${n}`).join(', ')} — +${elapsed}s)...\n`,
+      );
+      await sleep(pollSec * 1000);
+    }
+  }
+  return results;
+}
+
+/** Classify each VM in roster as either to-switch or skip.
+ *  Pure: takes already-loaded /data vms array and per-VM state; no I/O. */
+function classifyVmsForSwitch(roster, vms, newBranch, force) {
+  const toSwitch = [];
+  const skipped = [];
+  for (const n of roster) {
+    const currentBranch = vmClientBranch(vms, n);
+    if (currentBranch === newBranch) {
+      skipped.push({ n, reason: `already on ${newBranch}` });
+      continue;
+    }
+    if (vmHasActiveSession(vms, n) && !force) {
+      skipped.push({ n, reason: 'has active session (use --force to override)' });
+      continue;
+    }
+    toSwitch.push(n);
+  }
+  return { toSwitch, skipped };
+}
+
+/** Fire Reconfigure for each VM in toSwitch. Returns { fired, rejected }.
+ *  postFn is injected for testability; defaults to postReconfigure. */
+async function fireReconfigures(baseUrl, tok, toSwitch, newBranch, force, postFn = postReconfigure) {
+  const fired = [];
+  const rejected = [];
+  for (const n of toSwitch) {
+    try {
+      const r = await postFn(baseUrl, tok, n, newBranch, force);
+      if (r.body && r.body.ok === false) {
+        const why = r.body.msg || 'rejected by dashboard';
+        console.warn(`  VM-${n}: rejected — ${why}`);
+        rejected.push({ n, reason: why });
+      } else {
+        const queued = r.body && r.body.queued ? ' (queued)' : '';
+        console.log(`  VM-${n}: accepted${queued}`);
+        fired.push(n);
+      }
+    } catch (e) {
+      console.warn(`  VM-${n}: HTTP error — ${e.message}`);
+      rejected.push({ n, reason: e.message });
+    }
+  }
+  return { fired, rejected };
+}
+
+// ── Fixup ────────────────────────────────────────────────────────────────────
+
+function runFixupVmCreds(n) {
+  if (!fs.existsSync(FIXUP_SCRIPT)) return;
+  console.log(`  fixup-vm-creds VM-${n}...`);
+  const r = spawnSync('bash', [FIXUP_SCRIPT, String(n)], {
+    stdio: 'inherit', cwd: rootDir,
+  });
+  if (r.status !== 0) {
+    console.warn(`  WARN: fixup-vm-creds exited ${r.status} for VM-${n}`);
+  }
+}
+
+// ── Main ─────────────────────────────────────────────────────────────────────
+
+async function branchSwitchMain() {
+  let args;
+  try {
+    args = parseBranchSwitchArgs(process.argv.slice(2));
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Usage: npm run cloud:branch-switch editor-improvements-N [--dry-run] [--force]');
+    process.exit(1);
+  }
+
+  if (!args.newBranch) {
+    console.error('Usage: npm run cloud:branch-switch editor-improvements-N [--dry-run] [--force]');
+    process.exit(1);
+  }
+  if (!isValidBranchName(args.newBranch)) {
+    console.error(`Error: invalid branch name '${args.newBranch}'`);
+    process.exit(1);
+  }
+
+  const dryRun = args.dryRun;
+  const force = args.force;
+  const newBranch = args.newBranch;
+
+  console.log(
+    `cloud:branch-switch ${newBranch}${dryRun ? ' --dry-run' : ''}${force ? ' --force' : ''}`,
+  );
+
+  // Step 1: verify branch exists on origin
+  process.stdout.write('Step 1: verifying branch exists on origin... ');
+  if (!branchExistsOnOrigin(newBranch)) {
+    console.error(`\nError: '${newBranch}' does not exist on origin.`);
+    process.exit(1);
+  }
+  console.log('✓');
+
+  // Step 2: print launchd repoint instruction
+  console.log('\nStep 2: launchd repoint (operator action — run once after the switch):');
+  console.log(`  BRANCH=${newBranch} bash scripts/operator/install-launchd-agents.sh`);
+  console.log('  (auto-mode classifier blocks ~/Library/LaunchAgents writes from Claude Code)');
+
+  // Step 3: load dashboard state
+  const baseUrl = readDashboardBaseUrl();
+  const tok = readToken();
+  if (!tok) {
+    console.error(`\nError: no dashboard token at ${TOKEN_FILE}`);
+    process.exit(1);
+  }
+
+  console.log('\nStep 3: fetching dashboard /data...');
+  let data;
+  try {
+    data = await fetchDashboardData(baseUrl, tok);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error(`  Dashboard: ${baseUrl}`);
+    process.exit(1);
+  }
+
+  const roster = readRoster();
+  if (!roster.length) {
+    console.error('Error: roster is empty — no VMs to switch.');
+    process.exit(1);
+  }
+
+  const { toSwitch, skipped } = classifyVmsForSwitch(roster, data.vms, newBranch, force);
+
+  console.log('\nPlan:');
+  for (const n of toSwitch) {
+    const cur = vmClientBranch(data.vms, n) || '?';
+    console.log(`  VM-${n}: RECONFIGURE  ${cur} → ${newBranch}`);
+  }
+  for (const s of skipped) console.log(`  VM-${s.n}: SKIP — ${s.reason}`);
+
+  if (!toSwitch.length) {
+    console.log('\nNothing to do — all VMs already at target branch or skipped.');
+    return;
+  }
+
+  if (dryRun) {
+    console.log('\n--dry-run: plan printed, no side effects.');
+    return;
+  }
+
+  // Step 4: fire Reconfigure for each VM
+  console.log(`\nStep 4: firing Reconfigure on ${toSwitch.length} VM(s)...`);
+  const { fired, rejected } = await fireReconfigures(baseUrl, tok, toSwitch, newBranch, force);
+  for (const r of rejected) skipped.push(r);
+
+  if (!fired.length) {
+    console.log('\nNo VMs accepted Reconfigure.');
+    return;
+  }
+
+  // Step 5: wait for jobs to complete
+  console.log(`\nStep 5: waiting for ${fired.length} job(s) (timeout ${TIMEOUT_SEC}s, poll ${POLL_SEC}s)...`);
+  const results = await waitForReconfigureJobs(baseUrl, tok, fired, POLL_SEC, TIMEOUT_SEC);
+
+  const succeeded = fired.filter((n) => results[n] === 'done');
+  const failed = fired.filter((n) => results[n] !== 'done');
+
+  // Step 6: fixup-vm-creds for successfully reconfigured VMs
+  if (succeeded.length && fs.existsSync(FIXUP_SCRIPT)) {
+    console.log('\nStep 6: running fixup-vm-creds on reconfigured VMs...');
+    for (const n of succeeded) runFixupVmCreds(n);
+  }
+
+  console.log('\nSummary:');
+  if (succeeded.length) console.log(`  reconfigured: ${succeeded.map((n) => `VM-${n}`).join(', ')}`);
+  if (skipped.length)   console.log(`  skipped:      ${skipped.map((s) => `VM-${s.n}`).join(', ')}`);
+  if (failed.length)    console.log(`  failed:       ${failed.map((n) => `VM-${n} (${results[n]})`).join(', ')}`);
+
+  console.log(`\nDone. Remember to run:`);
+  console.log(`  BRANCH=${newBranch} bash scripts/operator/install-launchd-agents.sh`);
+
+  if (failed.length) process.exit(1);
+}
+
+module.exports = {
+  parseBranchSwitchArgs,
+  isValidBranchName,
+  findVm,
+  isReconfigureTerminal,
+  reconfigureResult,
+  vmHasActiveSession,
+  vmClientBranch,
+  buildReconfigureQuery,
+  classifyVmsForSwitch,
+  fireReconfigures,
+  readRoster,
+  readToken,
+  readDashboardBaseUrl,
+  branchExistsOnOrigin,
+};
+
+if (require.main === module) {
+  branchSwitchMain().catch((e) => {
+    console.error(`Error: ${e.message || e}`);
+    process.exit(1);
+  });
+}