@geminilight/mindos 0.3.0 → 0.4.0

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.4.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(', ')}`);

package/scripts/setup.js

@@ -114,6 +114,8 @@ const T = {
   cfgKept:        { en: '✔ Keeping existing config', zh: '✔ 保留现有配置' },
   cfgKeptNote:    { en: '  Settings from this session were not saved', zh: '  本次填写的设置未保存' },
   cfgSaved:       { en: '✔ Config saved', zh: '✔ 配置已保存' },
+  cfgConfirm:     { en: 'Save this configuration?', zh: '保存此配置？' },
+  cfgAborted:     { en: '✘ Setup cancelled. Run `mindos onboard` to try again.', zh: '✘ 设置已取消。运行 `mindos onboard` 重新开始。' },
   yesNo:          { en: '[y/N]', zh: '[y/N]' },
   yesNoDefault:   { en: '[Y/n]', zh: '[Y/n]' },
   startNow:       { en: 'Start MindOS now?', zh: '现在启动 MindOS？' },
@@ -764,6 +766,28 @@ async function main() {
     },
   };
 
+  // ── Configuration Summary & Confirmation ──────────────────────────────────
+  const maskPw = (s) => s ? '•'.repeat(Math.min(s.length, 8)) : '';
+  const maskTk = (s) => s && s.length > 8 ? s.slice(0, 8) + '····' : (s ? s.slice(0, 4) + '····' : '');
+  const sep = '━'.repeat(40);
+  write(`\n${sep}\n`);
+  write(`${c.bold(uiLang === 'zh' ? '配置摘要' : 'Configuration Summary')}\n`);
+  write(`${sep}\n`);
+  write(`  ${c.dim('Knowledge base:')}  ${mindDir}\n`);
+  write(`  ${c.dim('Web port:')}        ${webPort}\n`);
+  write(`  ${c.dim('MCP port:')}        ${mcpPort}\n`);
+  write(`  ${c.dim('Auth token:')}      ${maskTk(authToken)}\n`);
+  if (webPassword) write(`  ${c.dim('Web password:')}    ${maskPw(webPassword)}\n`);
+  write(`  ${c.dim('AI provider:')}     ${config.ai.provider}\n`);
+  write(`  ${c.dim('Start mode:')}      ${startMode}\n`);
+  write(`${sep}\n`);
+
+  const confirmSave = await askYesNoDefault('cfgConfirm');
+  if (!confirmSave) {
+    console.log(c.red(t('cfgAborted')));
+    process.exit(0);
+  }
+
   mkdirSync(MINDOS_DIR, { recursive: true });
   writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
   console.log(`\n${c.green(t('cfgSaved'))}: ${c.dim(CONFIG_PATH)}`);