@0dai-dev/cli 4.0.0 → 4.2.0

package/lib/commands/workspace.js

@@ -0,0 +1,297 @@
+"use strict";
+const shared = require("../shared");
+const { log, T, R, D, fs, path, spawnSync } = shared;
+const os = require("os");
+
+const CONFIG_NAME = "workspace.json";
+
+function findConfig(target) {
+  const local = path.join(target, ".0dai", CONFIG_NAME);
+  if (fs.existsSync(local)) return { file: local, scope: "local" };
+  const globalFile = path.join(os.homedir(), ".0dai", CONFIG_NAME);
+  if (fs.existsSync(globalFile)) return { file: globalFile, scope: "global" };
+  return null;
+}
+
+function loadConfig(target) {
+  const found = findConfig(target);
+  if (!found) return null;
+  try { return JSON.parse(fs.readFileSync(found.file, "utf8")); } catch { return null; }
+}
+
+function saveConfig(target, ws, globalFlag) {
+  const configFile = globalFlag
+    ? path.join(os.homedir(), ".0dai", CONFIG_NAME)
+    : path.join(target, ".0dai", CONFIG_NAME);
+  fs.mkdirSync(path.dirname(configFile), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(configFile, JSON.stringify(ws, null, 2) + "\n", { mode: 0o600 });
+  return configFile;
+}
+
+function tmux(args) {
+  try {
+    return spawnSync("tmux", args, { encoding: "utf8", timeout: 5000 });
+  } catch { return { status: 1, stderr: "tmux not found" }; }
+}
+
+function sessionName(name) {
+  return "0dai-" + name.replace(/[^a-z0-9-]/gi, "-").toLowerCase();
+}
+
+function listTmuxSessions() {
+  const r = tmux(["list-sessions", "-F", "#{session_name}\t#{session_created}\t#{pane_pid}"]);
+  if (r.status !== 0) return [];
+  return r.stdout.trim().split("\n").filter(Boolean).map(line => {
+    const [name, created, pid] = line.split("\t");
+    return { name, created, pid };
+  });
+}
+
+// --- Auto-detection ---
+
+function detectSessions(target) {
+  const sessions = [];
+
+  // API server
+  if (fs.existsSync(path.join(target, "scripts", "api_server.py"))) {
+    sessions.push({
+      name: "api",
+      cmd: "python3 api_server.py --public --port 8440",
+      dir: "scripts",
+      auto_start: true,
+    });
+  }
+
+  // Web dev (Next.js, etc.)
+  const pkgPath = path.join(target, "web", "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+      if (pkg.scripts && pkg.scripts.dev) {
+        sessions.push({ name: "web", cmd: "npm run dev", dir: "web", auto_start: true });
+      }
+    } catch {}
+  }
+
+  // Uptime monitor
+  if (fs.existsSync(path.join(target, "scripts", "uptime_monitor.py"))) {
+    sessions.push({
+      name: "monitor",
+      cmd: "python3 uptime_monitor.py --url http://localhost:8440",
+      dir: "scripts",
+      auto_start: false,
+    });
+  }
+
+  // Procfile support
+  const procfile = path.join(target, "Procfile");
+  if (fs.existsSync(procfile)) {
+    try {
+      const lines = fs.readFileSync(procfile, "utf8").split("\n");
+      for (const line of lines) {
+        const m = line.match(/^(\w+):\s*(.+)$/);
+        if (m) {
+          const existing = sessions.find(s => s.name === m[1]);
+          if (!existing) {
+            sessions.push({ name: m[1], cmd: m[2], dir: ".", auto_start: true });
+          }
+        }
+      }
+    } catch {}
+  }
+
+  return sessions;
+}
+
+// --- Commands ---
+
+function cmdWorkspaceInit(target, args) {
+  const globalFlag = args.includes("--global");
+
+  const sessions = detectSessions(target);
+  if (sessions.length === 0) {
+    log("no services detected. Create workspace config manually with: 0dai workspace add");
+    return;
+  }
+
+  const ws = {
+    name: path.basename(target),
+    root: target,
+    sessions,
+  };
+
+  const configFile = saveConfig(target, ws, globalFlag);
+  log(`workspace config created: ${T}${configFile}${R}`);
+  log(`${sessions.length} session(s) detected: ${sessions.map(s => s.name).join(", ")}`);
+  log(`run: ${T}0dai workspace up${R}`);
+}
+
+function cmdWorkspaceAdd(target, args) {
+  const nameIdx = args.indexOf("add");
+  const name = nameIdx >= 0 ? args[nameIdx + 1] : args[0];
+  if (!name) { log("usage: 0dai workspace add <name> --cmd '...' [--dir scripts] [--auto]"); return; }
+
+  const ws = loadConfig(target) || { name: path.basename(target), sessions: [] };
+  const cmdIdx = args.indexOf("--cmd");
+  const dirIdx = args.indexOf("--dir");
+  const cmd = cmdIdx >= 0 && args[cmdIdx + 1] ? args[cmdIdx + 1] : name;
+  const dir = dirIdx >= 0 && args[dirIdx + 1] ? args[dirIdx + 1] : ".";
+  const auto = args.includes("--auto");
+
+  const existing = ws.sessions.findIndex(s => s.name === name);
+  const entry = { name, cmd, dir, auto_start: auto };
+  if (existing >= 0) ws.sessions[existing] = entry;
+  else ws.sessions.push(entry);
+
+  const found = findConfig(target);
+  const configFile = found ? found.file : saveConfig(target, ws, false);
+  fs.writeFileSync(configFile, JSON.stringify(ws, null, 2) + "\n", { mode: 0o600 });
+  log(`session "${T}${name}${R}" ${existing >= 0 ? "updated" : "added"}`);
+}
+
+function cmdWorkspaceRm(target, name) {
+  if (!name) { log("usage: 0dai workspace rm <name>"); return; }
+  const ws = loadConfig(target);
+  if (!ws) { log("no workspace config"); return; }
+  ws.sessions = ws.sessions.filter(s => s.name !== name);
+  const found = findConfig(target);
+  fs.writeFileSync(found.file, JSON.stringify(ws, null, 2) + "\n", { mode: 0o600 });
+  log(`session "${T}${name}${R}" removed`);
+}
+
+function cmdWorkspaceUp(target, args) {
+  const ws = loadConfig(target);
+  if (!ws) { log("no workspace config. Run: 0dai workspace init"); return; }
+
+  // Filter by name if specified
+  const filterNames = args.filter(a => !a.startsWith("-"));
+  const running = listTmuxSessions();
+
+  log(`starting workspace "${T}${ws.name}${R}"`);
+
+  for (const s of ws.sessions) {
+    if (!s.auto_start) continue;
+    if (filterNames.length && !filterNames.includes(s.name)) continue;
+
+    const sname = sessionName(s.name);
+    if (running.find(x => x.name === sname)) {
+      log(`${D}${s.name} already running (pid ${running.find(x => x.name === sname).pid})${R}`);
+      continue;
+    }
+
+    const dir = s.dir ? path.join(ws.root || target, s.dir) : (ws.root || target);
+    const cmd = `cd ${dir} && ${s.cmd}`;
+    const r = tmux(["new-session", "-d", "-s", sname, "bash", "-lc", cmd]);
+    if (r.status === 0) log(`${T}✓${R} ${s.name} started`);
+    else log(`${R}✗${R} ${s.name} failed: ${r.stderr?.trim() || r.error || "unknown"}`);
+  }
+
+  if (filterNames.length === 0) {
+    log(`workspace ready. ${D}Status: 0dai workspace status${R}`);
+  }
+}
+
+function cmdWorkspaceDown(target, args) {
+  const ws = loadConfig(target);
+  if (!ws) { log("no workspace config"); return; }
+
+  const filterNames = args.filter(a => !a.startsWith("-"));
+  log(`stopping workspace "${T}${ws.name}${R}"`);
+
+  for (const s of ws.sessions) {
+    if (filterNames.length && !filterNames.includes(s.name)) continue;
+    const sname = sessionName(s.name);
+    tmux(["kill-session", "-t", sname]);
+    log(`${D}${s.name} stopped${R}`);
+  }
+}
+
+function cmdWorkspaceStatus(target) {
+  const ws = loadConfig(target);
+  if (!ws) { log("no workspace config. Run: 0dai workspace init"); return; }
+
+  const running = listTmuxSessions();
+  const isTTY = process.stdout.isTTY;
+  const G = isTTY ? "\x1b[32m" : "";
+  const RD = isTTY ? "\x1b[31m" : "";
+  const DIM = isTTY ? "\x1b[2m" : "";
+
+  console.log(`\n  ${T}Workspace: ${ws.name}${R}\n`);
+  console.log(`  ${"SESSION".padEnd(14)} ${"STATUS".padEnd(10)} ${"PID".padEnd(8)} DIR`);
+  console.log(`  ${"-".repeat(60)}`);
+
+  for (const s of ws.sessions) {
+    const sname = sessionName(s.name);
+    const match = running.find(x => x.name === sname);
+    const status = match ? `${G}running${R}` : `${RD}stopped${R}`;
+    const pid = match ? match.pid : "—";
+    const dir = s.dir || ".";
+    console.log(`  ${s.name.padEnd(14)} ${status.padEnd(10)} ${String(pid).padEnd(8)} ${DIM}${dir}${R}`);
+  }
+  console.log();
+}
+
+function cmdWorkspaceAttach(target, name) {
+  if (!name) { log("usage: 0dai workspace attach <name>"); return; }
+  const sname = sessionName(name);
+  const running = listTmuxSessions();
+  if (!running.find(x => x.name === sname)) {
+    log(`session "${name}" not running. Run: 0dai workspace up`);
+    return;
+  }
+  log(`attaching to ${T}${name}${R}`);
+  try {
+    const { execSync } = require("child_process");
+    execSync(`tmux attach -t ${sname}`, { stdio: "inherit" });
+  } catch (e) { log(`error: ${e.message}`); }
+}
+
+function cmdWorkspaceLogs(target, name, args) {
+  if (!name) { log("usage: 0dai workspace logs <name> [-f]"); return; }
+  const sname = sessionName(name);
+  const running = listTmuxSessions();
+  if (!running.find(x => x.name === sname)) { log(`session "${name}" not running`); return; }
+
+  const follow = args.includes("-f") || args.includes("--follow");
+  if (follow) {
+    // Live follow mode
+    log(`following ${T}${name}${R} logs (Ctrl+C to exit)`);
+    try {
+      const { execSync } = require("child_process");
+      execSync(`tmux capture-pane -t ${sname} -p -e`, { stdio: "inherit" });
+    } catch (e) { log(`error: ${e.message}`); }
+  } else {
+    const r = tmux(["capture-pane", "-t", sname, "-p"]);
+    if (r.stdout) {
+      const lines = r.stdout.trim().split("\n").slice(-50);
+      console.log(lines.join("\n"));
+    }
+  }
+}
+
+function cmdWorkspace(target, sub, args) {
+  switch (sub) {
+    case "init": cmdWorkspaceInit(target, args); break;
+    case "up": cmdWorkspaceUp(target, args); break;
+    case "down": cmdWorkspaceDown(target, args); break;
+    case "status": cmdWorkspaceStatus(target); break;
+    case "attach": cmdWorkspaceAttach(target, args[0]); break;
+    case "logs": cmdWorkspaceLogs(target, args[0], args); break;
+    case "add": cmdWorkspaceAdd(target, args); break;
+    case "rm": cmdWorkspaceRm(target, args[0]); break;
+    default:
+      console.log(`\n  ${T}0dai workspace${R} — tmux session manager\n`);
+      console.log("Commands:");
+      console.log("  workspace init [--global]   Create config (auto-detect services)");
+      console.log("  workspace up [name...]       Start auto_start sessions (filter by name)");
+      console.log("  workspace down [name...]     Stop sessions (filter by name)");
+      console.log("  workspace status             Show session status table");
+      console.log("  workspace attach <name>      Attach to a running session");
+      console.log("  workspace logs <name> [-f]   Show session output (-f = follow)");
+      console.log("  workspace add <name> --cmd '...' [--dir X] [--auto]");
+      console.log("  workspace rm <name>          Remove session from config");
+      console.log();
+  }
+}
+
+module.exports = { cmdWorkspace };

package/lib/onboarding.js

@@ -104,20 +104,28 @@ async function cmdQuickstart(target, { cmdDoctor, cmdStatus, cmdInit, log, ensur
 
   // Step 1: Auth
   console.log(`\n  [1/${steps}] Checking authentication...`);
+  let signedIn = false;
   let authInfo = "not signed in";
   try {
     const auth = JSON.parse(fs.readFileSync(path.join(require("os").homedir(), ".0dai", "auth.json"), "utf8"));
     if (auth.access_token) {
+      signedIn = true;
       authInfo = `signed in (${auth.plan || "free"} plan)`;
     }
   } catch {}
-  console.log(`           \u2713 ${authInfo}`);
+  if (signedIn) {
+    console.log(`           \u2713 ${authInfo}`);
+  } else {
+    console.log(`           \u26a0 ${authInfo} \u2192 run 0dai auth login`);
+  }
 
   // Step 2: Init
   console.log(`  [2/${steps}] Checking project config...`);
   const aiExists = fs.existsSync(path.join(target, "ai", "VERSION"));
   if (aiExists) {
     console.log("           \u2713 ai/ layer found");
+  } else if (!signedIn) {
+    console.log("           \u26a0 skipped \u2192 sign in before first init");
   } else {
     console.log("           initializing...");
     try {
@@ -132,9 +140,9 @@ async function cmdQuickstart(target, { cmdDoctor, cmdStatus, cmdInit, log, ensur
 
   // Step 3: Doctor
   console.log(`  [3/${steps}] Running health check...`);
-  if (fs.existsSync(path.join(target, "ai"))) {
+  if (fs.existsSync(path.join(target, "ai", "VERSION"))) {
     try {
-      cmdDoctor(target);
+      cmdDoctor(target, { suppressExitCode: true });
     } catch {}
     console.log("           \u2713 health check complete");
   } else {
@@ -143,7 +151,7 @@ async function cmdQuickstart(target, { cmdDoctor, cmdStatus, cmdInit, log, ensur
 
   // Step 4: Status
   console.log(`  [4/${steps}] Project status:`);
-  if (fs.existsSync(path.join(target, "ai"))) {
+  if (fs.existsSync(path.join(target, "ai", "VERSION"))) {
     try {
       cmdStatus(target);
     } catch {}
@@ -155,9 +163,15 @@ async function cmdQuickstart(target, { cmdDoctor, cmdStatus, cmdInit, log, ensur
   const elapsed = ((Date.now() - start) / 1000).toFixed(1);
   console.log(`  [5/${steps}] Ready! (${elapsed}s)`);
   console.log("");
-  console.log("  Your project is set up. Try:");
-  console.log("    0dai swarm run --goal \"add auth\"  (Pro)");
-  console.log("    0dai graph push                   (Pro)");
+  if (!signedIn && !aiExists) {
+    console.log("  Next:");
+    console.log("    0dai auth login                  Sign in to unlock init and sync");
+    console.log("    0dai quickstart                  Re-run after sign-in");
+  } else {
+    console.log("  Your project is set up. Try:");
+    console.log("    0dai swarm run --goal \"add auth\"  (Pro)");
+    console.log("    0dai graph push                   (Pro)");
+  }
   console.log("");
 }
 

package/lib/shared.js

@@ -11,6 +11,7 @@ const http = require("http");
 const fs = require("fs");
 const path = require("path");
 const os = require("os");
+const crypto = require("crypto");
 const { spawnSync } = require("child_process");
 
 const VERSION = require("../package.json").version;
@@ -48,6 +49,15 @@ const CONFIG_DIR = path.join(os.homedir(), ".0dai");
 const AUTH_FILE = path.join(CONFIG_DIR, "auth.json");
 const VERSION_CHECK_FILE = path.join(CONFIG_DIR, ".version_check");
 const PROJECTS_FILE = path.join(CONFIG_DIR, "projects.json");
+const DRIFT_TRACKED_CONFIGS = [
+  "CLAUDE.md",
+  "AGENTS.md",
+  "GEMINI.md",
+  "opencode.json",
+  ".cursorrules",
+  ".windsurfrules",
+  ".aider.conf.yml",
+];
 
 // --- API ---
 function apiCall(endpoint, data) {
@@ -84,7 +94,7 @@ function apiCall(endpoint, data) {
       });
     });
     req.on("error", (e) => resolve({ error: `${e.message}. Is ${API_URL} reachable?` }));
-    req.on("timeout", () => { req.destroy(); resolve({ error: "timeout" }); });
+    req.on("timeout", () => { req.destroy(); resolve({ error: "request timed out after 60s. Check your internet connection or try again." }); });
     if (body) req.write(body);
     req.end();
   });
@@ -160,14 +170,123 @@ async function ensureLicenseActivation() {
 }
 
 // --- Project Heartbeat ---
-async function sendProjectHeartbeat(identity, result, extra = {}) {
+function _hashFileSha256(filePath) {
+  const buf = fs.readFileSync(filePath);
+  return crypto.createHash("sha256").update(buf).digest("hex");
+}
+
+function computeProjectDriftSummary(target) {
+  const hashesPath = path.join(target, "ai", "manifest", "config_hashes.json");
+  if (!fs.existsSync(hashesPath)) return null;
+  let hashes;
+  try {
+    hashes = JSON.parse(fs.readFileSync(hashesPath, "utf8"));
+  } catch {
+    return null;
+  }
+  const findings = [];
+  let totalConfigs = 0;
+  for (const name of DRIFT_TRACKED_CONFIGS) {
+    const filePath = path.join(target, name);
+    const exists = fs.existsSync(filePath) && fs.statSync(filePath).isFile();
+    const recorded = hashes[name];
+    if (exists) totalConfigs += 1;
+    if (recorded && !exists) {
+      findings.push({ config: name, type: "missing", severity: "warning" });
+      continue;
+    }
+    if (!recorded && exists) {
+      findings.push({ config: name, type: "extra", severity: "info" });
+      continue;
+    }
+    if (recorded && exists) {
+      try {
+        const currentHash = _hashFileSha256(filePath);
+        if (currentHash !== String(recorded.hash || "")) {
+          findings.push({ config: name, type: "modified", severity: "warning" });
+        }
+      } catch {
+        findings.push({ config: name, type: "unreadable", severity: "warning" });
+      }
+    }
+  }
+  const driftedCount = findings.filter((f) => f.type === "modified" || f.type === "missing").length;
+  return {
+    available: true,
+    clean: findings.length === 0,
+    drifted_count: driftedCount,
+    total_configs: totalConfigs,
+    findings,
+    updated_at: new Date().toISOString(),
+  };
+}
+
+async function sendProjectHeartbeat(target, identity, result, extra = {}) {
+  const drift = computeProjectDriftSummary(target);
   return apiCall("/v1/projects/heartbeat", {
     project_id: identity.project_id, stack: result.stack || identity.stack || "unknown",
     cli_version: VERSION, activation_status: "active", binding_status: "bound",
-    runtime_sessions: 0, swarm_active: 0, swarm_done: 0, channel: "npm", ...extra,
+    runtime_sessions: 0, swarm_active: 0, swarm_done: 0, channel: "npm",
+    ...(drift ? { drift } : {}),
+    ...extra,
   });
 }
 
+// --- First-run proof gate (issue #342) ---
+//
+// Idempotently appends a `first_run.success` event to ai/manifest/audit.jsonl
+// when all 4 activation gates have passed. Matches scripts/audit.py shape.
+// Returns { fired: boolean, elapsedS: number|null }.
+function logFirstRunSuccess(target, gates) {
+  try {
+    const auditPath = path.join(target, "ai", "manifest", "audit.jsonl");
+    if (!fs.existsSync(path.dirname(auditPath))) {
+      fs.mkdirSync(path.dirname(auditPath), { recursive: true });
+    }
+
+    // Idempotency: skip if a first_run.success event already exists for this project.
+    if (fs.existsSync(auditPath)) {
+      const existing = fs.readFileSync(auditPath, "utf8");
+      if (existing.includes('"action":"first_run.success"') ||
+          existing.includes('"action": "first_run.success"')) {
+        return { fired: false, elapsedS: null };
+      }
+    }
+
+    // Compute elapsed_s from the local first-run marker.
+    let elapsedS = null;
+    try {
+      const ob = require("./onboarding");
+      ob.trackFirstInit(target);
+      elapsedS = ob.getTimeToInit(target);
+    } catch {}
+
+    // Read current ai/VERSION for the entry's ai_version field.
+    let aiVersion = null;
+    try {
+      const vf = path.join(target, "ai", "VERSION");
+      if (fs.existsSync(vf)) aiVersion = fs.readFileSync(vf, "utf8").trim();
+    } catch {}
+
+    const entry = {
+      timestamp: new Date().toISOString(),
+      action: "first_run.success",
+      actor: "cli",
+      user: process.env.USER || process.env.USERNAME || "unknown",
+      ai_version: aiVersion,
+      details: JSON.stringify({
+        elapsed_s: elapsedS,
+        gates: gates || {},
+      }),
+    };
+
+    fs.appendFileSync(auditPath, JSON.stringify(entry) + "\n", "utf8");
+    return { fired: true, elapsedS };
+  } catch {
+    return { fired: false, elapsedS: null };
+  }
+}
+
 // --- File Writing ---
 function mergeSettingsJson(existing, incoming) {
   try {
@@ -273,7 +392,7 @@ module.exports = {
   // Plan / Tier
   _detectPlanLocal, requirePlan, getSwarmQuotaLocal,
   // Project
-  sendProjectHeartbeat, recordExperienceEvent,
+  sendProjectHeartbeat, recordExperienceEvent, logFirstRunSuccess,
   // Files
   mergeSettingsJson, writeFiles, findRepoScript,
   // Version