@geminilight/mindos 0.6.40 → 0.6.41

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;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.6.40",
+  "version": "0.6.41",
   "description": "MindOS — Human-Agent Collaborative Mind System. Local-first knowledge base that syncs your mind to all AI Agents via MCP.",
   "keywords": [
     "mindos",
@@ -19,7 +19,7 @@
     "type": "git",
     "url": "https://github.com/GeminiLight/MindOS"
   },
-  "homepage": "https://mindos.app",
+  "homepage": "https://mindos.you",
   "bugs": {
     "url": "https://github.com/GeminiLight/MindOS/issues"
   },