@0dai-dev/cli 4.3.5 → 4.3.7

package/lib/commands/update.js

@@ -1,10 +1,123 @@
 "use strict";
 const shared = require("../shared");
-const { log, SUPPORTED_CLIS } = shared;
+const { log, SUPPORTED_CLIS, cliDisplayName } = shared;
+
+function installCommand(cli) {
+  if (cli.pkgType === "npm" && cli.pkg) return `npm install -g ${cli.pkg}@latest`;
+  if (cli.pkgType === "pip" && cli.pkg) return `pip install --upgrade ${cli.pkg}`;
+  return cli.install || "";
+}
+
+function latestCommand(cli) {
+  if (cli.pkgType === "npm" && cli.pkg) return `npm view ${cli.pkg} version`;
+  if (cli.pkgType === "pip" && cli.pkg) return `pip index versions ${cli.pkg}`;
+  return "";
+}
+
+function parseVersion(out) {
+  const m = String(out || "").match(/(\d+\.\d+\.\d+)/);
+  return m ? m[1] : null;
+}
+
+function readInstalledVersion(cli, execFileSync) {
+  try {
+    const out = execFileSync(cli.bin, ["--version"], { timeout: 8000 }).toString().trim();
+    return { installed: true, version: parseVersion(out), raw: out };
+  } catch {
+    return { installed: false, version: null, raw: "" };
+  }
+}
+
+function readLatestVersion(cli, execFileSync) {
+  if (cli.pkgType === "npm" && cli.pkg) {
+    try {
+      const latest = execFileSync("npm", ["view", cli.pkg, "version"], { timeout: 5000 })
+        .toString()
+        .trim();
+      return { latest, error: null };
+    } catch (error) {
+      return { latest: null, error };
+    }
+  }
+  if (cli.pkgType === "pip" && cli.pkg) {
+    try {
+      const out = execFileSync("pip", ["index", "versions", cli.pkg], { timeout: 8000, encoding: "utf8" });
+      const m = String(out).match(/LATEST:\s*(\d+\.\d+\.\d+)/i) || String(out).match(/(\d+\.\d+\.\d+)/);
+      return { latest: m ? m[1] : null, error: null };
+    } catch (error) {
+      return { latest: null, error };
+    }
+  }
+  return { latest: null, error: null };
+}
+
+function verifyUpdatedVersion(cli, expected, execFileSync) {
+  const after = readInstalledVersion(cli, execFileSync);
+  if (!after.installed) {
+    return {
+      ok: false,
+      version: null,
+      error: `post-update verification failed: ${cli.bin} is not available after install`,
+    };
+  }
+  if (after.version === expected) {
+    return { ok: true, version: after.version, error: null };
+  }
+  const actual = after.version
+    ? after.version
+    : (after.raw ? `unparseable output ${JSON.stringify(after.raw)}` : "unknown");
+  return {
+    ok: false,
+    version: after.version,
+    error: `post-update verification failed: ${cli.name} is still ${actual} (expected ${expected})`,
+  };
+}
+
+function updateEntry(cli, current, latest, status, extra = {}) {
+  return {
+    name: cli.name,
+    bin: cli.bin,
+    current: current || "",
+    latest: latest || "",
+    status,
+    ...(extra.error ? { error: extra.error } : {}),
+    ...(extra.next ? { next: extra.next } : {}),
+  };
+}
+
+function formatEntry(entry) {
+  const current = entry.current ? String(entry.current) : "";
+  const latest = entry.latest ? String(entry.latest) : "";
+  const name = cliDisplayName(entry);
+  const version = latest && current && latest !== current
+    ? `${current} -> ${latest}`
+    : (current || latest || "unknown");
+  return `${name} ${version}`;
+}
+
+function printSummary(summary) {
+  log("update summary");
+  for (const key of ["updated", "would_update", "failed", "unchanged"]) {
+    const entries = summary[key] || [];
+    if (!entries.length) continue;
+    console.log(`  ${key.replace("_", " ")}: ${entries.map(formatEntry).join(", ")}`);
+    for (const entry of entries) {
+      const name = cliDisplayName(entry);
+      if (entry.next) console.log(`    next ${name}: ${entry.next}`);
+      if (entry.error) console.log(`    error ${name}: ${entry.error}`);
+    }
+  }
+  const nextEntries = ["would_update", "failed"]
+    .flatMap((key) => summary[key] || []);
+  if (nextEntries.some((entry) => entry.next && entry.next.startsWith("npm install "))) {
+    console.log("  note: global npm may need sudo/admin");
+  }
+}
 
 function cmdUpdate(args) {
   const { execFileSync: _ef3, execSync } = require("child_process");
   const dryRun = args.includes("--dry-run");
+  const wantJson = args.includes("--json");
 
   // 0dai self-update entry, then all supported agent CLIs.
   const CLIS = [
@@ -12,58 +125,91 @@ function cmdUpdate(args) {
     ...SUPPORTED_CLIS,
   ];
 
-  let updated = 0;
+  const summary = {
+    dry_run: dryRun,
+    updated: [],
+    would_update: [],
+    failed: [],
+    unchanged: [],
+    skipped: [],
+  };
   for (const cli of CLIS) {
-    let installed = false, ver = null;
-    try {
-      const out = _ef3(cli.bin, ["--version"], { timeout: 8000 }).toString().trim();
-      installed = true;
-      const m = out.match(/(\d+\.\d+\.\d+)/);
-      if (m) ver = m[1];
-    } catch {}
-
-    if (!installed) continue;
-
-    let latest = null;
-    if (cli.pkgType === "npm" && cli.pkg) {
-      try { latest = _ef3("npm", ["view", cli.pkg, "version"], { timeout: 5000 }).toString().trim(); } catch {}
-    } else if (cli.pkgType === "pip" && cli.pkg) {
-      try {
-        const out = _ef3("pip", ["index", "versions", cli.pkg], { timeout: 8000, encoding: "utf8" });
-        const m = out.match(/LATEST:\s*(\d+\.\d+\.\d+)/i) || out.match(/(\d+\.\d+\.\d+)/);
-        if (m) latest = m[1];
-      } catch {}
+    const label = cliDisplayName(cli);
+    const installedInfo = readInstalledVersion(cli, _ef3);
+    const ver = installedInfo.version;
+
+    if (!installedInfo.installed) {
+      summary.skipped.push(updateEntry(cli, "", "", "not_installed"));
+      continue;
+    }
+
+    const latestInfo = readLatestVersion(cli, _ef3);
+    const latest = latestInfo.latest;
+    const latestError = latestInfo.error;
+
+    if (latestError) {
+      const error = `latest check failed: ${String(latestError && latestError.message ? latestError.message : latestError).split("\n")[0]}`;
+      summary.failed.push(updateEntry(cli, ver, latest, "latest_unknown", { error, next: latestCommand(cli) }));
+      if (!wantJson) log(`failed to check ${label}: ${error}`);
+      continue;
     }
 
     if (!latest || latest === ver) {
-      console.log(`  ${cli.name} ${ver || ""} — up to date`);
+      summary.unchanged.push(updateEntry(cli, ver, latest, "unchanged"));
+      if (!wantJson) console.log(`  ${label} ${ver || ""} — up to date`);
       continue;
     }
 
-    console.log(`  ${cli.name} ${ver} → ${latest}`);
-    if (dryRun) { updated++; continue; }
+    if (!wantJson) console.log(`  ${label} ${ver} → ${latest}`);
+    if (dryRun) {
+      summary.would_update.push(updateEntry(cli, ver, latest, "would_update", { next: installCommand(cli) }));
+      continue;
+    }
 
     try {
-      if (cli.pkgType === "npm") {
-        log(`updating ${cli.name}...`);
-        execSync(`npm install -g ${cli.pkg}@latest`, { timeout: 60000, stdio: "pipe" });
-        log(`${cli.name} updated to ${latest}`);
-        updated++;
-      } else if (cli.pkgType === "pip") {
-        log(`updating ${cli.name}...`);
-        execSync(`pip install --upgrade ${cli.pkg}`, { timeout: 60000, stdio: "pipe" });
-        log(`${cli.name} updated to ${latest}`);
-        updated++;
+      if (cli.pkgType === "npm" || cli.pkgType === "pip") {
+        const next = installCommand(cli);
+        if (!wantJson) log(`updating ${label}...`);
+        execSync(next, { timeout: 60000, stdio: "pipe" });
+        const verified = verifyUpdatedVersion(cli, latest, _ef3);
+        if (!verified.ok) {
+          summary.failed.push(updateEntry(cli, ver, latest, "verify_failed", { error: verified.error, next }));
+          if (!wantJson) log(`failed to verify ${label}: ${verified.error}`);
+          continue;
+        }
+        if (!wantJson) log(`${label} updated to ${latest}`);
+        summary.updated.push(updateEntry(cli, ver, latest, "updated"));
+      } else {
+        summary.skipped.push(updateEntry(cli, ver, latest, "unsupported"));
       }
     } catch (e) {
-      log(`failed to update ${cli.name}: ${e.message.split("\n")[0]}`);
+      const error = String(e && e.message ? e.message : e).split("\n")[0];
+      summary.failed.push(updateEntry(cli, ver, latest, "failed", { error, next: installCommand(cli) }));
+      if (!wantJson) log(`failed to update ${label}: ${error}`);
     }
   }
-  if (updated) {
-    log(`${dryRun ? "would update" : "updated"} ${updated} CLI(s)`);
+
+  summary.counts = {
+    updated: summary.updated.length,
+    would_update: summary.would_update.length,
+    failed: summary.failed.length,
+    unchanged: summary.unchanged.length,
+    skipped: summary.skipped.length,
+  };
+
+  if (wantJson) {
+    console.log(JSON.stringify(summary, null, 2));
+  } else if (summary.updated.length || summary.would_update.length || summary.failed.length) {
+    printSummary(summary);
   } else {
     log("all CLIs are up to date");
   }
+  return summary;
 }
 
-module.exports = { cmdUpdate };
+module.exports = {
+  cmdUpdate,
+  installCommand,
+  latestCommand,
+  formatEntry,
+};

package/lib/commands/usage.js

@@ -67,7 +67,7 @@ function cmdUsage(target, rawArgs = []) {
     process.exit(1);
   }
 
-  const script = findRepoScript(target, "usage_ledger.py");
+  const script = shared.resolvePythonScript(target, "usage_ledger.py");
   if (!script) {
     log("usage ledger unavailable");
     console.log(`  ${D}Expected scripts/usage_ledger.py in this project${R}`);

package/lib/commands/validate.js

@@ -19,11 +19,17 @@ function cmdValidate(target) {
     "ai/manifest/project.yaml", "ai/manifest/discovery.json",
     "ai/manifest/applied-lock.json", "ai/manifest/environment.yaml",
     "ai/manifest/commands.yaml",
+    "ai/manifest/current_state.json", "ai/manifest/current_task.json",
   ];
 
   let agents = [];
+  let localMode = false;
   try {
-    agents = JSON.parse(fs.readFileSync(path.join(ai, "manifest", "discovery.json"), "utf8")).selected_agents || [];
+    const discovery = JSON.parse(fs.readFileSync(path.join(ai, "manifest", "discovery.json"), "utf8"));
+    agents = discovery.selected_agents || [];
+    // A wizard/`0dai init --local` layer is generated offline and never writes
+    // the cloud-only files below. Treat it as a valid "local" install mode.
+    localMode = discovery.wizard === true || discovery.mode === "local";
   } catch {}
 
   const agentFiles = Object.fromEntries(
@@ -35,6 +41,18 @@ function cmdValidate(target) {
     for (const f of agentFiles[agent] || []) required.push(f);
   }
 
+  // Files that only `0dai sync` (cloud mode) can produce. On a local layer these
+  // are optional — their absence is informational, not a validation failure.
+  const CLOUD_ONLY = new Set([
+    "ai/VERSION_SCHEMA",
+    "ai/manifest/applied-lock.json",
+    "ai/manifest/environment.yaml",
+    "ai/manifest/commands.yaml",
+    ".claude/settings.json", ".claude/CLAUDE.md", ".mcp.json",
+    ".codex/config.toml", "opencode.json",
+    ...Object.values(agentFiles).flat(),
+  ]);
+
   const FIX_HINTS = {
     "ai/VERSION": "run: 0dai init",
     "ai/VERSION_SCHEMA": "run: 0dai sync",
@@ -43,6 +61,8 @@ function cmdValidate(target) {
     "ai/manifest/applied-lock.json": "run: 0dai sync",
     "ai/manifest/environment.yaml": "run: 0dai sync",
     "ai/manifest/commands.yaml": "run: 0dai sync",
+    "ai/manifest/current_state.json": "run: 0dai sync",
+    "ai/manifest/current_task.json": "run: 0dai sync",
     "AGENTS.md": "run: 0dai sync",
     ".claude/settings.json": "run: 0dai sync",
     ".claude/CLAUDE.md": "run: 0dai sync",
@@ -51,10 +71,16 @@ function cmdValidate(target) {
     "opencode.json": "install opencode, then: 0dai sync",
   };
 
-  const present = required.filter(f => fs.existsSync(path.join(target, f)));
-  const missing = required.filter(f => !fs.existsSync(path.join(target, f)));
+  const exists = (f) => fs.existsSync(path.join(target, f));
+  const present = required.filter(exists);
+  // On a local layer, absent cloud-only files are optional, not missing.
+  const missing = required.filter(f => !exists(f) && !(localMode && CLOUD_ONLY.has(f)));
+  const optional = localMode ? required.filter(f => !exists(f) && CLOUD_ONLY.has(f)) : [];
 
   for (const f of present) console.log(`  ${G}✓${R2} ${f}`);
+  for (const f of optional) {
+    console.log(`  ${D2}○ ${f} — optional in local mode (run: 0dai sync to enable cloud features)${R2}`);
+  }
   for (const f of missing) {
     const hint = FIX_HINTS[f] || "run: 0dai sync";
     console.log(`  ${E}✗${R2} ${f} ${D2}— ${hint}${R2}`);
@@ -63,6 +89,9 @@ function cmdValidate(target) {
   if (missing.length) {
     console.log(`\n${E}${missing.length} missing${R2} / ${present.length + missing.length} total`);
     process.exitCode = 1;
+  } else if (localMode) {
+    const optNote = optional.length ? ` ${D2}(${optional.length} cloud-only file(s) skipped)${R2}` : "";
+    log(`${G}validate ok${R2} — healthy local install, ${present.length} required files present${optNote}`);
   } else {
     log(`${G}validate ok${R2} — all ${present.length} required files present`);
   }

package/lib/commands/vault.js

@@ -24,10 +24,16 @@ function hasFlag(args, name) {
   return args.includes(name);
 }
 
+function _hasFlagBeforeTerminator(args, name) {
+  const stop = args.indexOf("--");
+  const scan = stop >= 0 ? args.slice(0, stop) : args;
+  return scan.includes(name);
+}
+
 function printUsage() {
   console.log("Usage: 0dai vault <init|add|get|list|inject|rotate> [--json]");
   console.log("  Phase 1+2a ships `init`, `add`, `get`. `list`/`inject`/`rotate` gated on operator P2b approval.");
-  console.log("  add: 0dai vault add <scope> <name> <value>    (or value via --stdin)");
+  console.log("  add: 0dai vault add <scope> <name> <value>    (or value via --stdin; use -- before values starting with --)");
   console.log("  get: 0dai vault get <scope> <name>");
   console.log("  Runbook: docs/runbooks/0dai-vault.md");
 }
@@ -84,12 +90,39 @@ function _readStdinSync() {
   }
 }
 
-function cmdVaultAdd(args) {
-  const asJson = hasFlag(args, "--json");
-  const useStdin = hasFlag(args, "--stdin");
-  // positional args after stripping flags
-  const positional = args.filter((a) => !a.startsWith("--"));
+function _normalizeStdinPayload(payload) {
+  return String(payload || "").replace(/\r?\n$/, "");
+}
+
+function _positionalArgs(args, knownFlags = new Set()) {
+  const out = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--") {
+      out.push(...args.slice(i + 1));
+      break;
+    }
+    if (knownFlags.has(arg)) continue;
+    out.push(arg);
+  }
+  return out;
+}
+
+function _parseAddArgs(args) {
+  const flags = new Set(["--json", "--stdin"]);
+  const positional = _positionalArgs(args, flags);
   const [scope, name, value] = positional;
+  return {
+    asJson: _hasFlagBeforeTerminator(args, "--json"),
+    useStdin: _hasFlagBeforeTerminator(args, "--stdin"),
+    scope,
+    name,
+    value,
+  };
+}
+
+function cmdVaultAdd(args) {
+  const { asJson, useStdin, scope, name, value } = _parseAddArgs(args);
   if (!scope || !name) {
     log("usage: 0dai vault add <scope> <name> <value>|--stdin");
     process.exitCode = 1;
@@ -97,7 +130,7 @@ function cmdVaultAdd(args) {
   }
   let payload = value;
   if (useStdin) {
-    payload = _readStdinSync();
+    payload = _normalizeStdinPayload(_readStdinSync());
     if (!payload) {
       log("vault add --stdin: no input on stdin");
       process.exitCode = 1;
@@ -142,7 +175,7 @@ function cmdVaultAdd(args) {
 
 function cmdVaultGet(args) {
   const asJson = hasFlag(args, "--json");
-  const positional = args.filter((a) => !a.startsWith("--"));
+  const positional = _positionalArgs(args, new Set(["--json"]));
   const [scope, name] = positional;
   if (!scope || !name) {
     log("usage: 0dai vault get <scope> <name>");
@@ -209,7 +242,9 @@ function cmdVaultDeferred(sub, args) {
 
 function cmdVault(_target, sub, args) {
   const command = sub && !sub.startsWith("-") ? sub : "";
-  const forwarded = command === sub ? args.slice(2) : args.slice(1);
+  // args is already args.slice(2) from bin/0dai.js (the tail after "vault <sub>"),
+  // so forwarded is the remaining flags/positionals unchanged.
+  const forwarded = command ? args : args.slice(1);
 
   if (!command || command === "help" || command === "-h" || command === "--help") {
     printUsage();
@@ -243,4 +278,6 @@ function cmdVault(_target, sub, args) {
 
 module.exports = {
   cmdVault,
+  _normalizeStdinPayload,
+  _parseAddArgs,
 };