@geminilight/mindos 0.6.8 → 0.6.13

package/app/lib/organize-history.ts

@@ -0,0 +1,74 @@
+'use client';
+
+// ---------------------------------------------------------------------------
+// Organize History — localStorage persistence for past AI organize operations
+// ---------------------------------------------------------------------------
+
+export interface OrganizeHistoryFile {
+  action: 'create' | 'update' | 'unknown';
+  path: string;
+  ok: boolean;
+  /** Undone by user (deleted for create / restored for update) */
+  undone?: boolean;
+}
+
+export interface OrganizeHistoryEntry {
+  id: string;
+  /** Unix ms */
+  timestamp: number;
+  /** Original uploaded file names */
+  sourceFiles: string[];
+  files: OrganizeHistoryFile[];
+  status: 'completed' | 'partial' | 'undone';
+}
+
+const STORAGE_KEY = 'mindos:organize-history';
+const MAX_ENTRIES = 50;
+
+export function loadHistory(): OrganizeHistoryEntry[] {
+  if (typeof window === 'undefined') return [];
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return [];
+    return JSON.parse(raw) as OrganizeHistoryEntry[];
+  } catch {
+    return [];
+  }
+}
+
+export function saveHistory(entries: OrganizeHistoryEntry[]): void {
+  if (typeof window === 'undefined') return;
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(entries.slice(0, MAX_ENTRIES)));
+  } catch { /* quota exceeded — silently drop oldest */ }
+}
+
+export function appendEntry(entry: OrganizeHistoryEntry): OrganizeHistoryEntry[] {
+  const all = loadHistory();
+  all.unshift(entry);
+  const trimmed = all.slice(0, MAX_ENTRIES);
+  saveHistory(trimmed);
+  return trimmed;
+}
+
+export function updateEntry(id: string, patch: Partial<OrganizeHistoryEntry>): OrganizeHistoryEntry[] {
+  const all = loadHistory();
+  const idx = all.findIndex(e => e.id === id);
+  if (idx >= 0) {
+    all[idx] = { ...all[idx], ...patch };
+    saveHistory(all);
+  }
+  return all;
+}
+
+export function clearHistory(): void {
+  if (typeof window === 'undefined') return;
+  try {
+    localStorage.removeItem(STORAGE_KEY);
+  } catch { /* ignore */ }
+}
+
+let _idCounter = 0;
+export function generateEntryId(): string {
+  return `org-${Date.now()}-${++_idCounter}`;
+}

package/app/lib/settings.ts

@@ -23,6 +23,7 @@ export interface AgentConfig {
   enableThinking?: boolean;   // default false, Anthropic only
   thinkingBudget?: number;    // default 5000
   contextStrategy?: 'auto' | 'off'; // default 'auto'
+  reconnectRetries?: number;  // default 3, range 0-10 (0 = disabled)
 }
 
 export interface GuideState {
@@ -128,6 +129,7 @@ function parseAgent(raw: unknown): AgentConfig | undefined {
   if (typeof obj.enableThinking === 'boolean') result.enableThinking = obj.enableThinking;
   if (typeof obj.thinkingBudget === 'number') result.thinkingBudget = Math.min(50000, Math.max(1000, obj.thinkingBudget));
   if (obj.contextStrategy === 'auto' || obj.contextStrategy === 'off') result.contextStrategy = obj.contextStrategy;
+  if (typeof obj.reconnectRetries === 'number') result.reconnectRetries = Math.min(10, Math.max(0, obj.reconnectRetries));
   return Object.keys(result).length > 0 ? result : undefined;
 }
 

package/app/lib/types.ts

@@ -41,6 +41,8 @@ export interface Message {
   timestamp?: number;
   /** Structured parts for assistant messages (tool calls + text segments) */
   parts?: MessagePart[];
+  /** Skill name used for this user message (rendered as a capsule in the UI) */
+  skillName?: string;
 }
 
 export interface LocalAttachment {

package/app/next.config.ts

@@ -1,21 +1,39 @@
 import type { NextConfig } from "next";
 import path from "path";
 
+// When MindOS is installed globally via npm, the entire project lives
+// under node_modules/@geminilight/mindos/. Next.js skips tsconfig path
+// resolution and SWC TypeScript compilation for files inside node_modules.
+// We detect this at config time and apply the necessary overrides.
+const projectDir = path.resolve(__dirname);
+const inNodeModules = projectDir.includes('node_modules');
+
 const nextConfig: NextConfig = {
-  transpilePackages: ['github-slugger'],
+  transpilePackages: [
+    'github-slugger',
+    // Self-reference: ensures the SWC loader compiles our own TypeScript
+    // when the project is inside node_modules (global npm install).
+    ...(inNodeModules ? ['@geminilight/mindos'] : []),
+  ],
   serverExternalPackages: ['chokidar', 'openai', '@mariozechner/pi-ai', '@mariozechner/pi-agent-core', '@mariozechner/pi-coding-agent', 'mcporter'],
   output: 'standalone',
-  outputFileTracingRoot: path.join(__dirname),
+  outputFileTracingRoot: projectDir,
   turbopack: {
-    root: path.join(__dirname),
+    root: projectDir,
   },
-  // Disable client-side router cache for dynamic layouts so that
-  // router.refresh() always fetches a fresh file tree from the server.
   experimental: {
     staleTimes: {
       dynamic: 0,
     },
   },
+  webpack: (config) => {
+    if (inNodeModules) {
+      config.resolve = config.resolve ?? {};
+      config.resolve.alias = config.resolve.alias ?? {};
+      (config.resolve.alias as Record<string, string>)['@'] = projectDir;
+    }
+    return config;
+  },
 };
 
 export default nextConfig;

package/bin/cli.js

@@ -40,7 +40,7 @@
 
 import { execSync, spawn as nodeSpawn } from 'node:child_process';
 import { existsSync, readFileSync, writeFileSync, rmSync, cpSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { dirname, resolve } from 'node:path';
 import { homedir } from 'node:os';
 
 import { ROOT, CONFIG_PATH, BUILD_STAMP, LOG_PATH, MINDOS_DIR } from './lib/constants.js';
@@ -57,6 +57,7 @@ import { stopMindos } from './lib/stop.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 { ensureMcpBundle } from './lib/mcp-build.js';
 import { mcpInstall } from './lib/mcp-install.js';
 import { initSync, startSyncDaemon, stopSyncDaemon, getSyncStatus, manualSync, listConflicts, setSyncEnabled } from './lib/sync.js';
 
@@ -403,7 +404,7 @@ const commands = {
     run(
       `${NEXT_BIN} start -p ${webPort} ${extra}`,
       resolve(ROOT, 'app'),
-      process.env.HOSTNAME ? undefined : { HOSTNAME: '127.0.0.1' }
+      { HOSTNAME: '127.0.0.1' }
     );
   },
 
@@ -422,11 +423,7 @@ const commands = {
     const hasInstallFlags = restArgs.some(a => ['-g', '--global', '-y', '--yes'].includes(a));
     if (sub === 'install' || hasInstallFlags) { await mcpInstall(); return; }
     loadConfig();
-    const mcpSdk = resolve(ROOT, 'mcp', 'node_modules', '@modelcontextprotocol', 'sdk', 'package.json');
-    if (!existsSync(mcpSdk)) {
-      console.log(yellow('Installing MCP dependencies (first run)...\n'));
-      npmInstall(resolve(ROOT, 'mcp'), '--no-workspaces');
-    }
+    ensureMcpBundle();
     // `mindos mcp` is the entry point for MCP clients (Claude Code, Cursor, etc.)
     // which communicate over stdin/stdout. Default to stdio; HTTP is handled by
     // `mindos start` via spawnMcp(). Callers can still override via env.
@@ -790,7 +787,7 @@ ${dim('Shortcut: mindos start --daemon  →  install + start in one step')}
       const webPort = updateConfig.port ?? 3456;
       const mcpPort = updateConfig.mcpPort ?? 8781;
       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', logFile: LOG_PATH });
+      const ready = await waitForHttp(Number(webPort), { retries: 180, intervalMs: 2000, label: 'Web UI', logFile: LOG_PATH });
       if (ready) {
         const localIP = getLocalIP();
         console.log(`\n${'─'.repeat(53)}`);
@@ -849,7 +846,7 @@ ${dim('Shortcut: mindos start --daemon  →  install + start in one step')}
         child.unref();
 
         console.log(dim('  (Waiting for Web UI to come back up...)'));
-        const ready = await waitForHttp(webPort, { retries: 120, intervalMs: 2000, label: 'Web UI', logFile: LOG_PATH });
+        const ready = await waitForHttp(webPort, { retries: 180, intervalMs: 2000, label: 'Web UI', logFile: LOG_PATH });
         if (ready) {
           const localIP = getLocalIP();
           console.log(`\n${'─'.repeat(53)}`);

package/bin/lib/mcp-build.js

@@ -0,0 +1,74 @@
+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';
+
+export const MCP_DIR = resolve(ROOT, 'mcp');
+export const MCP_SRC_DIR = resolve(MCP_DIR, 'src');
+export const MCP_BUNDLE = resolve(MCP_DIR, 'dist', 'index.cjs');
+
+const MCP_PACKAGE_JSON = resolve(MCP_DIR, 'package.json');
+const MCP_PACKAGE_LOCK = resolve(MCP_DIR, 'package-lock.json');
+const MCP_SDK = resolve(MCP_DIR, 'node_modules', '@modelcontextprotocol', 'sdk', 'package.json');
+const MCP_ESBUILD = resolve(MCP_DIR, 'node_modules', 'esbuild', 'package.json');
+
+function safeMtime(filePath) {
+  try {
+    return statSync(filePath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+function latestTreeMtime(dirPath) {
+  if (!existsSync(dirPath)) return 0;
+
+  let latest = safeMtime(dirPath);
+  for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+    const fullPath = resolve(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      latest = Math.max(latest, latestTreeMtime(fullPath));
+    } else {
+      latest = Math.max(latest, safeMtime(fullPath));
+    }
+  }
+  return latest;
+}
+
+function hasBuildDeps() {
+  return existsSync(MCP_SDK) && existsSync(MCP_ESBUILD);
+}
+
+export function needsMcpBuild() {
+  if (!existsSync(MCP_BUNDLE)) return true;
+
+  const bundleMtime = safeMtime(MCP_BUNDLE);
+  const sourceMtime = Math.max(
+    latestTreeMtime(MCP_SRC_DIR),
+    safeMtime(MCP_PACKAGE_JSON),
+    safeMtime(MCP_PACKAGE_LOCK),
+  );
+
+  return sourceMtime > bundleMtime;
+}
+
+export function ensureMcpBundle() {
+  if (!needsMcpBuild()) return;
+
+  const hadBundle = existsSync(MCP_BUNDLE);
+
+  if (!hasBuildDeps()) {
+    console.log(yellow('Installing MCP build dependencies...\n'));
+    npmInstall(MCP_DIR, '--no-workspaces');
+  }
+
+  console.log(yellow(hadBundle
+    ? 'Rebuilding MCP bundle (source changed)...\n'
+    : 'Building MCP bundle (first run)...\n'));
+  run('npm run build', MCP_DIR);
+
+  if (!existsSync(MCP_BUNDLE)) {
+    throw new Error(`MCP bundle build did not produce ${MCP_BUNDLE}`);
+  }
+}

package/bin/lib/mcp-spawn.js

@@ -1,17 +1,20 @@
 import { spawn } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { ROOT, CONFIG_PATH } from './constants.js';
 import { bold, red } from './colors.js';
+import { ensureMcpBundle, MCP_BUNDLE } from './mcp-build.js';
 
 export function spawnMcp(verbose = false) {
   const mcpPort = process.env.MINDOS_MCP_PORT || '8781';
   const webPort = process.env.MINDOS_WEB_PORT || '3456';
 
-  const mcpBundle = resolve(ROOT, 'mcp', 'dist', 'index.cjs');
-  if (!existsSync(mcpBundle)) {
+  try {
+    ensureMcpBundle();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
     throw new Error(
-      `MCP bundle not found: ${mcpBundle}\n` +
+      `${message}\n` +
       `This MindOS installation may be corrupted. Try: npm install -g @geminilight/mindos@latest`,
     );
   }
@@ -31,7 +34,7 @@ export function spawnMcp(verbose = false) {
     ...(configAuthToken ? { AUTH_TOKEN: configAuthToken } : {}),
     ...(verbose ? { MCP_VERBOSE: '1' } : {}),
   };
-  const child = spawn(process.execPath, [mcpBundle], {
+  const child = spawn(process.execPath, [MCP_BUNDLE], {
     cwd: resolve(ROOT, 'mcp'),
     stdio: 'inherit',
     env,

package/bin/lib/port.js

@@ -1,5 +1,5 @@
 import { createConnection } from 'node:net';
-import { bold, dim, red } from './colors.js';
+import { bold, dim, red, yellow } from './colors.js';
 
 export function isPortInUse(port) {
   return new Promise((resolve) => {
@@ -16,10 +16,25 @@ export function isPortInUse(port) {
 }
 
 export async function assertPortFree(port, name) {
+  if (!(await isPortInUse(port))) return;
+
+  // Port is occupied — try to clean up orphaned processes from a previous
+  // installation (e.g. user deleted MindOS.app from Finder without quitting,
+  // leaving behind zombie Next.js / MCP processes on the default ports).
+  console.warn(`${yellow('⚠')} Port ${port} in use (${name}) — attempting cleanup...`);
+  try {
+    const { stopMindos } = await import('./stop.js');
+    stopMindos();
+    // Wait briefly for ports to release after SIGTERM
+    await new Promise(r => setTimeout(r, 1500));
+  } catch { /* stopMindos may fail if no config exists yet — that's fine */ }
+
+  // Re-check after cleanup
   if (await isPortInUse(port)) {
-    console.error(`\n${red('\u2718')} ${bold(`Port ${port} is already in use`)} ${dim(`(${name})`)}`);
+    console.error(`\n${red('\u2718')} ${bold(`Port ${port} is still in use after cleanup`)} ${dim(`(${name})`)}`);
     console.error(`\n  ${dim('Stop MindOS:')}       mindos stop`);
     console.error(`  ${dim('Find the process:')}  lsof -i :${port}\n`);
     process.exit(1);
   }
+  console.log(`  ${dim('Cleaned up orphaned processes on port')} ${port}`);
 }

package/bin/lib/stop.js

@@ -74,6 +74,13 @@ function killTree(pid) {
  *   read from the current config file.
  */
 export function stopMindos(opts = {}) {
+  // In test environment, skip all real process killing to avoid
+  // destroying dev servers or other unrelated processes.
+  if (process.env.NODE_ENV === 'test') {
+    console.log('(test mode: skipping real process stop)');
+    return;
+  }
+
   // Read ports from config for port-based cleanup
   let webPort = '3456', mcpPort = '8781';
   try {
@@ -110,8 +117,11 @@ export function stopMindos(opts = {}) {
 
   if (!pids.length && portKilled === 0) {
     // Last resort: pattern match (for envs without lsof)
-    try { execSync('pkill -f "next start|next dev" 2>/dev/null || true', { stdio: ['ignore', 'inherit', 'inherit'] }); } catch {}
-    try { execSync('pkill -f "mcp/(src/index|dist/index)" 2>/dev/null || true', { stdio: ['ignore', 'inherit', 'inherit'] }); } catch {}
+    // Skip in test environment to avoid killing unrelated dev servers
+    if (process.env.NODE_ENV !== 'test') {
+      try { execSync('pkill -f "next start|next dev" 2>/dev/null || true', { stdio: ['ignore', 'inherit', 'inherit'] }); } catch {}
+      try { execSync('pkill -f "mcp/(src/index|dist/index)" 2>/dev/null || true', { stdio: ['ignore', 'inherit', 'inherit'] }); } catch {}
+    }
   }
 
   if (!pids.length) console.log(green('\u2714 Done'));