@geminilight/mindos 0.3.0 → 0.5.0

package/bin/lib/port.js

@@ -4,8 +4,14 @@ import { bold, dim, red } from './colors.js';
 export function isPortInUse(port) {
   return new Promise((resolve) => {
     const sock = createConnection({ port, host: '127.0.0.1' });
-    sock.once('connect', () => { sock.destroy(); resolve(true); });
-    sock.once('error',   () => { sock.destroy(); resolve(false); });
+    const cleanup = (result) => { sock.destroy(); resolve(result); };
+    sock.setTimeout(500, () => cleanup(false));
+    sock.once('connect', () => cleanup(true));
+    sock.once('error', (err) => {
+      // ECONNREFUSED = nothing listening → port is free
+      // EACCES / ENETUNREACH / etc. = treat as unavailable (can't bind either)
+      cleanup(err.code !== 'ECONNREFUSED');
+    });
   });
 }
 

package/bin/lib/startup.js

@@ -3,6 +3,7 @@ import { networkInterfaces } from 'node:os';
 import { CONFIG_PATH } from './constants.js';
 import { bold, dim, cyan, green, yellow } from './colors.js';
 import { getSyncStatus } from './sync.js';
+import { checkForUpdate, printUpdateHint } from './update-check.js';
 
 export function getLocalIP() {
   try {
@@ -15,39 +16,32 @@ export function getLocalIP() {
   return null;
 }
 
-export function printStartupInfo(webPort, mcpPort) {
+export async function printStartupInfo(webPort, mcpPort) {
+  // Fire update check immediately (non-blocking)
+  const updatePromise = checkForUpdate().catch(() => null);
+
   let config = {};
   try { config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')); } catch { /* ignore */ }
   const authToken = config.authToken || '';
   const localIP   = getLocalIP();
 
-  const auth = authToken
-    ? `,\n        "headers": { "Authorization": "Bearer ${authToken}" }`
-    : '';
-  const block = (host) =>
-    `  {\n    "mcpServers": {\n      "mindos": {\n        "url": "http://${host}:${mcpPort}/mcp"${auth}\n      }\n    }\n  }`;
-
   console.log(`\n${'─'.repeat(53)}`);
   console.log(`${bold('🧠 MindOS is starting')}\n`);
   console.log(`  ${green('●')} Web UI   ${cyan(`http://localhost:${webPort}`)}`);
   if (localIP) console.log(`             ${cyan(`http://${localIP}:${webPort}`)}`);
   console.log(`  ${green('●')} MCP      ${cyan(`http://localhost:${mcpPort}/mcp`)}`);
   if (localIP) console.log(`             ${cyan(`http://${localIP}:${mcpPort}/mcp`)}`);
-  if (localIP) console.log(dim(`\n  💡 Running on a remote server? Open the Network URL (${localIP}) in your browser,\n     or use SSH port forwarding: ssh -L ${webPort}:localhost:${webPort} user@${localIP}`));
-  console.log();
-  console.log(bold('Configure MCP in your Agent:'));
-  console.log(dim('  Local (same machine):'));
-  console.log(block('localhost'));
-  if (localIP) {
-    console.log(dim('\n  Remote (other device):'));
-    console.log(block(localIP));
-  }
+
   if (authToken) {
-    console.log(`\n  🔑 ${bold('Auth token:')} ${cyan(authToken)}`);
-    console.log(dim('  Run `mindos token` anytime to view it again'));
+    const maskedToken = authToken.length > 8 ? authToken.slice(0, 8) + '····' : (authToken.length > 4 ? authToken.slice(0, 4) + '····' : '····');
+    console.log(`  ${green('●')} Auth     ${cyan(maskedToken)}  ${dim('(run `mindos token` for full config)')}`);
   }
-  console.log(dim('\n  Install Skills (optional):'));
-  console.log(dim('  npx skills add https://github.com/GeminiLight/MindOS --skill mindos -g -y'));
+
+  // MCP quick-connect hint
+  console.log(`\n  ${dim('Quick connect:')}  ${cyan('mindos mcp install claude-code -g -y')}`);
+  console.log(`  ${dim('Full config:')}    ${cyan('mindos token')}`);
+
+  if (localIP) console.log(dim(`\n  💡 Remote? SSH port forwarding: ssh -L ${webPort}:localhost:${webPort} -L ${mcpPort}:localhost:${mcpPort} user@${localIP}`));
 
   // Sync status
   const mindRoot = config.mindRoot;
@@ -70,5 +64,12 @@ export function printStartupInfo(webPort, mcpPort) {
     } catch { /* sync check is best-effort */ }
   }
 
+  // Wait for update check result (max 4s, then give up)
+  const latestVersion = await Promise.race([
+    updatePromise,
+    new Promise(r => setTimeout(() => r(null), 4000)),
+  ]);
+  if (latestVersion) printUpdateHint(latestVersion);
+
   console.log(`${'─'.repeat(53)}\n`);
 }

package/bin/lib/stop.js

@@ -1,13 +1,51 @@
 import { execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
 import { green, yellow, dim } from './colors.js';
 import { loadPids, clearPids } from './pid.js';
+import { CONFIG_PATH } from './constants.js';
+
+/**
+ * Kill processes listening on the given port.
+ * Returns number of processes killed.
+ */
+function killByPort(port) {
+  let killed = 0;
+  try {
+    const output = execSync(`lsof -ti :${port} 2>/dev/null`, { encoding: 'utf-8' }).trim();
+    if (output) {
+      for (const p of output.split('\n')) {
+        const pid = Number(p);
+        if (pid > 0) {
+          try { process.kill(pid, 'SIGTERM'); killed++; } catch {}
+        }
+      }
+    }
+  } catch {
+    // lsof not available or no processes found
+  }
+  return killed;
+}
 
 export function stopMindos() {
   const pids = loadPids();
   if (!pids.length) {
-    console.log(yellow('No PID file found, trying pattern-based stop...'));
-    try { execSync('pkill -f "next start|next dev" 2>/dev/null || true', { stdio: 'inherit' }); } catch {}
-    try { execSync('pkill -f "mcp/src/index"       2>/dev/null || true', { stdio: 'inherit' }); } catch {}
+    console.log(yellow('No PID file found, trying port-based stop...'));
+    // Read ports from config
+    let webPort = '3000', mcpPort = '8787';
+    try {
+      const config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+      if (config.port) webPort = String(config.port);
+      if (config.mcpPort) mcpPort = String(config.mcpPort);
+    } catch {}
+    let stopped = 0;
+    for (const port of [webPort, mcpPort]) {
+      stopped += killByPort(port);
+    }
+    if (stopped === 0) {
+      // Fallback: pkill pattern match (for envs without lsof)
+      try { execSync('pkill -f "next start|next dev" 2>/dev/null || true', { stdio: 'inherit' }); } catch {}
+      try { execSync('pkill -f "mcp/src/index"       2>/dev/null || true', { stdio: 'inherit' }); } catch {}
+    }
     console.log(green('\u2714 Done'));
     return;
   }

package/bin/lib/sync.js

@@ -139,52 +139,66 @@ let activePullInterval = null;
 /**
  * Interactive sync init — configure remote git repo
  */
-export async function initSync(mindRoot) {
+export async function initSync(mindRoot, opts = {}) {
   if (!mindRoot) { console.error(red('No mindRoot configured.')); process.exit(1); }
 
-  const readline = await import('node:readline');
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const ask = (q) => new Promise(r => rl.question(q, r));
+  const nonInteractive = opts.nonInteractive || false;
+  let remoteUrl = opts.remote || '';
+  let token = opts.token || '';
+  let branch = opts.branch || 'main';
 
-  // 1. Ensure git repo
-  if (!isGitRepo(mindRoot)) {
-    console.log(dim('Initializing git repository...'));
-    execSync('git init', { cwd: mindRoot, stdio: 'inherit' });
-    execSync('git checkout -b main', { cwd: mindRoot, stdio: 'pipe' }).toString();
-  }
+  if (nonInteractive) {
+    // Non-interactive mode: all params from opts
+    if (!remoteUrl) {
+      throw new Error('Remote URL is required in non-interactive mode');
+    }
+  } else {
+    // Interactive mode: prompt user
+    const readline = await import('node:readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(r => rl.question(q, r));
+
+    // 2. Remote URL
+    const currentRemote = getRemoteUrl(mindRoot);
+    const defaultUrl = currentRemote || '';
+    const urlPrompt = currentRemote
+      ? `${bold('Remote URL')} ${dim(`[${currentRemote}]`)}: `
+      : `${bold('Remote URL')} ${dim('(HTTPS or SSH)')}: `;
+    remoteUrl = (await ask(urlPrompt)).trim() || defaultUrl;
+
+    if (!remoteUrl) {
+      console.error(red('Remote URL is required.'));
+      rl.close();
+      process.exit(1);
+    }
 
-  // 2. Remote URL
-  const currentRemote = getRemoteUrl(mindRoot);
-  const defaultUrl = currentRemote || '';
-  const urlPrompt = currentRemote
-    ? `${bold('Remote URL')} ${dim(`[${currentRemote}]`)}: `
-    : `${bold('Remote URL')} ${dim('(HTTPS or SSH)')}: `;
-  let remoteUrl = (await ask(urlPrompt)).trim() || defaultUrl;
+    // 3. Token for HTTPS
+    if (remoteUrl.startsWith('https://')) {
+      token = (await ask(`${bold('Access Token')} ${dim('(GitHub PAT / GitLab PAT, leave empty if SSH)')}: `)).trim();
+    }
 
-  if (!remoteUrl) {
-    console.error(red('Remote URL is required.'));
     rl.close();
-    process.exit(1);
   }
 
-  // 3. Token for HTTPS
-  let token = '';
-  if (remoteUrl.startsWith('https://')) {
-    token = (await ask(`${bold('Access Token')} ${dim('(GitHub PAT / GitLab PAT, leave empty if SSH)')}: `)).trim();
-    if (token) {
-      // Inject token into URL for credential storage
-      const urlObj = new URL(remoteUrl);
-      urlObj.username = 'oauth2';
-      urlObj.password = token;
-      const authUrl = urlObj.toString();
-      // Configure credential helper
-      try { execSync(`git config credential.helper store`, { cwd: mindRoot, stdio: 'pipe' }); } catch {}
-      // Store the credential
-      try {
-        const credInput = `protocol=${urlObj.protocol.replace(':', '')}\nhost=${urlObj.host}\nusername=oauth2\npassword=${token}\n\n`;
-        execSync('git credential approve', { cwd: mindRoot, input: credInput, stdio: 'pipe' });
-      } catch {}
-    }
+  // 1. Ensure git repo
+  if (!isGitRepo(mindRoot)) {
+    if (!nonInteractive) console.log(dim('Initializing git repository...'));
+    execSync('git init', { cwd: mindRoot, stdio: 'pipe' });
+    try { execSync('git checkout -b main', { cwd: mindRoot, stdio: 'pipe' }); } catch {}
+  }
+
+  // Handle token for HTTPS
+  if (token && remoteUrl.startsWith('https://')) {
+    const urlObj = new URL(remoteUrl);
+    urlObj.username = 'oauth2';
+    urlObj.password = token;
+    // Configure credential helper
+    try { execSync(`git config credential.helper store`, { cwd: mindRoot, stdio: 'pipe' }); } catch {}
+    // Store the credential
+    try {
+      const credInput = `protocol=${urlObj.protocol.replace(':', '')}\nhost=${urlObj.host}\nusername=oauth2\npassword=${token}\n\n`;
+      execSync('git credential approve', { cwd: mindRoot, input: credInput, stdio: 'pipe' });
+    } catch {}
   }
 
   // 4. Set remote
@@ -195,50 +209,48 @@ export async function initSync(mindRoot) {
   }
 
   // 5. Test connection
-  console.log(dim('Testing connection...'));
+  if (!nonInteractive) console.log(dim('Testing connection...'));
   try {
-    execSync('git ls-remote --exit-code origin', { cwd: mindRoot, stdio: 'pipe' });
-    console.log(green('✔ Connection successful'));
+    execSync('git ls-remote --exit-code origin', { cwd: mindRoot, stdio: 'pipe', timeout: 15000 });
+    if (!nonInteractive) console.log(green('✔ Connection successful'));
   } catch {
+    const errMsg = 'Remote not reachable — check URL and credentials';
+    if (nonInteractive) throw new Error(errMsg);
     console.error(red('✘ Could not connect to remote. Check your URL and credentials.'));
-    rl.close();
     process.exit(1);
   }
 
-  rl.close();
-
   // 6. Save sync config
   const syncConfig = {
     enabled: true,
     provider: 'git',
     remote: 'origin',
-    branch: getBranch(mindRoot),
+    branch: branch || getBranch(mindRoot),
     autoCommitInterval: 30,
     autoPullInterval: 300,
   };
   saveSyncConfig(syncConfig);
-  console.log(green('✔ Sync configured'));
+  if (!nonInteractive) console.log(green('✔ Sync configured'));
 
   // 7. First sync: pull if remote has content, push otherwise
   try {
     const refs = gitExec('git ls-remote --heads origin', mindRoot);
     if (refs) {
-      console.log(dim('Pulling from remote...'));
+      if (!nonInteractive) console.log(dim('Pulling from remote...'));
       try {
-        execSync(`git pull origin ${syncConfig.branch} --allow-unrelated-histories`, { cwd: mindRoot, stdio: 'inherit' });
+        execSync(`git pull origin ${syncConfig.branch} --allow-unrelated-histories`, { cwd: mindRoot, stdio: nonInteractive ? 'pipe' : 'inherit' });
       } catch {
-        // Might fail if empty or conflicts — that's fine for initial setup
-        console.log(yellow('Pull completed with warnings. Check for conflicts.'));
+        if (!nonInteractive) console.log(yellow('Pull completed with warnings. Check for conflicts.'));
       }
     } else {
-      console.log(dim('Pushing to remote...'));
+      if (!nonInteractive) console.log(dim('Pushing to remote...'));
       autoCommitAndPush(mindRoot);
     }
   } catch {
-    console.log(dim('Performing initial push...'));
+    if (!nonInteractive) console.log(dim('Performing initial push...'));
     autoCommitAndPush(mindRoot);
   }
-  console.log(green('✔ Initial sync complete\n'));
+  if (!nonInteractive) console.log(green('✔ Initial sync complete\n'));
 }
 
 /**

package/bin/lib/update-check.js

@@ -0,0 +1,94 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { ROOT, UPDATE_CHECK_PATH } from './constants.js';
+import { bold, dim, cyan, yellow } from './colors.js';
+
+const TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+const REGISTRIES = [
+  'https://registry.npmmirror.com/@geminilight/mindos/latest',
+  'https://registry.npmjs.org/@geminilight/mindos/latest',
+];
+
+/** Simple semver "a > b" comparison (major.minor.patch only). */
+function semverGt(a, b) {
+  const pa = a.split('.').map(Number);
+  const pb = b.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return true;
+    if ((pa[i] || 0) < (pb[i] || 0)) return false;
+  }
+  return false;
+}
+
+function getCurrentVersion() {
+  try {
+    return JSON.parse(readFileSync(resolve(ROOT, 'package.json'), 'utf-8')).version;
+  } catch {
+    return '0.0.0';
+  }
+}
+
+function readCache() {
+  try {
+    return JSON.parse(readFileSync(UPDATE_CHECK_PATH, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(latestVersion) {
+  try {
+    writeFileSync(UPDATE_CHECK_PATH, JSON.stringify({
+      lastCheck: new Date().toISOString(),
+      latestVersion,
+    }), 'utf-8');
+  } catch { /* best-effort */ }
+}
+
+async function fetchLatest() {
+  for (const url of REGISTRIES) {
+    try {
+      const res = await fetch(url, { signal: AbortSignal.timeout(3000) });
+      if (res.ok) {
+        const data = await res.json();
+        return data.version;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+/**
+ * Check for updates. Returns the latest version string if an update is
+ * available, or null if up-to-date / check fails.
+ */
+export async function checkForUpdate() {
+  if (process.env.MINDOS_NO_UPDATE_CHECK === '1') return null;
+
+  const current = getCurrentVersion();
+  const cache = readCache();
+
+  // Cache hit — still fresh
+  if (cache?.lastCheck) {
+    const age = Date.now() - new Date(cache.lastCheck).getTime();
+    if (age < TTL_MS) {
+      return (cache.latestVersion && semverGt(cache.latestVersion, current))
+        ? cache.latestVersion
+        : null;
+    }
+  }
+
+  // Cache miss or expired — fetch
+  const latest = await fetchLatest();
+  if (latest) writeCache(latest);
+  return (latest && semverGt(latest, current)) ? latest : null;
+}
+
+/** Print update hint line if an update is available. */
+export function printUpdateHint(latestVersion) {
+  const current = getCurrentVersion();
+  console.log(`\n  ${yellow('⬆')}  ${bold(`MindOS v${latestVersion}`)} available ${dim(`(current: v${current})`)}.  Run ${cyan('mindos update')} to upgrade.`);
+}

package/bin/lib/utils.js

@@ -6,8 +6,8 @@ import { ROOT } from './constants.js';
 export function run(command, cwd = ROOT) {
   try {
     execSync(command, { cwd, stdio: 'inherit', env: process.env });
-  } catch {
-    process.exit(1);
+  } catch (err) {
+    process.exit(err.status || 1);
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "MindOS — Human-Agent Collaborative Mind System. Local-first knowledge base that syncs your mind to all AI Agents via MCP.",
   "keywords": [
     "mindos",

package/scripts/gen-renderer-index.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+// Scans app/components/renderers/*/manifest.ts and generates
+// app/lib/renderers/index.ts with auto-discovered imports.
+//
+// Run: node scripts/gen-renderer-index.js
+// Hooked into: npm run build (via prebuild)
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const renderersDir = path.resolve(__dirname, '../app/components/renderers');
+const outputFile = path.resolve(__dirname, '../app/lib/renderers/index.ts');
+
+// Scan for manifest.ts in immediate subdirectories
+const dirs = fs.readdirSync(renderersDir, { withFileTypes: true })
+  .filter(d => d.isDirectory())
+  .filter(d => fs.existsSync(path.join(renderersDir, d.name, 'manifest.ts')))
+  .map(d => d.name)
+  .sort();
+
+if (dirs.length === 0) {
+  console.error('No manifest.ts files found in', renderersDir);
+  process.exit(1);
+}
+
+// kebab-case → camelCase
+function toCamel(s) {
+  return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+const imports = dirs.map(dir => {
+  const varName = toCamel(dir);
+  return `import { manifest as ${varName} } from '@/components/renderers/${dir}/manifest';`;
+}).join('\n');
+
+const varNames = dirs.map(toCamel);
+
+const code = `/**
+ * AUTO-GENERATED by scripts/gen-renderer-index.js — do not edit manually.
+ * To regenerate: node scripts/gen-renderer-index.js
+ */
+import { registerRenderer } from './registry';
+${imports}
+
+const manifests = [
+  ${varNames.join(', ')},
+];
+
+for (const m of manifests) {
+  registerRenderer(m);
+}
+`;
+
+fs.writeFileSync(outputFile, code, 'utf-8');
+console.log(`Generated ${path.relative(process.cwd(), outputFile)} with ${dirs.length} renderers: ${dirs.join(', ')}`);