@geminilight/mindos 0.6.40 → 0.6.42

package/bin/lib/one-shot.js

@@ -0,0 +1,88 @@
+/**
+ * One-shot (non-interactive) execution for CLI agent/chat commands.
+ *
+ * Counterpart to lib/repl.js (interactive mode).
+ * Shared between `mindos agent -p` and `mindos ask -p`.
+ */
+
+import { dim, red } from './colors.js';
+import { streamSSE, postAsk, checkHealth } from './sse-stream.js';
+import { EXIT } from './command.js';
+
+/**
+ * Execute a single AI request, stream the response, and exit.
+ *
+ * @param {object} opts
+ * @param {string} opts.baseUrl - e.g. http://localhost:3456
+ * @param {string} opts.token - auth token
+ * @param {string} opts.message - user message / task
+ * @param {'agent'|'chat'} opts.mode
+ * @param {boolean} [opts.showTools=false] - show tool calls in output
+ * @param {number} [opts.maxSteps] - max agent steps
+ * @param {string[]} [opts.attachedFiles] - file attachments
+ * @param {boolean} [opts.json=false] - output as JSON
+ */
+export async function executeOneShot(opts) {
+  const {
+    baseUrl, token, message, mode,
+    showTools = false,
+    maxSteps,
+    attachedFiles,
+    json = false,
+  } = opts;
+
+  const healthy = await checkHealth(baseUrl);
+  if (!healthy) {
+    console.error(red('MindOS is not running. Start it with: mindos start'));
+    process.exit(EXIT.CONNECT);
+  }
+
+  if (!json) {
+    process.stdout.write(dim('Thinking...'));
+  }
+
+  const body = {
+    messages: [{ role: 'user', content: message, timestamp: Date.now() }],
+    mode,
+  };
+  if (attachedFiles) body.attachedFiles = attachedFiles;
+  if (maxSteps) body.maxSteps = maxSteps;
+
+  try {
+    const res = await postAsk(baseUrl, body, token);
+
+    if (!res.ok) {
+      const errText = await res.text();
+      if (!json) process.stdout.write('\r\x1b[K');
+      console.error(red(`API error (${res.status}): ${errText}`));
+      process.exit(EXIT.ERROR);
+    }
+
+    const contentType = res.headers.get('content-type') || '';
+
+    if (contentType.includes('text/event-stream')) {
+      const result = await streamSSE(res, { showTools, json });
+
+      if (json) {
+        const out = { answer: result.text, error: result.error || undefined };
+        if (showTools) out.toolCalls = result.toolCalls;
+        console.log(JSON.stringify(out, null, 2));
+      }
+
+      if (result.error) process.exit(EXIT.ERROR);
+    } else {
+      const data = await res.json();
+      if (!json) process.stdout.write('\r\x1b[K');
+
+      if (json) {
+        console.log(JSON.stringify(data, null, 2));
+      } else {
+        console.log(data.answer || data.text || JSON.stringify(data, null, 2));
+      }
+    }
+  } catch (err) {
+    if (!json) process.stdout.write('\r\x1b[K');
+    console.error(red(err.message));
+    process.exit(EXIT.ERROR);
+  }
+}

package/bin/lib/path-expand.js

@@ -0,0 +1,9 @@
+/**
+ * Path expansion — resolve `~/...` to absolute paths.
+ */
+
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+
+export const expandHome = (p) =>
+  p.startsWith('~/') ? resolve(homedir(), p.slice(2)) : p;

package/bin/lib/remote.js

@@ -0,0 +1,65 @@
+/**
+ * Remote-mode HTTP helpers for MindOS CLI.
+ *
+ * When MINDOS_URL is set to a non-localhost address, CLI commands should
+ * use these helpers to make HTTP API calls instead of direct fs operations.
+ */
+
+/**
+ * Check if CLI is operating in remote mode.
+ * Remote = MINDOS_URL is set and not pointing to localhost/127.0.0.1.
+ */
+export function isRemoteMode() {
+  const url = process.env.MINDOS_URL;
+  if (!url) return false;
+  try {
+    const parsed = new URL(url);
+    const host = parsed.hostname;
+    return host !== 'localhost' && host !== '127.0.0.1' && host !== '::1' && host !== '0.0.0.0';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the base URL for API calls.
+ * In remote mode: MINDOS_URL
+ * In local mode: http://localhost:<MINDOS_WEB_PORT || 3456>
+ */
+export function getBaseUrl() {
+  if (process.env.MINDOS_URL) return process.env.MINDOS_URL.replace(/\/$/, '');
+  const port = process.env.MINDOS_WEB_PORT || '3456';
+  return `http://localhost:${port}`;
+}
+
+/**
+ * Build headers with auth token if available.
+ */
+export function getAuthHeaders() {
+  const headers = { 'Content-Type': 'application/json' };
+  const token = process.env.AUTH_TOKEN || process.env.MINDOS_AUTH_TOKEN;
+  if (token) headers['Authorization'] = `Bearer ${token}`;
+  return headers;
+}
+
+/**
+ * Make an authenticated API call to the MindOS backend.
+ * @param {string} path - API path (e.g. '/api/file')
+ * @param {object} [options] - fetch options (method, body, etc.)
+ * @returns {Promise<Response>}
+ */
+export async function apiCall(path, options = {}) {
+  const url = `${getBaseUrl()}${path}`;
+  const headers = { ...getAuthHeaders(), ...options.headers };
+  const res = await fetch(url, { ...options, headers });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    const hint = res.status === 401
+      ? ' (check AUTH_TOKEN — run `mindos token` on the server)'
+      : res.status === 404
+      ? ' (is MindOS running? try `mindos start`)'
+      : '';
+    throw new Error(`API ${res.status}: ${text || res.statusText}${hint}`);
+  }
+  return res;
+}

package/bin/lib/repl.js

@@ -0,0 +1,167 @@
+/**
+ * Interactive REPL for CLI agent/chat sessions.
+ *
+ * Provides a multi-turn conversation loop with SSE streaming.
+ * Shared between `mindos agent` and `mindos ask` commands.
+ */
+
+import * as readline from 'node:readline';
+import { bold, dim, cyan, red } from './colors.js';
+import { streamSSE, postAsk, checkHealth } from './sse-stream.js';
+import { EXIT } from './command.js';
+
+/**
+ * @param {object} opts
+ * @param {string} opts.baseUrl - e.g. http://localhost:3456
+ * @param {string} opts.token - auth token
+ * @param {'agent'|'chat'} opts.mode
+ * @param {string} opts.prompt - readline prompt string (e.g. "agent> ")
+ * @param {string} opts.welcome - welcome message shown on start
+ * @param {boolean} opts.showTools - show tool calls in output
+ * @param {string[]} [opts.attachedFiles] - initial file attachments
+ * @param {number} [opts.maxSteps] - max agent steps per turn
+ */
+export async function startRepl(opts) {
+  const {
+    baseUrl, token, mode, prompt, welcome,
+    showTools = true,
+    attachedFiles,
+    maxSteps,
+  } = opts;
+
+  const healthy = await checkHealth(baseUrl);
+  if (!healthy) {
+    console.error(red('\n  MindOS is not running. Start it with: mindos start\n'));
+    process.exit(EXIT.CONNECT);
+  }
+
+  console.log(`\n  ${welcome}`);
+  console.log(`  ${dim('Type "exit" or press Ctrl+C to quit.')}\n`);
+
+  const messages = [];
+  let busy = false;
+  let exiting = false;
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: cyan(prompt),
+    terminal: true,
+  });
+
+  rl.prompt();
+
+  rl.on('line', async (line) => {
+    const input = line.trim();
+
+    if (!input) {
+      rl.prompt();
+      return;
+    }
+
+    if (input === 'exit' || input === 'quit' || input === '/exit' || input === '/quit') {
+      exitGracefully();
+      return;
+    }
+
+    if (input === '/clear') {
+      messages.length = 0;
+      console.log(dim('  Conversation cleared.\n'));
+      rl.prompt();
+      return;
+    }
+
+    // Prevent concurrent requests — queue is dropped, user gets feedback
+    if (busy) {
+      console.log(dim('  Still processing previous message. Please wait.\n'));
+      return;
+    }
+
+    busy = true;
+    messages.push({ role: 'user', content: input, timestamp: Date.now() });
+
+    // Keep last 40 messages to prevent unbounded payload growth
+    const MAX_CONTEXT = 40;
+    const contextMessages = messages.length > MAX_CONTEXT
+      ? messages.slice(-MAX_CONTEXT)
+      : [...messages];
+
+    const body = { messages: contextMessages, mode };
+    if (attachedFiles) body.attachedFiles = attachedFiles;
+    if (maxSteps) body.maxSteps = maxSteps;
+
+    process.stdout.write('\n');
+
+    try {
+      const res = await postAsk(baseUrl, body, token);
+
+      if (!res.ok) {
+        const errText = await res.text();
+        console.error(red(`  API error (${res.status}): ${errText}\n`));
+        messages.pop();
+        busy = false;
+        rl.prompt();
+        return;
+      }
+
+      const contentType = res.headers.get('content-type') || '';
+
+      if (contentType.includes('text/event-stream')) {
+        const result = await streamSSE(res, { showTools, json: false });
+
+        if (result.error) {
+          console.error(red('  Error in this turn. You can retry.\n'));
+          messages.pop();
+          busy = false;
+          rl.prompt();
+          return;
+        }
+
+        if (result.text) {
+          messages.push({
+            role: 'assistant',
+            content: result.text,
+            timestamp: Date.now(),
+          });
+        }
+      } else {
+        const data = await res.json();
+        const answer = data.answer || data.text || JSON.stringify(data, null, 2);
+        console.log(answer);
+
+        messages.push({
+          role: 'assistant',
+          content: answer,
+          timestamp: Date.now(),
+        });
+      }
+    } catch (err) {
+      console.error(red(`  ${err.message}\n`));
+      messages.pop();
+    }
+
+    busy = false;
+    console.log();
+    rl.prompt();
+  });
+
+  rl.on('close', () => {
+    exitGracefully();
+  });
+
+  rl.on('SIGINT', () => {
+    console.log(dim('\n  (Press Ctrl+C again or type "exit" to quit)'));
+    rl.once('SIGINT', () => {
+      exitGracefully();
+    });
+    rl.prompt();
+  });
+
+  function exitGracefully() {
+    if (exiting) return;
+    exiting = true;
+    console.log(dim('\n  Goodbye.\n'));
+    rl.close();
+    process.exit(0);
+  }
+}

package/bin/lib/{utils.js → shell.js}

@@ -1,33 +1,33 @@
+/**
+ * Shell execution helpers — inheriting stdio.
+ */
+
 import { execSync } from 'node:child_process';
-import { resolve } from 'node:path';
-import { homedir } from 'node:os';
 import { ROOT } from './constants.js';
 
 /**
+ * @param {string} command
+ * @param {string} [cwd]
  * @param {Record<string, string | undefined>} [envPatch] merged into process.env (for child only)
  */
-export function run(command, cwd = ROOT, envPatch) {
+export const execInherited = (command, cwd = ROOT, envPatch) => {
   try {
     const env = envPatch ? { ...process.env, ...envPatch } : process.env;
     execSync(command, { cwd, stdio: 'inherit', env });
   } catch (err) {
     process.exit(err.status || 1);
   }
-}
+};
 
 /**
  * Run `npm install` with --prefer-offline for speed, auto-fallback to online
  * if the local cache is stale or missing a required package version.
- *
- * @param {string} cwd - Directory to run in
- * @param {string} [extraFlags=''] - Additional npm flags (e.g. '--no-workspaces')
  */
-export function npmInstall(cwd, extraFlags = '') {
+export const npmInstall = (cwd, extraFlags = '') => {
   const base = `npm install ${extraFlags}`.trim();
   try {
     execSync(`${base} --prefer-offline`, { cwd, stdio: 'inherit', env: process.env });
   } catch {
-    // Cache miss or stale packument — retry online
     try {
       execSync(base, { cwd, stdio: 'inherit', env: process.env });
     } catch (err) {
@@ -36,20 +36,4 @@ export function npmInstall(cwd, extraFlags = '') {
       process.exit(err.status || 1);
     }
   }
-}
-
-export function expandHome(p) {
-  return p.startsWith('~/') ? resolve(homedir(), p.slice(2)) : p;
-}
-
-/**
- * Parse JSONC — strips single-line and block comments before JSON.parse.
- * VS Code-based editors (Cursor, Windsurf, Cline) use JSONC for config files.
- */
-export function parseJsonc(text) {
-  // Strip single-line comments (not inside quoted strings)
-  let stripped = text.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*$)/gm, (m, g) => g ? '' : m);
-  // Strip block comments
-  stripped = stripped.replace(/\/\*[\s\S]*?\*\//g, '');
-  return JSON.parse(stripped);
-}
+};

package/bin/lib/skill-check.js

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync, copyFileSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { existsSync, readFileSync, writeFileSync, copyFileSync, mkdirSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { createInterface } from 'node:readline';
 import { ROOT } from './constants.js';
@@ -7,11 +7,10 @@ import { bold, dim, cyan, green, yellow, isTTY } from './colors.js';
 
 const SKILLS = ['mindos', 'mindos-zh'];
 const INSTALLED_BASE = resolve(homedir(), '.agents', 'skills');
+const CONFIG_PATH = resolve(homedir(), '.mindos', 'config.json');
 
 /**
  * Simple semver "a > b" comparison (major.minor.patch only).
- * Intentionally inlined (same as update-check.js) to keep this module
- * self-contained — no cross-module dependency for a 10-line function.
  */
 function semverGt(a, b) {
   const pa = a.split('.').map(Number);
@@ -37,70 +36,165 @@ export function extractSkillVersion(filePath) {
   }
 }
 
+/* ── Config helpers (read/write installedSkillAgents) ─────────── */
+
+/**
+ * Read config.json, best-effort.
+ */
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Merge fields into config.json (preserves all existing fields).
+ */
+function mergeConfig(patch) {
+  const config = readConfig();
+  Object.assign(config, patch);
+  const dir = dirname(CONFIG_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}
+
+/**
+ * Read the installed-skill-agents list from config.
+ * @returns {Array<{ agent: string, skill: string, path: string }>}
+ */
+export function getInstalledSkillAgents() {
+  const config = readConfig();
+  return Array.isArray(config.installedSkillAgents) ? config.installedSkillAgents : [];
+}
+
+/**
+ * Record that a skill was installed to a specific agent.
+ * Idempotent — updates existing entry if agent+skill already recorded.
+ */
+export function recordSkillInstall(agentKey, skillName, installPath) {
+  const list = getInstalledSkillAgents();
+  const idx = list.findIndex(e => e.agent === agentKey && e.skill === skillName);
+  const entry = { agent: agentKey, skill: skillName, path: installPath };
+  if (idx >= 0) {
+    list[idx] = entry;
+  } else {
+    list.push(entry);
+  }
+  mergeConfig({ installedSkillAgents: list });
+}
+
+/**
+ * Remove a skill record for an agent.
+ */
+export function removeSkillRecord(agentKey, skillName) {
+  const list = getInstalledSkillAgents();
+  const filtered = list.filter(e => !(e.agent === agentKey && e.skill === skillName));
+  if (filtered.length !== list.length) {
+    mergeConfig({ installedSkillAgents: filtered });
+  }
+}
+
+/* ── Version checking ─────────────────────────────────────────── */
+
 /**
  * Compare installed vs bundled skill versions.
- * @param {string} [root] — package root to read bundled skills from.
- *   Defaults to the static ROOT (fine for startup). Pass the post-update
- *   root when called from `mindos update` so we read the NEW package's skills.
- * Returns array of mismatches where bundled > installed.
+ * Checks both the default ~/.agents/skills/ path AND all agent-specific
+ * paths recorded in config.installedSkillAgents.
+ *
+ * @param {string} [root] — package root (defaults to ROOT)
+ * @returns {Array<{ name, installed, bundled, installPath, bundledPath, agent? }>}
  */
 export function checkSkillVersions(root) {
   const base = root || ROOT;
   const mismatches = [];
+  const seen = new Set(); // dedup by installPath
+
+  // 1. Check default ~/.agents/skills/ (legacy path)
   for (const name of SKILLS) {
     const installPath = resolve(INSTALLED_BASE, name, 'SKILL.md');
     const bundledPath = resolve(base, 'skills', name, 'SKILL.md');
+    if (!existsSync(installPath) || !existsSync(bundledPath)) continue;
+    const installed = extractSkillVersion(installPath);
+    const bundled = extractSkillVersion(bundledPath);
+    if (!installed || !bundled) continue;
+    if (semverGt(bundled, installed)) {
+      mismatches.push({ name, installed, bundled, installPath, bundledPath });
+    }
+    seen.add(installPath);
+  }
 
-    if (!existsSync(installPath)) continue;
+  // 2. Check agent-specific paths from config
+  const agentRecords = getInstalledSkillAgents();
+  for (const record of agentRecords) {
+    const installPath = record.path;
+    if (!installPath || seen.has(installPath)) continue;
+    seen.add(installPath);
+
+    const skillName = record.skill || 'mindos';
+    const bundledPath = resolve(base, 'skills', skillName, 'SKILL.md');
     if (!existsSync(bundledPath)) continue;
 
+    if (!existsSync(installPath)) {
+      // Path no longer exists — clean up stale record silently
+      removeSkillRecord(record.agent, skillName);
+      continue;
+    }
+
     const installed = extractSkillVersion(installPath);
     const bundled = extractSkillVersion(bundledPath);
-
     if (!installed || !bundled) continue;
     if (semverGt(bundled, installed)) {
-      mismatches.push({ name, installed, bundled, installPath, bundledPath });
+      mismatches.push({
+        name: skillName,
+        installed,
+        bundled,
+        installPath,
+        bundledPath,
+        agent: record.agent,
+      });
     }
   }
+
   return mismatches;
 }
 
 /**
  * Copy bundled SKILL.md over the installed version.
+ * Creates parent directory if needed.
  */
 export function updateSkill(bundledPath, installPath) {
+  const dir = dirname(installPath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   copyFileSync(bundledPath, installPath);
 }
 
 /**
  * Print skill update hints and optionally prompt user to update.
- *
- * - TTY + not daemon: interactive readline prompt (default Y)
- * - Non-TTY / daemon / MINDOS_NO_SKILL_CHECK=1: one-line hint, no block
  */
 export async function promptSkillUpdate(mismatches) {
   if (!mismatches || mismatches.length === 0) return;
 
-  // Print mismatch info
   for (const m of mismatches) {
-    console.log(`\n  ${yellow('⬆')}  Skill ${bold(m.name)}: ${dim(`v${m.installed}`)} → ${cyan(`v${m.bundled}`)}`);
+    const agentLabel = m.agent ? ` (${m.agent})` : '';
+    console.log(`\n  ${yellow('⬆')}  Skill ${bold(m.name)}${agentLabel}: ${dim(`v${m.installed}`)} → ${cyan(`v${m.bundled}`)}`);
   }
 
   // Non-interactive mode: just print hint
-  if (!isTTY || process.env.LAUNCHED_BY_LAUNCHD === '1' || process.env.INVOCATION_ID) {
+  if (!isTTY() || process.env.LAUNCHED_BY_LAUNCHD === '1' || process.env.INVOCATION_ID) {
     console.log(`     ${dim('Run `mindos start` in a terminal to update interactively.')}`);
     return;
   }
 
-  // Interactive prompt (10s timeout to avoid blocking startup indefinitely)
+  // Interactive prompt (10s timeout)
   return new Promise((res) => {
     let done = false;
     const finish = () => { if (!done) { done = true; res(); } };
 
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     const timer = setTimeout(() => { rl.close(); finish(); }, 10_000);
-
-    rl.on('close', finish); // handles broken pipe / EOF
+    rl.on('close', finish);
 
     rl.question(`     Update skill${mismatches.length > 1 ? 's' : ''}? ${dim('(Y/n)')} `, (answer) => {
       clearTimeout(timer);
@@ -110,7 +204,8 @@ export async function promptSkillUpdate(mismatches) {
         for (const m of mismatches) {
           try {
             updateSkill(m.bundledPath, m.installPath);
-            console.log(`  ${green('✓')} ${dim(`Updated ${m.name} → v${m.bundled}`)}`);
+            const agentLabel = m.agent ? ` (${m.agent})` : '';
+            console.log(`  ${green('✓')} ${dim(`Updated ${m.name}${agentLabel} → v${m.bundled}`)}`);
           } catch (err) {
             console.log(`  ${yellow('!')} ${dim(`Failed to update ${m.name}: ${err.message}`)}`);
           }