@geminilight/mindos 0.6.39 → 0.6.41

package/bin/commands/gateway.js

@@ -0,0 +1,42 @@
+/**
+ * mindos gateway — Manage MindOS as a background OS service
+ */
+
+import { bold, dim, cyan } from '../lib/colors.js';
+
+export const meta = {
+  name: 'gateway',
+  group: 'Gateway',
+  summary: 'Manage background service (launchd/systemd)',
+  usage: 'mindos gateway <subcommand>',
+  examples: [
+    'mindos gateway install',
+    'mindos gateway start',
+    'mindos gateway stop',
+    'mindos gateway status',
+    'mindos gateway logs',
+  ],
+};
+
+export const run = async (args) => {
+  const sub = args[0];
+  if (!sub) {
+    const row = (c, d) => `  ${cyan(c.padEnd(32))}${dim(d)}`;
+    console.log(`
+${bold('mindos gateway')} — manage MindOS as a background OS service
+
+${bold('Subcommands:')}
+${row('mindos gateway install',   'Install and enable the service (systemd/launchd)')}
+${row('mindos gateway uninstall', 'Disable and remove the service')}
+${row('mindos gateway start',     'Start the service')}
+${row('mindos gateway stop',      'Stop the service')}
+${row('mindos gateway status',    'Show service status')}
+${row('mindos gateway logs',      'Tail service logs')}
+
+${dim('Shortcut: mindos start --daemon  →  install + start in one step')}
+`);
+    return;
+  }
+  const { runGatewayCommand } = await import('../lib/gateway.js');
+  await runGatewayCommand(sub);
+};

package/bin/commands/init-skills.js

@@ -0,0 +1,56 @@
+/**
+ * mindos init-skills — Initialize skill rules
+ */
+
+import { existsSync, readFileSync, mkdirSync, cpSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { ROOT, CONFIG_PATH } from '../lib/constants.js';
+import { bold, dim, cyan, green, red } from '../lib/colors.js';
+import { EXIT } from '../lib/command.js';
+
+export const meta = {
+  name: 'init-skills',
+  group: 'Config',
+  summary: 'Initialize skill rules',
+  usage: 'mindos init-skills',
+  hidden: true,
+};
+
+export const run = () => {
+  console.log(`\n${bold('📦 Initialize Skill Rules')}\n`);
+
+  if (!existsSync(CONFIG_PATH)) {
+    console.log(`  ${red('✘')} Config not found. Run ${cyan('mindos onboard')} first.\n`);
+    process.exit(EXIT.ERROR);
+  }
+  let config;
+  try {
+    config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+  } catch {
+    console.log(`  ${red('✘')} Failed to parse config at ${dim(CONFIG_PATH)}\n`);
+    process.exit(EXIT.ERROR);
+  }
+  const mindRoot = config.mindRoot;
+  if (!mindRoot || !existsSync(mindRoot)) {
+    console.log(`  ${red('✘')} Knowledge base not found: ${dim(mindRoot || '(not set)')}\n`);
+    process.exit(EXIT.ERROR);
+  }
+
+  const mindosDir = resolve(mindRoot, '.mindos');
+  const dest = resolve(mindosDir, 'user-preferences.md');
+  if (existsSync(dest)) {
+    console.log(`  ${dim('skip')}  .mindos/user-preferences.md (already exists)\n`);
+  } else {
+    if (!existsSync(mindosDir)) mkdirSync(mindosDir, { recursive: true });
+    const isZh = config.disabledSkills?.includes('mindos');
+    const lang = isZh ? 'zh' : 'en';
+    const src = resolve(ROOT, 'templates', 'skill-rules', lang, 'user-rules.md');
+    if (existsSync(src)) {
+      cpSync(src, dest);
+      console.log(`  ${green('✓')}  .mindos/user-preferences.md created at ${dim(mindosDir)}\n`);
+    } else {
+      console.log(`  ${dim('skip')}  Template not found, create .mindos/user-preferences.md manually if needed.\n`);
+    }
+  }
+  console.log(`  ${dim('Note: Operating rules are now built into the app. No install needed.')}\n`);
+};

package/bin/commands/logs.js

@@ -0,0 +1,32 @@
+/**
+ * mindos logs — Tail service logs
+ */
+
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { LOG_PATH } from '../lib/constants.js';
+import { dim } from '../lib/colors.js';
+
+export const meta = {
+  name: 'logs',
+  group: 'Config',
+  summary: 'Tail service logs',
+  usage: 'mindos logs',
+  examples: [
+    'mindos logs',
+  ],
+};
+
+export const run = async (args, flags) => {
+  const { ensureMindosDir } = await import('../lib/gateway.js');
+  await ensureMindosDir();
+
+  if (!existsSync(LOG_PATH)) {
+    console.log(dim(`No log file yet at ${LOG_PATH}`));
+    console.log(dim('Logs are created when starting MindOS (mindos start, mindos onboard, or daemon mode).'));
+    process.exit(0);
+  }
+
+  const noFollow = flags['no-follow'] === true;
+  execSync(noFollow ? `tail -n 100 ${LOG_PATH}` : `tail -f ${LOG_PATH}`, { stdio: 'inherit' });
+};

package/bin/commands/mcp-cmd.js

@@ -0,0 +1,57 @@
+/**
+ * mindos mcp — MCP server management
+ */
+
+import { resolve } from 'node:path';
+import { ROOT } from '../lib/constants.js';
+import { loadConfig } from '../lib/config.js';
+import { execInherited } from '../lib/shell.js';
+import { printCommandHelp } from '../lib/command.js';
+
+export const meta = {
+  name: 'mcp',
+  group: 'Connections',
+  summary: 'Manage AI agent connections',
+  usage: 'mindos mcp [install [agent]]',
+  examples: [
+    'mindos mcp',
+    'mindos mcp install',
+    'mindos mcp install cursor',
+  ],
+};
+
+export const run = async (args) => {
+  const sub = args[0];
+  const hasInstallFlags = args.some(a => ['-g', '--global', '-y', '--yes'].includes(a));
+
+  if (sub === 'install' || hasInstallFlags) {
+    const { mcpInstall } = await import('../lib/mcp-install.js');
+    await mcpInstall();
+    return;
+  }
+
+  // No subcommand in interactive terminal → show help
+  // (stdio mode is only meaningful when piped by an AI agent)
+  if (!sub && process.stdin.isTTY) {
+    printCommandHelp({ meta });
+    return;
+  }
+
+  loadConfig();
+
+  const { ensureMcpBundle } = await import('../lib/mcp-build.js');
+  await ensureMcpBundle();
+
+  if (!process.env.MCP_TRANSPORT) {
+    process.env.MCP_TRANSPORT = 'stdio';
+  }
+
+  const webPort = process.env.MINDOS_WEB_PORT || '3456';
+  process.env.MINDOS_URL = process.env.MINDOS_URL || `http://localhost:${webPort}`;
+
+  if (process.env.MCP_TRANSPORT === 'http') {
+    process.env.MCP_PORT = process.env.MINDOS_MCP_PORT || '8781';
+  }
+
+  execInherited(`node dist/index.cjs`, resolve(ROOT, 'mcp'));
+};

package/bin/commands/onboard.js

@@ -0,0 +1,25 @@
+/**
+ * mindos onboard — Interactive setup wizard
+ */
+
+import { resolve } from 'node:path';
+import { ROOT } from '../lib/constants.js';
+import { execInherited } from '../lib/shell.js';
+
+export const meta = {
+  name: 'onboard',
+  aliases: ['init', 'setup'],
+  group: 'Config',
+  summary: 'First-time setup wizard',
+  usage: 'mindos onboard',
+  examples: [
+    'mindos onboard',
+    'mindos init',
+    'mindos setup',
+  ],
+};
+
+export const run = (args, flags) => {
+  const daemonFlag = flags['install-daemon'] ? ' --install-daemon' : '';
+  execInherited(`node ${resolve(ROOT, 'scripts/setup.js')}${daemonFlag}`);
+};

package/bin/commands/open.js

@@ -0,0 +1,41 @@
+/**
+ * mindos open — Open Web UI in browser
+ */
+
+import { execSync } from 'node:child_process';
+import { loadConfig } from '../lib/config.js';
+import { cyan, green, dim } from '../lib/colors.js';
+
+export const meta = {
+  name: 'open',
+  group: 'Service',
+  summary: 'Open Web UI in browser',
+  usage: 'mindos open',
+};
+
+export const run = () => {
+  loadConfig();
+  const webPort = process.env.MINDOS_WEB_PORT || '3456';
+  const url = `http://localhost:${webPort}`;
+
+  let cmd;
+  if (process.platform === 'darwin') {
+    cmd = 'open';
+  } else if (process.platform === 'linux') {
+    try {
+      const uname = execSync('uname -r', { encoding: 'utf-8' });
+      cmd = uname.toLowerCase().includes('microsoft') ? 'wslview' : 'xdg-open';
+    } catch {
+      cmd = 'xdg-open';
+    }
+  } else {
+    cmd = 'start';
+  }
+
+  try {
+    execSync(`${cmd} ${url}`, { stdio: 'ignore' });
+    console.log(`${green('✔')} Opening ${cyan(url)}`);
+  } catch {
+    console.log(dim(`Could not open browser automatically. Visit: ${cyan(url)}`));
+  }
+};

package/bin/commands/restart.js

@@ -0,0 +1,48 @@
+/**
+ * mindos restart — Stop then start again
+ */
+
+import { loadConfig, getStartMode } from '../lib/config.js';
+import { stopMindos } from '../lib/stop.js';
+import { isPortInUse } from '../lib/port.js';
+
+export const meta = {
+  name: 'restart',
+  group: 'Service',
+  summary: 'Restart services',
+  usage: 'mindos restart',
+};
+
+export const run = async (args, flags) => {
+  const oldWebPort = process.env.MINDOS_OLD_WEB_PORT || process.env.MINDOS_WEB_PORT;
+  const oldMcpPort = process.env.MINDOS_OLD_MCP_PORT || process.env.MINDOS_MCP_PORT;
+
+  loadConfig();
+
+  const newWebPort = Number(process.env.MINDOS_WEB_PORT || '3456');
+  const newMcpPort = Number(process.env.MINDOS_MCP_PORT || '8781');
+
+  const extraPorts = [];
+  if (oldWebPort && Number(oldWebPort) !== newWebPort) extraPorts.push(oldWebPort);
+  if (oldMcpPort && Number(oldMcpPort) !== newMcpPort) extraPorts.push(oldMcpPort);
+
+  stopMindos({ extraPorts });
+
+  const allPorts = new Set([newWebPort, newMcpPort]);
+  for (const p of extraPorts) allPorts.add(Number(p));
+
+  const deadline = Date.now() + 15_000;
+  while (Date.now() < deadline) {
+    let anyBusy = false;
+    for (const p of allPorts) {
+      if (await isPortInUse(p)) { anyBusy = true; break; }
+    }
+    if (!anyBusy) break;
+    await new Promise((r) => setTimeout(r, 500));
+  }
+
+  // Dynamically resolve start mode and dispatch
+  const mode = getStartMode();
+  const startCmd = await import(`./${mode}.js`);
+  await startCmd.run(args, flags);
+};

package/bin/commands/search.js

@@ -1,32 +1,34 @@
 import { bold, dim, cyan, red } from '../lib/colors.js';
 import { loadConfig } from '../lib/config.js';
-import { output, isJsonMode, EXIT } from '../lib/command.js';
+import { output, isJsonMode, EXIT, printCommandHelp } from '../lib/command.js';
+import { getBaseUrl, getAuthHeaders } from '../lib/remote.js';
 
 export const meta = {
   name: 'search', group: 'Knowledge',
-  summary: 'Search knowledge base via API',
+  summary: 'Search your knowledge base',
   usage: 'mindos search "<query>"',
-  examples: ['mindos search "meeting notes"', 'mindos search "RAG" --limit 5 --json'],
+  flags: {
+    '--limit <n>': 'Max results (default: 20)',
+    '--json': 'Output as JSON',
+  },
+  examples: [
+    'mindos search "meeting notes"',
+    'mindos search "RAG" --limit 5 --json',
+  ],
 };
 
 export async function run(args, flags) {
   const query = args.join(' ');
-  if (!query || flags.help || flags.h) {
-    console.log(bold('mindos search') + ' — Knowledge base search');
-    console.log('');
-    console.log('Usage: mindos search "<query>"');
-    console.log('Flags: --limit <n> (default 20), --json');
-    console.log('Note: MindOS must be running. Offline: mindos file search "<query>"');
+  if (!query) {
+    printCommandHelp({ meta });
     return;
   }
   loadConfig();
-  const port = flags.port || process.env.MINDOS_WEB_PORT || '3456';
-  const token = process.env.MINDOS_AUTH_TOKEN || '';
+  const baseUrl = getBaseUrl();
   const limit = parseInt(flags.limit) || 20;
-  const headers = {};
-  if (token) headers['Authorization'] = 'Bearer ' + token;
+  const headers = getAuthHeaders();
   try {
-    const res = await fetch('http://localhost:' + port + '/api/search?q=' + encodeURIComponent(query) + '&limit=' + limit, { headers });
+    const res = await fetch(`${baseUrl}/api/search?q=${encodeURIComponent(query)}&limit=${limit}`, { headers });
     if (!res.ok) throw new Error('API error (' + res.status + ')');
     const data = await res.json();
     const results = data.results || data || [];

package/bin/commands/space.js

@@ -11,6 +11,7 @@ import { resolve, basename } from 'node:path';
 import { bold, dim, cyan, green, red, yellow } from '../lib/colors.js';
 import { loadConfig } from '../lib/config.js';
 import { output, isJsonMode, EXIT } from '../lib/command.js';
+import { isRemoteMode, apiCall } from '../lib/remote.js';
 
 function getMindRoot() {
   loadConfig();
@@ -25,7 +26,7 @@ function getMindRoot() {
 export const meta = {
   name: 'space',
   group: 'Knowledge',
-  summary: 'Knowledge base structure (ls, mkdir, rmdir, init, info, tree)',
+  summary: 'Manage spaces (list, tree, create, rename)',
   usage: 'mindos space <subcommand>',
   examples: [
     'mindos space ls',
@@ -42,34 +43,20 @@ export const meta = {
 
 export async function run(args, flags) {
   const sub = args[0];
-  const root = getMindRoot();
-
-  if (!sub || flags.help || flags.h) {
-    console.log(`
-${bold('mindos space')} — Knowledge base structure management
-
-${bold('Browse:')}
-  ${cyan('ls [path]'.padEnd(24))}${dim('List contents of a directory (default: root)')}
-  ${cyan('tree [path]'.padEnd(24))}${dim('Show directory tree recursively')}
-  ${cyan('info <path>'.padEnd(24))}${dim('Show directory details (type, files, modified)')}
-
-${bold('Structure:')}
-  ${cyan('create <name>'.padEnd(24))}${dim('Create a new Space (directory + INSTRUCTION.md)')}
-  ${cyan('mkdir <path>'.padEnd(24))}${dim('Create a directory (no INSTRUCTION.md)')}
-  ${cyan('rmdir <path>'.padEnd(24))}${dim('Delete a directory and all its contents')}
-  ${cyan('rename <old> <new>'.padEnd(24))}${dim('Rename or move a directory')}
-  ${cyan('init <path>'.padEnd(24))}${dim('Upgrade a directory to a Space (add INSTRUCTION.md)')}
+  loadConfig();
 
-${bold('Examples:')}
-  ${dim('mindos space ls')}
-  ${dim('mindos space ls "📝 笔记" --json')}
-  ${dim('mindos space tree "⚙️ 配置"')}
-  ${dim('mindos space mkdir "📝 笔记/新分类/子分类"')}
-  ${dim('mindos space init "exploration"')}
-`);
+  if (!sub) {
+    printHelp();
     return;
   }
 
+  // Remote mode: delegate to HTTP API
+  if (isRemoteMode()) {
+    return remoteSpaceDispatch(sub, args, flags);
+  }
+
+  const root = getMindRoot();
+
   switch (sub) {
     case 'ls': case 'list': return spaceLs(root, args[1], flags);
     case 'tree': return spaceTree(root, args[1], flags);
@@ -106,6 +93,10 @@ function countFiles(dir) {
 
 function resolvePath(root, relPath) {
   const full = relPath ? resolve(root, relPath) : root;
+  if (full !== root && !full.startsWith(root + '/')) {
+    console.error(red(`Access denied: path outside knowledge base`));
+    process.exit(EXIT.ERROR);
+  }
   if (!existsSync(full)) {
     console.error(red(`Not found: ${relPath || '(root)'}`));
     process.exit(EXIT.NOT_FOUND);
@@ -377,3 +368,87 @@ function spaceInit(root, relPath, flags) {
   }
   console.log(`${green('✔')} Initialized Space: ${cyan(relPath)}`);
 }
+
+// ── Remote mode: space operations via HTTP API ─────────────────────────────
+
+async function remoteSpaceDispatch(sub, args, flags) {
+  try {
+    switch (sub) {
+      case 'ls':
+      case 'list': {
+        const res = await apiCall('/api/file?op=list_spaces');
+        const data = await res.json();
+        const spaces = data.spaces || [];
+        if (isJsonMode(flags)) { output({ count: spaces.length, spaces }, flags); return; }
+        if (spaces.length === 0) { console.log(dim('No spaces found.')); return; }
+        console.log(`\n${bold(`Spaces (${spaces.length}):`)}\n`);
+        for (const s of spaces) {
+          const name = s.name || s.path || s;
+          const files = s.fileCount != null ? dim(` (${s.fileCount} files)`) : '';
+          console.log(`  ${cyan(name)}${files}`);
+        }
+        console.log();
+        return;
+      }
+
+      case 'create': {
+        const name = args[1];
+        if (!name) { console.error(red('Usage: mindos space create <name>')); process.exit(EXIT.ERROR); }
+        const res = await apiCall('/api/file', {
+          method: 'POST',
+          body: JSON.stringify({ action: 'create_space', name }),
+        });
+        await res.json();
+        if (isJsonMode(flags)) { output({ ok: true, name }, flags); return; }
+        console.log(`${green('✔')} Created Space: ${cyan(name)}`);
+        return;
+      }
+
+      case 'rename':
+      case 'mv': {
+        const oldName = args[1], newName = args[2];
+        if (!oldName || !newName) { console.error(red('Usage: mindos space rename <old> <new>')); process.exit(EXIT.ERROR); }
+        const res = await apiCall('/api/file', {
+          method: 'POST',
+          body: JSON.stringify({ action: 'rename_space', oldName, newName }),
+        });
+        await res.json();
+        if (isJsonMode(flags)) { output({ ok: true, from: oldName, to: newName }, flags); return; }
+        console.log(`${green('✔')} Renamed: ${oldName} → ${cyan(newName)}`);
+        return;
+      }
+
+      default:
+        console.error(red(`Remote mode does not support 'space ${sub}'. Use: list, create, rename`));
+        process.exit(EXIT.ERROR);
+    }
+  } catch (e) {
+    console.error(red(`Remote error: ${e.message}`));
+    process.exit(EXIT.ERROR);
+  }
+}
+
+export function printHelp() {
+  console.log(`
+${bold('mindos space')} — Knowledge base structure management
+
+${bold('Browse:')}
+  ${cyan('ls [path]'.padEnd(24))}${dim('List contents of a directory (default: root)')}
+  ${cyan('tree [path]'.padEnd(24))}${dim('Show directory tree recursively')}
+  ${cyan('info <path>'.padEnd(24))}${dim('Show directory details (type, files, modified)')}
+
+${bold('Structure:')}
+  ${cyan('create <name>'.padEnd(24))}${dim('Create a new Space (directory + INSTRUCTION.md)')}
+  ${cyan('mkdir <path>'.padEnd(24))}${dim('Create a directory (no INSTRUCTION.md)')}
+  ${cyan('rmdir <path>'.padEnd(24))}${dim('Delete a directory and all its contents')}
+  ${cyan('rename <old> <new>'.padEnd(24))}${dim('Rename or move a directory')}
+  ${cyan('init <path>'.padEnd(24))}${dim('Upgrade a directory to a Space (add INSTRUCTION.md)')}
+
+${bold('Examples:')}
+  ${dim('mindos space ls')}
+  ${dim('mindos space ls "📝 笔记" --json')}
+  ${dim('mindos space tree "⚙️ 配置"')}
+  ${dim('mindos space mkdir "📝 笔记/新分类/子分类"')}
+  ${dim('mindos space init "exploration"')}
+`);
+}