@0dai-dev/cli 3.10.1 → 4.1.0

package/lib/shared.js

@@ -0,0 +1,360 @@
+/**
+ * Shared configuration and utilities for 0dai CLI commands.
+ *
+ * Phase 2: Thin re-export layer. Logic extracted into lib/utils/*.
+ * All command modules require from here — API is unchanged.
+ */
+"use strict";
+
+const https = require("https");
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { spawnSync } = require("child_process");
+
+const VERSION = require("../package.json").version;
+
+// --- Re-export from extracted modules ---
+const { SUPPORTED_CLIS, MANIFEST_FILES, PROBE_DIRS, SETTINGS_PRESERVE_FIELDS } = require("./utils/constants");
+const {
+  deviceFingerprint, registerProject, projectIdFor,
+  getGitRemoteOrigin, inferProjectName, detectStackHint,
+  collectMetadata, buildProjectIdentity,
+} = require("./utils/identity");
+const { PLAN_LEVELS, _detectPlanLocal, requirePlan, getSwarmQuotaLocal } = require("./utils/plan");
+
+// --- Colors & logging ---
+function _validateApiUrl(url) {
+  const DEFAULT = "https://api.0dai.dev";
+  if (!url) return DEFAULT;
+  try {
+    const u = new URL(url);
+    if (u.protocol === "https:") return url;
+    if (u.protocol === "http:" && (u.hostname === "localhost" || u.hostname === "127.0.0.1" || u.hostname === "::1")) return url;
+    return DEFAULT;
+  } catch { return DEFAULT; }
+}
+
+const API_URL = _validateApiUrl(process.env.ODAI_API_URL);
+const T = process.stdout.isTTY ? "\x1b[38;2;45;212;168m" : "";
+const R = process.stdout.isTTY ? "\x1b[0m" : "";
+const D = process.stdout.isTTY ? "\x1b[2m" : "";
+const E = process.stdout.isTTY ? "\x1b[31m" : "";
+const G = process.stdout.isTTY ? "\x1b[32m" : "";
+const W = process.stdout.isTTY ? "\x1b[33m" : "";
+const log = (msg) => console.log(`${T}[0dai]${R} ${msg}`);
+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 MANAGED_BEGIN = "<!-- 0dai:managed:begin -->";
+const MANAGED_END = "<!-- 0dai:managed:end -->";
+const LEGACY_MANAGED_BEGIN = "<!-- zerodayai:managed:begin -->";
+const LEGACY_MANAGED_END = "<!-- zerodayai:managed:end -->";
+
+// --- API ---
+function apiCall(endpoint, data) {
+  return new Promise((resolve) => {
+    const url = new URL(endpoint, API_URL);
+    const mod = url.protocol === "https:" ? https : http;
+    const body = data ? JSON.stringify(data) : null;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Device-ID": deviceFingerprint(),
+      "X-CLI-Version": VERSION,
+      "X-Client-Channel": "npm",
+    };
+    try {
+      const auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf8"));
+      const token = auth.api_key || auth.access_token || auth.token;
+      if (token) headers["Authorization"] = `Bearer ${token}`;
+    } catch {}
+    const opts = {
+      hostname: url.hostname,
+      port: url.port || (url.protocol === "https:" ? 443 : 80),
+      path: url.pathname,
+      method: body ? "POST" : "GET",
+      headers,
+      timeout: 60000,
+    };
+    if (body) opts.headers["Content-Length"] = Buffer.byteLength(body);
+    const req = mod.request(opts, (res) => {
+      let chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => {
+        try { resolve(JSON.parse(Buffer.concat(chunks).toString())); }
+        catch { resolve({ error: `HTTP ${res.statusCode}` }); }
+      });
+    });
+    req.on("error", (e) => resolve({ error: `${e.message}. Is ${API_URL} reachable?` }));
+    req.on("timeout", () => { req.destroy(); resolve({ error: "timeout" }); });
+    if (body) req.write(body);
+    req.end();
+  });
+}
+
+// --- Auth State ---
+function loadAuthState() {
+  try { return JSON.parse(fs.readFileSync(AUTH_FILE, "utf8")); }
+  catch { return null; }
+}
+
+function saveAuthState(next) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  fs.writeFileSync(AUTH_FILE, JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
+}
+
+function updateAuthState(patch) {
+  const current = loadAuthState() || {};
+  saveAuthState({ ...current, ...patch });
+}
+
+async function fetchAuthStatus() {
+  const status = await apiCall("/v1/auth/status");
+  if (status && !status.error && status.email) {
+    updateAuthState({
+      email: status.email, plan: status.plan || "free",
+      name: status.name || "", license: status.license || {},
+    });
+  }
+  return status;
+}
+
+function makeEnsureAuthenticated(cmdAuthLogin) {
+  return async function ensureAuthenticated(actionLabel) {
+    let auth = loadAuthState();
+    if (!auth || !(auth.api_key || auth.access_token || auth.token)) {
+      if (cmdAuthLogin && process.stdout.isTTY && process.stdin.isTTY) {
+        log(`${actionLabel} requires 0dai account auth`);
+        await cmdAuthLogin();
+        auth = loadAuthState();
+      } else {
+        log(`authentication required for ${actionLabel}`);
+        console.log(`  ${D}Run: 0dai auth login${R}`);
+        process.exit(1);
+      }
+    }
+    const status = await fetchAuthStatus();
+    if (status.error) {
+      log(`${actionLabel} requires a valid 0dai session`);
+      console.log(`  ${D}Run: 0dai auth login${R}`);
+      process.exit(1);
+    }
+    return status;
+  };
+}
+
+async function ensureLicenseActivation() {
+  const status = await apiCall("/v1/licenses/status");
+  if (!status.error && status.license && status.license.status === "active") {
+    updateAuthState({ license: status.license });
+    return status.license;
+  }
+  log("activating free open-source license...");
+  const activated = await apiCall("/v1/licenses/activate", {
+    device_id: deviceFingerprint(), cli_version: VERSION, channel: "npm",
+  });
+  if (activated.error || !activated.license) {
+    log(`error: ${activated.error || "activation failed"}`);
+    process.exit(1);
+  }
+  updateAuthState({ license: activated.license });
+  return activated.license;
+}
+
+// --- Project Heartbeat ---
+async function sendProjectHeartbeat(identity, result, extra = {}) {
+  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,
+  });
+}
+
+// --- File Writing ---
+function mergeSettingsJson(existing, incoming) {
+  try {
+    const base = JSON.parse(incoming);
+    const user = JSON.parse(existing);
+    for (const field of SETTINGS_PRESERVE_FIELDS) {
+      if (field in user && user[field] !== base[field]) base[field] = user[field];
+    }
+    return JSON.stringify(base, null, 2) + "\n";
+  } catch { return incoming; }
+}
+
+function mergeManagedMarkdown(existing, incoming) {
+  let src = incoming;
+  if (src.startsWith("# managed: true")) {
+    src = src.split("\n").slice(1).join("\n").trimStart();
+  }
+  const managedBody = `${MANAGED_BEGIN}\n${src.trim()}\n${MANAGED_END}\n`;
+  if (existing.includes(MANAGED_BEGIN) && existing.includes(MANAGED_END)) {
+    const start = existing.indexOf(MANAGED_BEGIN);
+    const finish = existing.indexOf(MANAGED_END) + MANAGED_END.length;
+    return existing.slice(0, start) + managedBody + existing.slice(finish);
+  }
+  if (existing.includes(LEGACY_MANAGED_BEGIN) && existing.includes(LEGACY_MANAGED_END)) {
+    const finish = existing.indexOf(LEGACY_MANAGED_END) + LEGACY_MANAGED_END.length;
+    const rest = existing.slice(finish).trimStart();
+    return rest ? `${managedBody}\n${rest}` : managedBody;
+  }
+  return `${managedBody}\n${existing}`;
+}
+
+function contentLooksManaged(existing) {
+  return existing.includes("managed: true") || existing.includes('"managed": true') ||
+    (existing.includes(MANAGED_BEGIN) && existing.includes(MANAGED_END)) ||
+    (existing.includes(LEGACY_MANAGED_BEGIN) && existing.includes(LEGACY_MANAGED_END));
+}
+
+function writeFiles(target, files) {
+  let created = 0, updated = 0, unchanged = 0, merged = 0, skipped = 0;
+  const targetResolved = path.resolve(target);
+  for (const [rel, content] of Object.entries(files)) {
+    if (typeof rel !== "string" || !rel || path.isAbsolute(rel) || rel.split(/[/\\]/).includes("..")) {
+      skipped++; continue;
+    }
+    const p = path.resolve(targetResolved, rel);
+    if (!p.startsWith(targetResolved + path.sep) && p !== targetResolved) { skipped++; continue; }
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    let finalContent = content;
+    if (fs.existsSync(p)) {
+      const existing = fs.readFileSync(p, "utf8");
+      if (existing === content) { unchanged++; continue; }
+      if (rel.endsWith("settings.json")) { finalContent = mergeSettingsJson(existing, content); merged++; }
+      else if (rel === "AGENTS.md") {
+        if (existing.includes("managed: false")) { unchanged++; continue; }
+        const backupDir = path.join(target, "ai", ".backups");
+        fs.mkdirSync(backupDir, { recursive: true });
+        fs.writeFileSync(path.join(backupDir, "AGENTS.md.bak"), existing, "utf8");
+        updated++;
+      } else { updated++; }
+    } else { created++; }
+    fs.writeFileSync(p, finalContent, "utf8");
+  }
+  const parts = [`${created} created`, `${updated} updated`, `${unchanged} unchanged`];
+  if (merged) parts.push(`${merged} merged`);
+  if (skipped) parts.push(`${skipped} skipped (unsafe path)`);
+  log(parts.join(", "));
+  return created + updated;
+}
+
+function writeManagedFiles(target, files) {
+  let created = 0, updated = 0, unchanged = 0, merged = 0, staged = 0, skipped = 0;
+  const targetResolved = path.resolve(target);
+  for (const [rel, content] of Object.entries(files)) {
+    if (typeof rel !== "string" || !rel || path.isAbsolute(rel) || rel.split(/[/\\]/).includes("..")) {
+      skipped++; continue;
+    }
+    const p = path.resolve(targetResolved, rel);
+    if (!p.startsWith(targetResolved + path.sep) && p !== targetResolved) { skipped++; continue; }
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    if (!fs.existsSync(p)) {
+      fs.writeFileSync(p, content, "utf8");
+      created++;
+      continue;
+    }
+    const existing = fs.readFileSync(p, "utf8");
+    if (existing === content) {
+      unchanged++;
+      continue;
+    }
+
+    if (rel.endsWith("settings.json")) {
+      fs.writeFileSync(p, mergeSettingsJson(existing, content), "utf8");
+      merged++;
+      continue;
+    }
+    if (rel === "AGENTS.md" || rel.endsWith("/CLAUDE.md")) {
+      fs.writeFileSync(p, mergeManagedMarkdown(existing, content), "utf8");
+      merged++;
+      continue;
+    }
+    if (!contentLooksManaged(existing)) {
+      fs.writeFileSync(`${p}.generated`, content, "utf8");
+      staged++;
+      continue;
+    }
+
+    fs.writeFileSync(p, content, "utf8");
+    updated++;
+  }
+  const parts = [`${created} created`, `${updated} updated`, `${unchanged} unchanged`];
+  if (merged) parts.push(`${merged} merged`);
+  if (staged) parts.push(`${staged} staged`);
+  if (skipped) parts.push(`${skipped} skipped (unsafe path)`);
+  log(parts.join(", "));
+  return created + updated + merged;
+}
+
+// --- Repo Script Lookup ---
+function findRepoScript(target, scriptName) {
+  const candidates = [
+    path.join(target, "scripts", scriptName),
+    path.join(process.cwd(), "scripts", scriptName),
+    path.join(__dirname, "..", "..", "..", "scripts", scriptName),
+  ];
+  for (const c of candidates) { if (fs.existsSync(c)) return c; }
+  return null;
+}
+
+// --- Version Check ---
+async function checkVersion() {
+  try {
+    const intervalSec = parseInt(process.env.ODAI_UPDATE_CHECK_INTERVAL || "3600");
+    let lastCheck = 0;
+    try { lastCheck = parseFloat(fs.readFileSync(VERSION_CHECK_FILE, "utf8")); } catch {}
+    if (Date.now() / 1000 - lastCheck < intervalSec) return;
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(VERSION_CHECK_FILE, String(Date.now() / 1000));
+    const result = await apiCall("/v1/version");
+    if (result.version && result.version !== VERSION) {
+      const cmp = (a, b) => { const [a1,a2,a3] = a.split(".").map(Number); const [b1,b2,b3] = b.split(".").map(Number); return a1 - b1 || a2 - b2 || a3 - b3; };
+      if (cmp(result.version, VERSION) > 0) {
+        log(`Update available: ${VERSION} → ${result.version}`);
+        console.log(`  Run: npm update -g @0dai-dev/cli\n`);
+      }
+    }
+  } catch {}
+}
+
+// --- Experience ---
+function recordExperienceEvent(target, payload) {
+  const script = findRepoScript(target, "experience_pipeline.py");
+  if (!script) return;
+  try {
+    spawnSync("python3", [script, "record-json", "--target", target], {
+      input: JSON.stringify(payload), stdio: ["pipe", "ignore", "ignore"],
+    });
+  } catch {}
+}
+
+// --- Re-export everything for backward compatibility ---
+module.exports = {
+  // Core
+  VERSION, API_URL, T, R, D, E, G, W,
+  log, CONFIG_DIR, AUTH_FILE, VERSION_CHECK_FILE, PROJECTS_FILE,
+  // Constants
+  PLAN_LEVELS, MANIFEST_FILES, PROBE_DIRS, SUPPORTED_CLIS, SETTINGS_PRESERVE_FIELDS,
+  // API
+  apiCall,
+  // Auth
+  loadAuthState, saveAuthState, updateAuthState,
+  fetchAuthStatus, makeEnsureAuthenticated, ensureLicenseActivation,
+  // Identity
+  deviceFingerprint, registerProject, projectIdFor,
+  getGitRemoteOrigin, inferProjectName, detectStackHint,
+  collectMetadata, buildProjectIdentity,
+  // Plan / Tier
+  _detectPlanLocal, requirePlan, getSwarmQuotaLocal,
+  // Project
+  sendProjectHeartbeat, recordExperienceEvent,
+  // Files
+  mergeSettingsJson, mergeManagedMarkdown, writeFiles, writeManagedFiles, findRepoScript,
+  // Version
+  checkVersion,
+  // Re-exports for convenience
+  spawnSync, fs, path, os, https, http,
+};

package/lib/utils/auth.js

@@ -0,0 +1,142 @@
+/**
+ * Authentication and license management utilities.
+ * Extracted from shared.js to reduce module size.
+ */
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const CONFIG_DIR = path.join(os.homedir(), ".0dai");
+const AUTH_FILE = path.join(CONFIG_DIR, "auth.json");
+
+function loadAuthState() {
+  try { return JSON.parse(fs.readFileSync(AUTH_FILE, "utf8")); }
+  catch { return null; }
+}
+
+function saveAuthState(next) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  fs.writeFileSync(AUTH_FILE, JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
+}
+
+function updateAuthState(patch) {
+  const current = loadAuthState() || {};
+  saveAuthState({ ...current, ...patch });
+}
+
+function deviceFingerprint() {
+  const crypto = require("crypto");
+  const parts = [os.hostname(), os.userInfo().username, os.platform(), os.arch(), os.cpus().length.toString(), os.totalmem().toString()];
+  try {
+    if (os.platform() === "linux") parts.push(fs.readFileSync("/etc/machine-id", "utf8").trim());
+  } catch {}
+  return crypto.createHash("sha256").update(parts.join(":")).digest("hex").slice(0, 32);
+}
+
+async function apiCall(endpoint, data, API_URL, VERSION) {
+  const https = require("https");
+  const http = require("http");
+  return new Promise((resolve) => {
+    const url = new URL(endpoint, API_URL);
+    const mod = url.protocol === "https:" ? https : http;
+    const body = data ? JSON.stringify(data) : null;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Device-ID": deviceFingerprint(),
+      "X-CLI-Version": VERSION,
+      "X-Client-Channel": "npm",
+    };
+    try {
+      const auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf8"));
+      const token = auth.api_key || auth.access_token || auth.token;
+      if (token) headers["Authorization"] = `Bearer ${token}`;
+    } catch {}
+    const opts = {
+      hostname: url.hostname,
+      port: url.port || (url.protocol === "https:" ? 443 : 80),
+      path: url.pathname,
+      method: body ? "POST" : "GET",
+      headers,
+      timeout: 60000,
+    };
+    if (body) opts.headers["Content-Length"] = Buffer.byteLength(body);
+    const req = mod.request(opts, (res) => {
+      let chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => {
+        try { resolve(JSON.parse(Buffer.concat(chunks).toString())); }
+        catch { resolve({ error: `HTTP ${res.statusCode}` }); }
+      });
+    });
+    req.on("error", (e) => resolve({ error: `${e.message}. Is ${API_URL} reachable?` }));
+    req.on("timeout", () => { req.destroy(); resolve({ error: "timeout" }); });
+    if (body) req.write(body);
+    req.end();
+  });
+}
+
+async function fetchAuthStatus(apiCallFn, API_URL) {
+  const status = await apiCallFn("/v1/auth/status", undefined, API_URL);
+  if (status && !status.error && status.email) {
+    updateAuthState({
+      email: status.email,
+      plan: status.plan || "free",
+      name: status.name || "",
+      license: status.license || {},
+    });
+  }
+  return status;
+}
+
+function makeEnsureAuthenticated(cmdAuthLogin, apiCallFn, API_URL, log, D, R) {
+  return async function ensureAuthenticated(actionLabel) {
+    let auth = loadAuthState();
+    if (!auth || !(auth.api_key || auth.access_token || auth.token)) {
+      if (cmdAuthLogin && process.stdout.isTTY && process.stdin.isTTY) {
+        log(`${actionLabel} requires 0dai account auth`);
+        await cmdAuthLogin();
+        auth = loadAuthState();
+      } else {
+        log(`authentication required for ${actionLabel}`);
+        console.log(`  ${D}Run: 0dai auth login${R}`);
+        process.exit(1);
+      }
+    }
+    const status = await fetchAuthStatus(apiCallFn, API_URL);
+    if (status.error) {
+      log(`${actionLabel} requires a valid 0dai session`);
+      console.log(`  ${D}Run: 0dai auth login${R}`);
+      process.exit(1);
+    }
+    return status;
+  };
+}
+
+async function ensureLicenseActivation(apiCallFn, API_URL, VERSION, log) {
+  const status = await apiCallFn("/v1/licenses/status", undefined, API_URL);
+  if (!status.error && status.license && status.license.status === "active") {
+    updateAuthState({ license: status.license });
+    return status.license;
+  }
+  log("activating free open-source license...");
+  const activated = await apiCallFn("/v1/licenses/activate", {
+    device_id: deviceFingerprint(),
+    cli_version: VERSION,
+    channel: "npm",
+  }, API_URL);
+  if (activated.error || !activated.license) {
+    log(`error: ${activated.error || "activation failed"}`);
+    process.exit(1);
+  }
+  updateAuthState({ license: activated.license });
+  return activated.license;
+}
+
+module.exports = {
+  CONFIG_DIR, AUTH_FILE,
+  loadAuthState, saveAuthState, updateAuthState,
+  deviceFingerprint, apiCall, fetchAuthStatus,
+  makeEnsureAuthenticated, ensureLicenseActivation,
+};

package/lib/utils/constants.js

@@ -0,0 +1,76 @@
+/**
+ * Shared constants extracted from shared.js.
+ */
+"use strict";
+
+const SUPPORTED_CLIS = [
+  {
+    name: "claude", bin: "claude",
+    pkg: "@anthropic-ai/claude-code", pkgType: "npm",
+    install: "npm i -g @anthropic-ai/claude-code",
+    altAuth: "Pro/Team subscription",
+    agentFiles: [".claude/settings.json", ".claude/CLAUDE.md", ".mcp.json"],
+  },
+  {
+    name: "codex", bin: "codex",
+    pkg: "@openai/codex", pkgType: "npm",
+    install: "npm i -g @openai/codex",
+    altAuth: "ChatGPT Pro subscription",
+    agentFiles: ["AGENTS.md", ".codex/config.toml"],
+  },
+  {
+    name: "opencode", bin: "opencode",
+    pkg: null, pkgType: "go",
+    install: "go install github.com/nichochar/opencode@latest",
+    altAuth: null,
+    agentFiles: ["opencode.json"],
+  },
+  {
+    name: "gemini", bin: "gemini",
+    pkg: "@google/gemini-cli", pkgType: "npm",
+    install: "npm i -g @google/gemini-cli",
+    altAuth: null,
+    agentFiles: null,
+  },
+  {
+    name: "aider", bin: "aider",
+    pkg: "aider-chat", pkgType: "pip",
+    install: "pip install aider-chat",
+    altAuth: null,
+    agentFiles: null,
+  },
+  {
+    name: "qoder", bin: "qodercli",
+    pkg: "@qoder-ai/qodercli", pkgType: "npm",
+    install: "npm i -g @qoder-ai/qodercli",
+    altAuth: null,
+    agentFiles: [".qoder/settings.json"],
+  },
+];
+
+const MANIFEST_FILES = [
+  "package.json", "package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock", "bun.lockb", "tsconfig.json",
+  "next.config.js", "next.config.mjs", "next.config.ts",
+  "vite.config.js", "vite.config.ts", "vite.config.mjs",
+  "vue.config.js", "nuxt.config.js", "nuxt.config.ts",
+  "svelte.config.js", "astro.config.mjs", "astro.config.ts",
+  "remix.config.js", "angular.json",
+  "go.mod", "go.sum", "pyproject.toml", "requirements.txt", "requirements-dev.txt", "setup.py",
+  "poetry.lock", "Pipfile", "Pipfile.lock",
+  "pubspec.yaml", "Cargo.toml", "Cargo.lock", "pom.xml", "build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts",
+  "Gemfile", "composer.json",
+  "Makefile", "docker-compose.yml", "docker-compose.yaml", "Dockerfile",
+  "pnpm-workspace.yaml", "lerna.json", "turbo.json", "nx.json",
+];
+
+const PROBE_DIRS = [
+  "src", "lib", "app", "apps", "packages", "services",
+  "cmd", "internal", "web", "frontend", "backend",
+  "tests", "test", "spec", "__tests__",
+  "infra", "deploy", "docker", ".github",
+  "android", "ios", "linux", "macos", "windows",
+];
+
+const SETTINGS_PRESERVE_FIELDS = ["model", "permissionMode", "effortLevel"];
+
+module.exports = { SUPPORTED_CLIS, MANIFEST_FILES, PROBE_DIRS, SETTINGS_PRESERVE_FIELDS };