@0dai-dev/cli 2.1.1 → 2.3.0

package/bin/0dai.js

@@ -7,7 +7,7 @@ const fs = require("fs");
 const path = require("path");
 const os = require("os");
 
-const VERSION = "2.1.1";
+const VERSION = "2.3.0";
 const API_URL = process.env.ODAI_API_URL || "https://api.0dai.dev";
 const T = process.stdout.isTTY ? "\x1b[38;2;45;212;168m" : ""; // teal
 const R = process.stdout.isTTY ? "\x1b[0m" : ""; // reset
@@ -152,10 +152,15 @@ async function cmdInit(target) {
     return;
   }
 
-  log("collecting project metadata...");
-  const { projectFiles, fileContents, clis } = collectMetadata(target);
+  const isTTY = process.stdout.isTTY;
+  let spinner = null;
+  if (isTTY) {
+    try { spinner = require("@clack/prompts").spinner(); } catch {}
+  }
 
-  log(`sending to API (${projectFiles.length} files, ${clis.length} CLIs)...`);
+  const { projectFiles, fileContents, clis } = collectMetadata(target);
+  if (spinner) spinner.start(`Generating ai/ layer (${projectFiles.length} files, ${clis.length} CLIs)...`);
+  else log(`sending to API (${projectFiles.length} files, ${clis.length} CLIs)...`);
   const result = await apiCall("/v1/init", {
     project_files: projectFiles,
     file_contents: fileContents,
@@ -172,7 +177,8 @@ async function cmdInit(target) {
     process.exit(1);
   }
 
-  log(`detected: ${result.stack || "?"}`);
+  if (spinner) spinner.stop(`Detected: ${result.stack || "?"}`);
+  else log(`detected: ${result.stack || "?"}`);
   writeFiles(target, result.files || {});
 
   // Add to .gitignore
@@ -310,43 +316,128 @@ async function checkVersion() {
 }
 
 async function cmdAuthLogin() {
-  // Step 1: request device code
-  const result = await apiCall("/v1/auth/device", { client_id: "cli" });
-  if (result.error) { log(`error: ${result.error}`); process.exit(1); }
+  const isTTY = process.stdout.isTTY && process.stdin.isTTY;
+
+  if (isTTY) {
+    // Interactive TUI flow
+    const p = require("@clack/prompts");
+    p.intro(`${T}0dai${R} authentication`);
+
+    const method = await p.select({
+      message: "How would you like to sign in?",
+      options: [
+        { value: "github", label: "GitHub", hint: "recommended" },
+        { value: "google", label: "Google" },
+        { value: "device", label: "Device code", hint: "no browser needed" },
+      ],
+    });
+    if (p.isCancel(method)) { p.cancel("Cancelled"); process.exit(0); }
+
+    if (method === "github" || method === "google") {
+      const url = `${API_URL}/v1/auth/${method}?cli=true`;
+      p.log.info(`Opening browser: ${url}`);
+      try {
+        const { execSync } = require("child_process");
+        const cmd = os.platform() === "darwin" ? "open" : os.platform() === "win32" ? "start" : "xdg-open";
+        execSync(`${cmd} "${url}"`, { stdio: "ignore" });
+      } catch {
+        p.log.warn(`Could not open browser. Visit manually:\n  ${url}`);
+      }
 
-  log(`Open this URL in your browser:\n`);
-  console.log(`  ${result.verification_uri}\n`);
-  log(`Enter code: ${result.user_code}\n`);
-  log("Waiting for authorization...");
-
-  // Step 2: poll for token
-  const interval = (result.interval || 5) * 1000;
-  const deadline = Date.now() + (result.expires_in || 600) * 1000;
-
-  while (Date.now() < deadline) {
-    await new Promise(r => setTimeout(r, interval));
-    const poll = await apiCall("/v1/auth/token", { device_code: result.device_code });
-    if (poll.access_token) {
-      // Save token
-      fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
-      fs.writeFileSync(AUTH_FILE, JSON.stringify({
-        access_token: poll.access_token,
-        email: poll.email,
-        plan: poll.plan || "free",
-        authenticated_at: new Date().toISOString(),
-        expires_at: poll.expires_at,
-      }, null, 2) + "\n", { mode: 0o600 });
-      log(`Logged in as ${poll.email} (${poll.plan} plan)`);
-      return;
+      const s = p.spinner();
+      s.start("Waiting for browser confirmation...");
+
+      // Poll auth/status until we get a new token (check every 3s, 5min timeout)
+      // For now, ask user to paste token from success page
+      s.stop("Browser opened");
+      const token = await p.text({
+        message: "Paste your token from the success page (or press Enter to skip):",
+        placeholder: "0dai_at_...",
+      });
+      if (token && !p.isCancel(token) && token.startsWith("0dai_at_")) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+        fs.writeFileSync(AUTH_FILE, JSON.stringify({
+          access_token: token,
+          authenticated_at: new Date().toISOString(),
+        }, null, 2) + "\n", { mode: 0o600 });
+        // Fetch profile
+        const status = await apiCall("/v1/auth/status");
+        if (status.email) {
+          const auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf8"));
+          auth.email = status.email;
+          auth.plan = status.plan;
+          auth.name = status.name;
+          fs.writeFileSync(AUTH_FILE, JSON.stringify(auth, null, 2) + "\n", { mode: 0o600 });
+          p.outro(`${T}Logged in${R} as ${status.email} (${status.plan} plan)`);
+        } else {
+          p.outro(`${T}Token saved${R}`);
+        }
+        return;
+      }
+      p.log.info("Skipped. You can also use device code flow:");
     }
-    if (poll.error && poll.error !== "authorization_pending") {
-      log(`${poll.error}`);
-      process.exit(1);
+
+    // Device code fallback
+    const result = await apiCall("/v1/auth/device", { client_id: "cli" });
+    if (result.error) { p.log.error(result.error); process.exit(1); }
+
+    p.log.step(`Open: ${result.verification_uri}`);
+    p.log.step(`Code: ${T}${result.user_code}${R}`);
+
+    const s = p.spinner();
+    s.start("Waiting for confirmation...");
+
+    const interval = (result.interval || 5) * 1000;
+    const deadline = Date.now() + (result.expires_in || 600) * 1000;
+    while (Date.now() < deadline) {
+      await new Promise(r => setTimeout(r, interval));
+      const poll = await apiCall("/v1/auth/token", { device_code: result.device_code });
+      if (poll.access_token) {
+        s.stop("Authorized!");
+        fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+        fs.writeFileSync(AUTH_FILE, JSON.stringify({
+          access_token: poll.access_token, email: poll.email,
+          plan: poll.plan || "free", authenticated_at: new Date().toISOString(),
+          expires_at: poll.expires_at,
+        }, null, 2) + "\n", { mode: 0o600 });
+        p.outro(`${T}Logged in${R} as ${poll.email} (${poll.plan} plan)`);
+        return;
+      }
+      if (poll.error && poll.error !== "authorization_pending") {
+        s.stop("Failed");
+        p.log.error(poll.error);
+        process.exit(1);
+      }
+    }
+    s.stop("Timed out");
+    p.log.error("Try again.");
+    process.exit(1);
+
+  } else {
+    // Non-interactive: device code only
+    const result = await apiCall("/v1/auth/device", { client_id: "cli" });
+    if (result.error) { log(`error: ${result.error}`); process.exit(1); }
+    log(`Open: ${result.verification_uri}`);
+    log(`Code: ${result.user_code}`);
+    log("Waiting...");
+    const interval = (result.interval || 5) * 1000;
+    const deadline = Date.now() + (result.expires_in || 600) * 1000;
+    while (Date.now() < deadline) {
+      await new Promise(r => setTimeout(r, interval));
+      const poll = await apiCall("/v1/auth/token", { device_code: result.device_code });
+      if (poll.access_token) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+        fs.writeFileSync(AUTH_FILE, JSON.stringify({
+          access_token: poll.access_token, email: poll.email,
+          plan: poll.plan || "free", authenticated_at: new Date().toISOString(),
+        }, null, 2) + "\n", { mode: 0o600 });
+        log(`Logged in as ${poll.email}`);
+        return;
+      }
     }
-    process.stdout.write(".");
+    log("Timed out");
+    process.exit(1);
   }
-  log("Authorization timed out. Try again.");
-  process.exit(1);
 }
 
 function cmdAuthLogout() {
@@ -399,6 +490,55 @@ async function cmdFeedbackPush(target) {
   }
 }
 
+// --- Models ---
+function cmdModels(filter) {
+  const MODELS = [
+    { name: "Claude Opus 4.6",   tier: "deep",     score: 95, cli: "claude",   flag: "--model opus" },
+    { name: "Claude Sonnet 4.6", tier: "balanced", score: 90, cli: "claude",   flag: "--model sonnet" },
+    { name: "Claude Haiku 4.5",  tier: "fast",     score: 78, cli: "claude",   flag: "--model haiku" },
+    { name: "GPT-5.3 Codex",     tier: "deep",     score: 91, cli: "codex",    flag: "-m gpt-5.3-codex" },
+    { name: "GPT-5.4",           tier: "balanced", score: 89, cli: "codex",    flag: "-m gpt-5.4",           tested: true },
+    { name: "GPT-5.4-mini",      tier: "fast",     score: 76, cli: "codex",    flag: "-m gpt-5.4-mini",      tested: true },
+    { name: "Gemini 3.1 Pro",    tier: "balanced", score: 85, cli: "gemini",   flag: "-m gemini-3.1-pro" },
+    { name: "Gemini 3 Flash",    tier: "fast",     score: 77, cli: "gemini",   flag: "-m gemini-3-flash" },
+    { name: "Kimi K2.5",         tier: "balanced", score: 74, cli: "opencode", flag: "-m opencode-go/kimi-k2.5",      tested: true },
+    { name: "MiniMax M2.7",      tier: "balanced", score: 72, cli: "opencode", flag: "-m opencode-go/minimax-m2.7",   tested: true },
+    { name: "GLM-5",             tier: "fast",     score: 68, cli: "opencode", flag: "-m opencode-go/glm-5",          tested: true },
+    { name: "MiniMax M2.5",      tier: "fast",     score: 66, cli: "opencode", flag: "-m opencode-go/minimax-m2.5",   tested: true },
+    { name: "Qwen 3.6+ Free",    tier: "fast",     score: 64, cli: "opencode", flag: "-m opencode/qwen3.6-plus-free", tested: true },
+  ];
+
+  const { execFileSync } = require("child_process");
+  const available = new Set();
+  for (const cli of ["claude", "codex", "opencode", "gemini", "aider"]) {
+    try { execFileSync("/bin/sh", ["-c", `command -v ${cli}`], { stdio: "ignore" }); available.add(cli); } catch {}
+  }
+
+  const isTTY = process.stdout.isTTY;
+  const Y  = isTTY ? "\x1b[33m" : "";
+  const G  = isTTY ? "\x1b[32m" : "";
+  const DIM = isTTY ? "\x1b[2m" : "";
+
+  let models = [...MODELS].sort((a, b) => b.score - a.score);
+  if (filter === "--fast")      models = models.filter(m => m.tier === "fast");
+  if (filter === "--balanced")  models = models.filter(m => m.tier === "balanced");
+  if (filter === "--deep")      models = models.filter(m => m.tier === "deep");
+  if (filter === "--available") models = models.filter(m => available.has(m.cli));
+
+  const tc = (t) => t === "deep" ? T : t === "balanced" ? G : DIM;
+  console.log(`\n  ${T}0dai${R} model ratings — ${models.length} models\n`);
+  console.log(`  ${"SCORE".padEnd(6)} ${"MODEL".padEnd(22)} ${"TIER".padEnd(10)} ${"CLI".padEnd(10)} FLAG`);
+  console.log(`  ${"-".repeat(64)}`);
+  for (const m of models) {
+    const dim = available.has(m.cli) ? "" : DIM;
+    const mark = m.tested ? ` ${G}✓${R}` : "";
+    console.log(`${dim}  ${Y}${String(m.score).padEnd(6)}${R} ${m.name.padEnd(22)} ${tc(m.tier)}${m.tier.padEnd(10)}${R} ${m.cli.padEnd(10)} ${DIM}${m.flag}${R}${mark}${dim ? R : ""}`);
+  }
+  console.log(`\n  ${DIM}✓ = swarm-benchmarked  |  dimmed = CLI not installed${R}`);
+  console.log(`  ${DIM}Filter: --fast  --balanced  --deep  --available${R}`);
+  console.log(`  ${DIM}Full table: https://0dai.dev/models${R}\n`);
+}
+
 // --- Session (local, file-based) ---
 function cmdSession(target, sub, args) {
   const sessFile = path.join(target, "ai", "sessions", "active.json");
@@ -545,6 +685,28 @@ async function main() {
     case "session": cmdSession(target, sub, args); break;
     case "swarm": cmdSwarm(target, sub, args); break;
     case "feedback": await cmdFeedback(target, sub, args); break;
+    case "models": cmdModels(sub || args[1]); break;
+    case "terminal": case "term":
+      try {
+        const SessionManager = require("../lib/session-manager");
+        const sm = new SessionManager();
+        if (sub === "launch" || !sub) {
+          const tool = args.find((_, i) => args[i - 1] === "--tool") || "codex";
+          const id = sm.spawn(tool, [], target);
+          log(`session ${id.slice(0, 8)} started (${tool})`);
+          sm.attach(id);
+        } else if (sub === "list") {
+          const sessions = sm.list();
+          if (!sessions.length) { log("no active sessions"); break; }
+          for (const s of sessions) console.log(`  ${s.id.slice(0, 8)} [${s.tool}] ${s.status} ${s.attached ? "(attached)" : ""}`);
+        } else {
+          console.log("Usage: 0dai terminal [launch|list] [--tool codex|claude|gemini]");
+        }
+      } catch (e) {
+        if (e.code === "MODULE_NOT_FOUND") log("install node-pty first: cd ~/.0dai && npm install node-pty");
+        else log(`error: ${e.message}`);
+      }
+      break;
     case "--version": console.log(`${T}0dai${R} ${VERSION}`); break;
     case "help": case "--help": case "-h":
       console.log(`\n  ${T}0dai${R} v${VERSION} — One config for 5 AI agent CLIs\n`);
@@ -557,6 +719,8 @@ async function main() {
       console.log("  session save   Save session for roaming");
       console.log("  swarm status   Task queue & delegation");
       console.log("  feedback push  Send feedback to 0dai");
+      console.log("  models         Show model ratings (--fast/--balanced/--deep/--available)");
+      console.log("  terminal       Launch interactive agent session");
       console.log("  auth login     Authenticate (device code flow)");
       console.log("  auth logout    Remove credentials");
       console.log("  auth status    Show account and usage");

package/lib/session-manager.js

@@ -0,0 +1,103 @@
+"use strict";
+
+const { randomUUID } = require("crypto");
+const pty = require("node-pty");
+
+class SessionManager {
+  constructor(opts = {}) {
+    this.sessions = new Map();
+    this.activeId = null;
+    this.bufferSize = opts.bufferSize || 65536;
+    this._stdin = null;
+    this._resize = null;
+    this._cleanup = () => this.detach();
+    process.once("exit", this._cleanup);
+    process.once("SIGINT", () => { this.detach(); process.exit(130); });
+    process.once("SIGTERM", () => { this.detach(); process.exit(143); });
+  }
+
+  spawn(tool, args = [], cwd = process.cwd()) {
+    const id = randomUUID();
+    const proc = pty.spawn(tool, args, {
+      cwd,
+      env: process.env,
+      name: "xterm-color",
+      cols: process.stdout.columns || 80,
+      rows: process.stdout.rows || 24,
+    });
+    const session = {
+      id,
+      tool,
+      command: [tool].concat(args).join(" "),
+      cwd,
+      status: "running",
+      createdAt: new Date().toISOString(),
+      lastActivityAt: new Date().toISOString(),
+      buffer: "",
+      exitCode: null,
+      signal: null,
+      proc,
+    };
+    proc.onData((data) => {
+      session.lastActivityAt = new Date().toISOString();
+      session.buffer = (session.buffer + data).slice(-this.bufferSize);
+      if (this.activeId === id) process.stdout.write(data);
+    });
+    proc.onExit(({ exitCode, signal }) => {
+      session.status = "exited";
+      session.exitCode = exitCode;
+      session.signal = signal;
+      if (this.activeId === id) this.detach();
+    });
+    this.sessions.set(id, session);
+    return id;
+  }
+
+  attach(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Unknown session: ${sessionId}`);
+    if (session.status !== "running") throw new Error(`Session is ${session.status}: ${sessionId}`);
+    if (this.activeId && this.activeId !== sessionId) this.detach();
+    this.activeId = sessionId;
+    if (session.buffer) process.stdout.write(session.buffer);
+    this._stdin = (data) => session.proc.write(data);
+    this._resize = () => session.proc.resize(process.stdout.columns || 80, process.stdout.rows || 24);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+    }
+    process.stdin.on("data", this._stdin);
+    process.stdout.on("resize", this._resize);
+  }
+
+  detach() {
+    if (!this.activeId) return;
+    if (this._stdin) process.stdin.off("data", this._stdin);
+    if (this._resize) process.stdout.off("resize", this._resize);
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    this._stdin = null;
+    this._resize = null;
+    this.activeId = null;
+  }
+
+  list() {
+    return Array.from(this.sessions.values())
+      .filter((session) => session.status === "running")
+      .map(({ proc, buffer, ...session }) => ({
+        ...session,
+        attached: session.id === this.activeId,
+        bufferedBytes: Buffer.byteLength(buffer),
+      }));
+  }
+
+  kill(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return false;
+    if (this.activeId === sessionId) this.detach();
+    session.proc.kill();
+    this.sessions.delete(sessionId);
+    return true;
+  }
+}
+
+module.exports = SessionManager;

package/package.json

@@ -1,11 +1,20 @@
 {
   "name": "@0dai-dev/cli",
-  "version": "2.1.1",
+  "version": "2.3.0",
   "description": "One config layer for 5 AI agent CLIs — Claude Code, Codex, OpenCode, Gemini, Aider",
   "bin": {
     "0dai": "./bin/0dai.js"
   },
-  "keywords": ["ai", "agents", "claude", "codex", "gemini", "aider", "developer-tools", "mcp"],
+  "keywords": [
+    "ai",
+    "agents",
+    "claude",
+    "codex",
+    "gemini",
+    "aider",
+    "developer-tools",
+    "mcp"
+  ],
   "author": "0dai-dev <dev@0dai.dev>",
   "license": "MIT",
   "repository": {
@@ -20,5 +29,9 @@
     "bin/",
     "lib/",
     "README.md"
-  ]
+  ],
+  "dependencies": {
+    "@clack/prompts": "^1.2.0",
+    "node-pty": "^1.0.0"
+  }
 }