@geminilight/mindos 0.6.39 → 0.6.41

package/bin/lib/mcp-agents.js

@@ -8,13 +8,8 @@
  */
 
 import { existsSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
-
-function expandHome(p) {
-  return p.startsWith('~/') ? resolve(homedir(), p.slice(2)) : p;
-}
+import { expandHome } from './path-expand.js';
 
 export const MCP_AGENTS = {
   'claude-code': {
@@ -32,7 +27,7 @@ export const MCP_AGENTS = {
     global: '~/.cursor/mcp.json',
     key: 'mcpServers',
     preferredTransport: 'stdio',
-    presenceDirs: ['~/.cursor/'],
+    presenceDirs: ['~/.cursor/extensions/'],
   },
   'windsurf': {
     name: 'Windsurf',
@@ -180,6 +175,30 @@ export const MCP_AGENTS = {
       '~/.config/Code/User/globalStorage/rooveterinaryinc.roo-cline/',
     ],
   },
+  'github-copilot': {
+    name: 'GitHub Copilot',
+    project: '.vscode/mcp.json',
+    global: process.platform === 'darwin'
+      ? '~/Library/Application Support/Code/User/mcp.json'
+      : '~/.config/Code/User/mcp.json',
+    key: 'servers',
+    preferredTransport: 'stdio',
+    presenceDirs: [
+      '~/Library/Application Support/Code/',
+      '~/.config/Code/',
+    ],
+    presenceCli: 'code',
+  },
+  'codex': {
+    name: 'Codex',
+    project: null,
+    global: '~/.codex/config.toml',
+    key: 'mcp_servers',
+    format: 'toml',
+    preferredTransport: 'stdio',
+    presenceCli: 'codex',
+    presenceDirs: ['~/.codex/'],
+  },
 };
 
 /**
@@ -204,7 +223,7 @@ export const SKILL_AGENT_REGISTRY = {
   'qoder': { mode: 'additional', skillAgentName: 'qoder' },
   'trae-cn': { mode: 'additional', skillAgentName: 'trae-cn' },
   'roo': { mode: 'additional', skillAgentName: 'roo' },
-  'vscode': { mode: 'universal' },
+  'github-copilot': { mode: 'universal' },
   'codex': { mode: 'universal' },
 };
 

package/bin/lib/mcp-build.js

@@ -2,7 +2,7 @@ import { existsSync, readdirSync, statSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { ROOT } from './constants.js';
 import { yellow } from './colors.js';
-import { run, npmInstall } from './utils.js';
+import { execInherited as run, npmInstall } from './shell.js';
 
 export const MCP_DIR = resolve(ROOT, 'mcp');
 export const MCP_SRC_DIR = resolve(MCP_DIR, 'src');

package/bin/lib/mcp-install.js

@@ -2,7 +2,8 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { CONFIG_PATH } from './constants.js';
 import { bold, dim, cyan, green, red, yellow } from './colors.js';
-import { expandHome, parseJsonc } from './utils.js';
+import { expandHome } from './path-expand.js';
+import { parseJsonc } from './jsonc.js';
 import { MCP_AGENTS, detectAgentPresence } from './mcp-agents.js';
 
 export { MCP_AGENTS };
@@ -309,8 +310,8 @@ export async function mcpInstall() {
       continue;
     }
 
-    // read + merge
-    const absPath = expandHome(configPath);
+    // read + merge — resolve to absolute path for cross-platform safety
+    const absPath = resolve(expandHome(configPath));
     let config = {};
     if (existsSync(absPath)) {
       try { config = parseJsonc(readFileSync(absPath, 'utf-8')); } catch {
@@ -331,5 +332,13 @@ export async function mcpInstall() {
     console.log(`${green('✔')} ${existed ? 'Updated' : 'Installed'} MindOS MCP for ${bold(agent.name)} ${dim(`→ ${absPath}`)}`);
   }
 
-  console.log(`\n${green('Done!')} ${agentKeys.length} agent(s) configured.\n`);
+  console.log(`\n${green('Done!')} ${agentKeys.length} agent(s) configured.`);
+
+  // Agents that require manual restart to pick up config changes
+  const needsRestart = new Set(['cursor', 'windsurf', 'trae', 'cline', 'roo-code']);
+  const restartAgents = agentKeys.filter(k => needsRestart.has(k)).map(k => MCP_AGENTS[k].name);
+  if (restartAgents.length > 0) {
+    console.log(`\n${yellow('Tip:')} ${restartAgents.join(', ')} must be restarted to load the new MCP config.`);
+  }
+  console.log();
 }

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

@@ -87,7 +87,7 @@ export async function promptSkillUpdate(mismatches) {
   }
 
   // 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;
   }

package/bin/lib/sse-stream.js

@@ -0,0 +1,167 @@
+/**
+ * SSE streaming client for CLI → /api/ask
+ *
+ * Handles the text/event-stream protocol emitted by the MindOS Ask API.
+ * Supports text_delta, thinking_delta, tool_start, tool_end, done, error, status events.
+ */
+
+import { dim, cyan, red } from './colors.js';
+
+/**
+ * Stream an SSE response from /api/ask and print to stdout.
+ *
+ * @param {Response} res - fetch Response with Content-Type: text/event-stream
+ * @param {object} opts
+ * @param {boolean} [opts.showTools=true] - Show tool call / result lines
+ * @param {boolean} [opts.json=false] - Collect full output and return as object instead of printing
+ * @returns {Promise<{ text: string, toolCalls: string[], error?: string }>}
+ */
+export async function streamSSE(res, opts = {}) {
+  const { showTools = true, json = false } = opts;
+  const decoder = new TextDecoder();
+  if (!res.body) {
+    return { text: '', toolCalls: [], error: 'Empty response body' };
+  }
+  const reader = res.body.getReader();
+
+  let textBuffer = '';
+  const toolCalls = [];
+  let error = null;
+  let buffer = '';
+  let firstTextPrinted = false;
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+
+      const lines = buffer.split('\n');
+      // Keep the last incomplete line in buffer
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (!line.startsWith('data:')) continue;
+        const payload = line.slice(5);
+        if (!payload) continue;
+
+        let event;
+        try {
+          event = JSON.parse(payload);
+        } catch {
+          continue;
+        }
+
+        if (event.type === 'text_delta') {
+          if (!firstTextPrinted && !json) {
+            // Clear "Thinking..." spinner
+            process.stdout.write('\r\x1b[K');
+            firstTextPrinted = true;
+          }
+          textBuffer += event.text;
+          if (!json) process.stdout.write(event.text);
+        }
+
+        if (event.type === 'thinking_delta') {
+          // Suppress thinking in CLI output (it's internal reasoning)
+        }
+
+        if (event.type === 'tool_start' && showTools && !json) {
+          if (!firstTextPrinted) {
+            process.stdout.write('\r\x1b[K');
+            firstTextPrinted = true;
+          }
+          const name = event.name || 'unknown';
+          const inputSnippet = event.input
+            ? JSON.stringify(event.input).slice(0, 80)
+            : '';
+          const toolLine = `\n  ${dim('[')}${cyan('tool')}${dim(']')} ${name}${inputSnippet ? dim(': ' + inputSnippet) : ''}`;
+          process.stdout.write(toolLine);
+          toolCalls.push(name);
+        }
+
+        if (event.type === 'tool_end' && showTools && !json) {
+          const result = event.result || '';
+          const preview = typeof result === 'string'
+            ? result.slice(0, 120)
+            : JSON.stringify(result).slice(0, 120);
+          if (preview) {
+            process.stdout.write(dim('  → ' + preview));
+          }
+          process.stdout.write('\n');
+        }
+
+        if (event.type === 'status' && !json) {
+          if (!firstTextPrinted) {
+            process.stdout.write('\r\x1b[K');
+            firstTextPrinted = true;
+          }
+          process.stdout.write(dim(`  [${event.message || 'processing'}]\n`));
+        }
+
+        if (event.type === 'error') {
+          error = event.message || event.error || 'Unknown error';
+          if (!json) {
+            if (!firstTextPrinted) {
+              process.stdout.write('\r\x1b[K');
+            }
+            process.stderr.write('\n' + red('Error: ' + error) + '\n');
+          }
+        }
+
+        if (event.type === 'done') {
+          // Stream complete
+        }
+      }
+    }
+  } catch (err) {
+    if (!json && !firstTextPrinted) {
+      process.stdout.write('\r\x1b[K');
+    }
+    error = err.message || 'Stream interrupted';
+    if (!json) {
+      if (textBuffer) process.stdout.write('\n');
+      process.stderr.write(red('Error: ' + error) + '\n');
+    }
+  }
+
+  if (!json && textBuffer && !textBuffer.endsWith('\n')) {
+    process.stdout.write('\n');
+  }
+
+  return { text: textBuffer, toolCalls, error };
+}
+
+/**
+ * POST to /api/ask with proper headers and message format.
+ *
+ * @param {string} baseUrl - e.g. http://localhost:3456
+ * @param {object} body - { messages, mode, attachedFiles, maxSteps, ... }
+ * @param {string} [token] - Auth token
+ * @returns {Promise<Response>}
+ */
+export async function postAsk(baseUrl, body, token) {
+  const headers = { 'Content-Type': 'application/json' };
+  if (token) headers['Authorization'] = `Bearer ${token}`;
+
+  return fetch(`${baseUrl}/api/ask`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(body),
+  });
+}
+
+/**
+ * Check if MindOS is running by hitting /api/health.
+ * @param {string} baseUrl
+ * @returns {Promise<boolean>}
+ */
+export async function checkHealth(baseUrl) {
+  try {
+    const res = await fetch(`${baseUrl}/api/health`);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}