@geminilight/mindos 0.5.10 → 0.5.12

package/app/lib/agent/stream-consumer.ts

@@ -0,0 +1,178 @@
+import type { Message, MessagePart, ToolCallPart, TextPart } from '@/lib/types';
+
+/**
+ * Parse a UIMessageStream SSE response into structured Message parts.
+ * The stream format is Server-Sent Events where each data line is a JSON-encoded UIMessageChunk.
+ */
+export async function consumeUIMessageStream(
+  body: ReadableStream<Uint8Array>,
+  onUpdate: (message: Message) => void,
+  signal?: AbortSignal,
+): Promise<Message> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  // Mutable working copies — we deep-clone when emitting to React
+  const parts: MessagePart[] = [];
+  const toolCalls = new Map<string, ToolCallPart>();
+  let currentTextId: string | null = null;
+
+  /** Deep-clone parts into an immutable Message snapshot for React state */
+  function buildMessage(): Message {
+    const clonedParts: MessagePart[] = parts.map(p => {
+      if (p.type === 'text') return { type: 'text' as const, text: p.text };
+      return { ...p }; // ToolCallPart — shallow copy is safe (all primitive fields + `input` is replaced, not mutated)
+    });
+    const textContent = clonedParts
+      .filter((p): p is TextPart => p.type === 'text')
+      .map(p => p.text)
+      .join('');
+    return {
+      role: 'assistant',
+      content: textContent,
+      parts: clonedParts,
+    };
+  }
+
+  function findOrCreateTextPart(id: string): TextPart {
+    if (currentTextId === id) {
+      const last = parts[parts.length - 1];
+      if (last && last.type === 'text') return last;
+    }
+    const part: TextPart = { type: 'text', text: '' };
+    parts.push(part);
+    currentTextId = id;
+    return part;
+  }
+
+  function findOrCreateToolCall(toolCallId: string, toolName?: string): ToolCallPart {
+    let tc = toolCalls.get(toolCallId);
+    if (!tc) {
+      tc = {
+        type: 'tool-call',
+        toolCallId,
+        toolName: toolName ?? 'unknown',
+        input: undefined,
+        state: 'pending',
+      };
+      toolCalls.set(toolCallId, tc);
+      parts.push(tc);
+      currentTextId = null; // break text continuity
+    }
+    return tc;
+  }
+
+  try {
+    while (true) {
+      if (signal?.aborted) break;
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+
+      // Process complete SSE lines
+      const lines = buffer.split('\n');
+      buffer = lines.pop() ?? ''; // keep incomplete last line
+
+      let changed = false;
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+
+        // SSE format: the ai SDK v6 UIMessageStream uses "d:{json}\n"
+        // Also handle standard "data:{json}" for robustness
+        let jsonStr: string | null = null;
+        if (trimmed.startsWith('d:')) {
+          jsonStr = trimmed.slice(2);
+        } else if (trimmed.startsWith('data:')) {
+          jsonStr = trimmed.slice(5).trim();
+        }
+
+        if (!jsonStr) continue;
+
+        let chunk: Record<string, unknown>;
+        try {
+          chunk = JSON.parse(jsonStr);
+        } catch {
+          continue; // skip malformed lines
+        }
+
+        const type = chunk.type as string;
+
+        switch (type) {
+          case 'text-start': {
+            findOrCreateTextPart(chunk.id as string);
+            changed = true;
+            break;
+          }
+          case 'text-delta': {
+            const part = findOrCreateTextPart(chunk.id as string);
+            part.text += chunk.delta as string;
+            changed = true;
+            break;
+          }
+          case 'text-end': {
+            // Text part is complete — no state change needed
+            break;
+          }
+          case 'tool-input-start': {
+            const tc = findOrCreateToolCall(chunk.toolCallId as string, chunk.toolName as string);
+            tc.state = 'running';
+            changed = true;
+            break;
+          }
+          case 'tool-input-delta': {
+            // Streaming input — we wait for input-available for the complete input
+            break;
+          }
+          case 'tool-input-available': {
+            const tc = findOrCreateToolCall(chunk.toolCallId as string, chunk.toolName as string);
+            tc.input = chunk.input;
+            tc.state = 'running';
+            changed = true;
+            break;
+          }
+          case 'tool-output-available': {
+            const tc = toolCalls.get(chunk.toolCallId as string);
+            if (tc) {
+              tc.output = typeof chunk.output === 'string' ? chunk.output : JSON.stringify(chunk.output);
+              tc.state = 'done';
+              changed = true;
+            }
+            break;
+          }
+          case 'tool-output-error':
+          case 'tool-input-error': {
+            const tc = toolCalls.get(chunk.toolCallId as string);
+            if (tc) {
+              tc.output = (chunk.errorText as string) ?? 'Error';
+              tc.state = 'error';
+              changed = true;
+            }
+            break;
+          }
+          case 'error': {
+            const errorText = (chunk.errorText as string) ?? 'Unknown error';
+            parts.push({ type: 'text', text: `\n\n**Error:** ${errorText}` });
+            currentTextId = null;
+            changed = true;
+            break;
+          }
+          // step-start, reasoning-*, metadata, finish — ignored for now
+          default:
+            break;
+        }
+      }
+
+      // Emit once per reader.read() batch, not per SSE line
+      if (changed) {
+        onUpdate(buildMessage());
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  return buildMessage();
+}

package/app/lib/agent/tools.ts

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import {
   searchFiles, getFileContent, getFileTree, getRecentlyModified,
   saveFileContent, createFile, appendToFile, insertAfterHeading, updateSection,
+  deleteFile, renameFile, moveFile, findBacklinks, gitLog, gitShowFile, appendCsvRow,
 } from '@/lib/fs';
 import { assertNotProtected } from '@/lib/core';
 import { logAgentOp } from './log';
@@ -169,4 +170,125 @@ export const knowledgeBaseTools = {
       }
     }),
   }),
+
+  // ─── New tools (Phase 1a) ──────────────────────────────────────────────────
+
+  delete_file: tool({
+    description: 'Permanently delete a file from the knowledge base. This is destructive and cannot be undone.',
+    inputSchema: z.object({
+      path: z.string().describe('Relative file path to delete'),
+    }),
+    execute: logged('delete_file', async ({ path }) => {
+      try {
+        assertWritable(path);
+        deleteFile(path);
+        return `File deleted: ${path}`;
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  rename_file: tool({
+    description: 'Rename a file within its current directory. Only the filename changes, not the directory.',
+    inputSchema: z.object({
+      path: z.string().describe('Current relative file path'),
+      new_name: z.string().describe('New filename (no path separators, e.g. "new-name.md")'),
+    }),
+    execute: logged('rename_file', async ({ path, new_name }) => {
+      try {
+        assertWritable(path);
+        const newPath = renameFile(path, new_name);
+        return `File renamed: ${path} → ${newPath}`;
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  move_file: tool({
+    description: 'Move a file to a new location. Also returns any files that had backlinks affected by the move.',
+    inputSchema: z.object({
+      from_path: z.string().describe('Current relative file path'),
+      to_path: z.string().describe('New relative file path'),
+    }),
+    execute: logged('move_file', async ({ from_path, to_path }) => {
+      try {
+        assertWritable(from_path);
+        const result = moveFile(from_path, to_path);
+        const affected = result.affectedFiles.length > 0
+          ? `\nAffected backlinks in: ${result.affectedFiles.join(', ')}`
+          : '';
+        return `File moved: ${from_path} → ${result.newPath}${affected}`;
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  get_backlinks: tool({
+    description: 'Find all files that reference a given file path. Useful for understanding connections between notes.',
+    inputSchema: z.object({
+      path: z.string().describe('Relative file path to find backlinks for'),
+    }),
+    execute: logged('get_backlinks', async ({ path }) => {
+      try {
+        const backlinks = findBacklinks(path);
+        if (backlinks.length === 0) return `No backlinks found for: ${path}`;
+        return backlinks.map(b => `- **${b.source}** (L${b.line}): ${b.context}`).join('\n');
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  get_history: tool({
+    description: 'Get git commit history for a file. Shows recent commits that modified this file.',
+    inputSchema: z.object({
+      path: z.string().describe('Relative file path'),
+      limit: z.number().min(1).max(50).default(10).describe('Number of commits to return'),
+    }),
+    execute: logged('get_history', async ({ path, limit }) => {
+      try {
+        const commits = gitLog(path, limit);
+        if (commits.length === 0) return `No git history found for: ${path}`;
+        return commits.map(c => `- \`${c.hash.slice(0, 7)}\` ${c.date} — ${c.message} (${c.author})`).join('\n');
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  get_file_at_version: tool({
+    description: 'Read the content of a file at a specific git commit. Use get_history first to find commit hashes.',
+    inputSchema: z.object({
+      path: z.string().describe('Relative file path'),
+      commit: z.string().describe('Git commit hash (full or abbreviated)'),
+    }),
+    execute: logged('get_file_at_version', async ({ path, commit }) => {
+      try {
+        const content = gitShowFile(path, commit);
+        return truncate(content);
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  append_csv: tool({
+    description: 'Append a row to a CSV file. Values are automatically escaped per RFC 4180.',
+    inputSchema: z.object({
+      path: z.string().describe('Relative path to .csv file'),
+      row: z.array(z.string()).describe('Array of cell values for the new row'),
+    }),
+    execute: logged('append_csv', async ({ path, row }) => {
+      try {
+        assertWritable(path);
+        const result = appendCsvRow(path, row);
+        return `Row appended to ${path} (now ${result.newRowCount} rows)`;
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
 };

package/app/lib/i18n.ts

@@ -119,6 +119,15 @@ export const messages = {
         resetToEnv: 'Reset to env value',
         restoreFromEnv: 'Restore from env',
         noApiKey: 'API key is not set. AI features will be unavailable until you add one.',
+        testKey: 'Test',
+        testKeyTesting: 'Testing...',
+        testKeyOk: (ms: number) => `\u2713 ${ms}ms`,
+        testKeyAuthError: 'Invalid API key',
+        testKeyModelNotFound: 'Model not found',
+        testKeyRateLimited: 'Rate limited, try again later',
+        testKeyNetworkError: 'Network error',
+        testKeyNoKey: 'No API key configured',
+        testKeyUnknown: 'Test failed',
       },
       appearance: {
         readingFont: 'Reading font',
@@ -514,6 +523,15 @@ export const messages = {
         resetToEnv: '恢复为环境变量',
         restoreFromEnv: '从环境变量恢复',
         noApiKey: 'API 密钥未设置，AI 功能暂不可用，请在此填写。',
+        testKey: '测试',
+        testKeyTesting: '测试中...',
+        testKeyOk: (ms: number) => `\u2713 ${ms}ms`,
+        testKeyAuthError: 'API Key 无效',
+        testKeyModelNotFound: '模型不存在',
+        testKeyRateLimited: '请求频率限制，稍后重试',
+        testKeyNetworkError: '网络错误',
+        testKeyNoKey: '未配置 API Key',
+        testKeyUnknown: '测试失败',
       },
       appearance: {
         readingFont: '正文字体',

package/app/lib/types.ts

@@ -13,9 +13,27 @@ export interface BacklinkItem {
   snippets: string[];
 }
 
+export interface ToolCallPart {
+  type: 'tool-call';
+  toolCallId: string;
+  toolName: string;
+  input: unknown;
+  output?: string;
+  state: 'pending' | 'running' | 'done' | 'error';
+}
+
+export interface TextPart {
+  type: 'text';
+  text: string;
+}
+
+export type MessagePart = TextPart | ToolCallPart;
+
 export interface Message {
   role: 'user' | 'assistant';
   content: string;
+  /** Structured parts for assistant messages (tool calls + text segments) */
+  parts?: MessagePart[];
 }
 
 export interface LocalAttachment {

package/app/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/types/routes.d.ts";
+import "./.next/dev/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/app/next.config.ts

@@ -3,7 +3,7 @@ import path from "path";
 
 const nextConfig: NextConfig = {
   transpilePackages: ['github-slugger'],
-  serverExternalPackages: ['pdfjs-dist', 'pdf-parse'],
+  serverExternalPackages: ['pdfjs-dist', 'pdf-parse', 'chokidar'],
   outputFileTracingRoot: path.join(__dirname),
   turbopack: {
     root: path.join(__dirname),

package/app/package.json

@@ -3,10 +3,10 @@
   "version": "0.1.0",
   "private": true,
   "scripts": {
-    "dev": "next dev -p ${MINDOS_WEB_PORT:-3000}",
+    "dev": "next dev -p ${MINDOS_WEB_PORT:-3456}",
     "prebuild": "node ../scripts/gen-renderer-index.js",
     "build": "next build",
-    "start": "next start -p ${MINDOS_WEB_PORT:-3000}",
+    "start": "next start -p ${MINDOS_WEB_PORT:-3456}",
     "lint": "eslint",
     "test": "vitest run"
   },

package/bin/cli.js

@@ -50,7 +50,7 @@ import { needsBuild, writeBuildStamp, clearBuildLock, cleanNextDir, ensureAppDep
 import { isPortInUse, assertPortFree } from './lib/port.js';
 import { savePids, clearPids } from './lib/pid.js';
 import { stopMindos } from './lib/stop.js';
-import { getPlatform, ensureMindosDir, waitForHttp, runGatewayCommand } from './lib/gateway.js';
+import { getPlatform, ensureMindosDir, waitForHttp, waitForPortFree, runGatewayCommand } from './lib/gateway.js';
 import { printStartupInfo, getLocalIP } from './lib/startup.js';
 import { spawnMcp } from './lib/mcp-spawn.js';
 import { mcpInstall } from './lib/mcp-install.js';
@@ -84,7 +84,7 @@ const commands = {
   // ── open ───────────────────────────────────────────────────────────────────
   open: () => {
     loadConfig();
-    const webPort = process.env.MINDOS_WEB_PORT || '3000';
+    const webPort = process.env.MINDOS_WEB_PORT || '3456';
     const url = `http://localhost:${webPort}`;
     let cmd;
     if (process.platform === 'darwin') {
@@ -121,7 +121,7 @@ const commands = {
       console.log(dim('No auth token set. Run `mindos onboard` to configure one.'));
       process.exit(0);
     }
-    const mcpPort = config.mcpPort || 8787;
+    const mcpPort = config.mcpPort || 8781;
     const localIP = getLocalIP();
 
     const localUrl = `http://localhost:${mcpPort}/mcp`;
@@ -197,8 +197,8 @@ const commands = {
   // ── dev ────────────────────────────────────────────────────────────────────
   dev: async () => {
     loadConfig();
-    const webPort = process.env.MINDOS_WEB_PORT || '3000';
-    const mcpPort = process.env.MINDOS_MCP_PORT || '8787';
+    const webPort = process.env.MINDOS_WEB_PORT || '3456';
+    const mcpPort = process.env.MINDOS_MCP_PORT || '8781';
     await assertPortFree(Number(webPort), 'web');
     await assertPortFree(Number(mcpPort), 'mcp');
     ensureAppDeps();
@@ -231,11 +231,13 @@ const commands = {
         console.warn(yellow('Warning: daemon mode not supported on this platform. Falling back to foreground.'));
       } else {
         loadConfig();
-        const webPort = process.env.MINDOS_WEB_PORT || '3000';
-        const mcpPort = process.env.MINDOS_MCP_PORT || '8787';
+        const webPort = process.env.MINDOS_WEB_PORT || '3456';
+        const mcpPort = process.env.MINDOS_MCP_PORT || '8781';
         console.log(cyan(`Installing MindOS as a background service (${platform})...`));
         await runGatewayCommand('install');
-        await runGatewayCommand('start');
+        // install() already starts the service via launchctl bootstrap + RunAtLoad=true.
+        // Do NOT call start() here — kickstart -k would kill the just-started process,
+        // causing a port-conflict race condition with KeepAlive restart loops.
         console.log(dim('  (First run may take a few minutes to install dependencies and build the app.)'));
         console.log(dim('  Follow live progress with:  mindos logs\n'));
         const ready = await waitForHttp(Number(webPort), { retries: 120, intervalMs: 2000, label: 'Web UI' });
@@ -261,10 +263,26 @@ const commands = {
       }
     }
     loadConfig();
-    const webPort = process.env.MINDOS_WEB_PORT || '3000';
-    const mcpPort = process.env.MINDOS_MCP_PORT || '8787';
-    await assertPortFree(Number(webPort), 'web');
-    await assertPortFree(Number(mcpPort), 'mcp');
+    const webPort = process.env.MINDOS_WEB_PORT || '3456';
+    const mcpPort = process.env.MINDOS_MCP_PORT || '8781';
+
+    // When launched by a daemon manager (launchd/systemd), wait for ports to
+    // free instead of exiting immediately — the previous instance may still be
+    // shutting down after a restart/update.
+    const launchedByDaemon = process.env.LAUNCHED_BY_LAUNCHD === '1'
+      || !!process.env.INVOCATION_ID; /* systemd sets INVOCATION_ID */
+
+    if (launchedByDaemon) {
+      const webOk = await waitForPortFree(Number(webPort), { retries: 60, intervalMs: 500 });
+      const mcpOk = await waitForPortFree(Number(mcpPort), { retries: 60, intervalMs: 500 });
+      if (!webOk || !mcpOk) {
+        console.error('Ports still in use after 30s, exiting.');
+        process.exit(1);  // KeepAlive will retry after ThrottleInterval
+      }
+    } else {
+      await assertPortFree(Number(webPort), 'web');
+      await assertPortFree(Number(mcpPort), 'mcp');
+    }
     ensureAppDeps();
     if (needsBuild()) {
       console.log(yellow('Building MindOS (first run or new version detected)...\n'));
@@ -306,8 +324,8 @@ const commands = {
       run('npm install --prefer-offline --no-workspaces', resolve(ROOT, 'mcp'));
     }
     // Map config env vars to what the MCP server expects
-    const mcpPort = process.env.MINDOS_MCP_PORT || '8787';
-    const webPort = process.env.MINDOS_WEB_PORT || '3000';
+    const mcpPort = process.env.MINDOS_MCP_PORT || '8781';
+    const webPort = process.env.MINDOS_WEB_PORT || '3456';
     process.env.MCP_PORT   = mcpPort;
     process.env.MINDOS_URL = `http://localhost:${webPort}`;
     run(`npx tsx src/index.ts`, resolve(ROOT, 'mcp'));
@@ -328,8 +346,8 @@ const commands = {
     loadConfig();
 
     // After loadConfig, env vars reflect the NEW config (or old if unchanged).
-    const newWebPort = Number(process.env.MINDOS_WEB_PORT || '3000');
-    const newMcpPort = Number(process.env.MINDOS_MCP_PORT || '8787');
+    const newWebPort = Number(process.env.MINDOS_WEB_PORT || '3456');
+    const newMcpPort = Number(process.env.MINDOS_MCP_PORT || '8781');
 
     // Collect old ports that differ from new ones — processes may still be
     // listening there even though config already points to the new ports.
@@ -465,8 +483,8 @@ ${dim('Shortcut: mindos start --daemon  →  install + start in one step')}
     }
 
     // 6. Ports
-    const webPort = Number(config?.port || process.env.MINDOS_WEB_PORT || 3000);
-    const mcpPort = Number(config?.mcpPort || process.env.MINDOS_MCP_PORT || 8787);
+    const webPort = Number(config?.port || process.env.MINDOS_WEB_PORT || 3456);
+    const mcpPort = Number(config?.mcpPort || process.env.MINDOS_MCP_PORT || 8781);
     const webInUse = await isPortInUse(webPort);
     const mcpInUse = await isPortInUse(mcpPort);
     if (webInUse) {
@@ -582,11 +600,13 @@ ${dim('Shortcut: mindos start --daemon  →  install + start in one step')}
       console.log(cyan('\n  Daemon is running — restarting to apply the new version...'));
       await runGatewayCommand('stop');
       await runGatewayCommand('install');
-      await runGatewayCommand('start');
+      // Note: install() already starts the service via launchctl bootstrap + RunAtLoad=true.
+      // Do NOT call start() here — kickstart -k would kill the just-started process,
+      // causing a port-conflict race condition with KeepAlive restart loops.
       const webPort = (() => {
-        try { return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')).port ?? 3000; } catch { return 3000; }
+        try { return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')).port ?? 3456; } catch { return 3456; }
       })();
-      console.log(dim('  (Waiting for Web UI to come back up...)'));
+      console.log(dim('  (Waiting for Web UI to come back up — first run after update includes a rebuild...)'));
       const ready = await waitForHttp(Number(webPort), { retries: 120, intervalMs: 2000, label: 'Web UI' });
       if (ready) {
         console.log(green('✔ MindOS restarted and ready.\n'));
@@ -803,7 +823,14 @@ ${bold('Examples:')}
     }
 
     if (sub === 'now') {
-      manualSync(mindRoot);
+      try {
+        console.log(dim('Pulling...'));
+        manualSync(mindRoot);
+        console.log(green('✔ Sync complete'));
+      } catch (err) {
+        console.error(red(err.message));
+        process.exit(1);
+      }
       return;
     }
 

package/bin/lib/gateway.js

@@ -1,5 +1,5 @@
 import { execSync } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, statSync, renameSync, unlinkSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { MINDOS_DIR, LOG_PATH, CLI_PATH, NODE_BIN, CONFIG_PATH } from './constants.js';
@@ -8,6 +8,18 @@ import { isPortInUse } from './port.js';
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
+/** Rotate log file when it exceeds 2 MB. Keeps at most one .old backup. */
+function rotateLogs() {
+  try {
+    const stat = statSync(LOG_PATH);
+    if (stat.size > 2 * 1024 * 1024) {
+      const old = LOG_PATH + '.old';
+      try { unlinkSync(old); } catch {}
+      renameSync(LOG_PATH, old);
+    }
+  } catch { /* file doesn't exist yet, nothing to rotate */ }
+}
+
 export function getPlatform() {
   if (process.platform === 'darwin') return 'launchd';
   if (process.platform === 'linux')  return 'systemd';
@@ -72,6 +84,7 @@ const systemd = {
   install() {
     if (!existsSync(SYSTEMD_DIR)) mkdirSync(SYSTEMD_DIR, { recursive: true });
     ensureMindosDir();
+    rotateLogs();
     const currentPath = process.env.PATH ?? '/usr/local/bin:/usr/bin:/bin';
     const unit = [
       '[Unit]',
@@ -100,6 +113,7 @@ const systemd = {
   },
 
   async start() {
+    rotateLogs();
     execSync('systemctl --user start mindos', { stdio: 'inherit' });
     const ok = await waitForService(() => {
       try {
@@ -153,6 +167,7 @@ const launchd = {
   install() {
     if (!existsSync(LAUNCHD_DIR)) mkdirSync(LAUNCHD_DIR, { recursive: true });
     ensureMindosDir();
+    rotateLogs();
     const currentPath = process.env.PATH ?? '/usr/local/bin:/usr/bin:/bin';
     const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -166,13 +181,18 @@ const launchd = {
     <string>start</string>
   </array>
   <key>RunAtLoad</key><true/>
-  <key>KeepAlive</key><true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key><false/>
+  </dict>
+  <key>ThrottleInterval</key><integer>5</integer>
   <key>StandardOutPath</key><string>${LOG_PATH}</string>
   <key>StandardErrorPath</key><string>${LOG_PATH}</string>
   <key>EnvironmentVariables</key>
   <dict>
     <key>HOME</key><string>${homedir()}</string>
     <key>PATH</key><string>${currentPath}</string>
+    <key>LAUNCHED_BY_LAUNCHD</key><string>1</string>
   </dict>
 </dict>
 </plist>
@@ -192,6 +212,7 @@ const launchd = {
   },
 
   async start() {
+    rotateLogs();
     execSync(`launchctl kickstart -k gui/${launchctlUid()}/${LAUNCHD_LABEL}`, { stdio: 'inherit' });
     const ok = await waitForService(() => {
       try {
@@ -209,7 +230,7 @@ const launchd = {
 
   async stop() {
     // Read ports before bootout so we can wait for them to be freed
-    let webPort = 3000, mcpPort = 8787;
+    let webPort = 3456, mcpPort = 8781;
     try {
       const config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
       if (config.port) webPort = Number(config.port);

package/bin/lib/mcp-install.js

@@ -253,8 +253,8 @@ export async function mcpInstall() {
     const ask2 = (q) => new Promise(r => rl2.question(q, r));
 
     if (!url) {
-      let mcpPort = 8787;
-      try { mcpPort = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')).mcpPort || 8787; } catch {}
+      let mcpPort = 8781;
+      try { mcpPort = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')).mcpPort || 8781; } catch {}
       const defaultUrl = `http://localhost:${mcpPort}/mcp`;
       url = hasYesFlag ? defaultUrl : (await ask2(`${bold('MCP URL')} ${dim(`[${defaultUrl}]:`)} `)).trim() || defaultUrl;
     }

package/bin/lib/mcp-spawn.js

@@ -5,8 +5,8 @@ import { ROOT } from './constants.js';
 import { bold, red, yellow } from './colors.js';
 
 export function spawnMcp(verbose = false) {
-  const mcpPort = process.env.MINDOS_MCP_PORT || '8787';
-  const webPort = process.env.MINDOS_WEB_PORT || '3000';
+  const mcpPort = process.env.MINDOS_MCP_PORT || '8781';
+  const webPort = process.env.MINDOS_WEB_PORT || '3456';
   // Ensure mcp/node_modules exists (auto-install on first run)
   const mcpSdk = resolve(ROOT, 'mcp', 'node_modules', '@modelcontextprotocol', 'sdk', 'package.json');
   if (!existsSync(mcpSdk)) {
@@ -16,7 +16,7 @@ export function spawnMcp(verbose = false) {
   const env = {
     ...process.env,
     MCP_PORT: mcpPort,
-    MINDOS_URL: `http://localhost:${webPort}`,
+    MINDOS_URL: process.env.MINDOS_URL || `http://127.0.0.1:${webPort}`,
     ...(verbose ? { MCP_VERBOSE: '1' } : {}),
   };
   const child = spawn('npx', ['tsx', 'src/index.ts'], {