@geminilight/mindos 0.2.1 → 0.4.0

package/app/app/api/init/route.ts

@@ -1,56 +1,22 @@
 import { NextRequest, NextResponse } from 'next/server';
-import fs from 'fs';
-import path from 'path';
 import { getMindRoot } from '@/lib/fs';
-
-function copyRecursive(src: string, dest: string) {
-  const stat = fs.statSync(src);
-  if (stat.isDirectory()) {
-    if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
-    for (const entry of fs.readdirSync(src)) {
-      copyRecursive(path.join(src, entry), path.join(dest, entry));
-    }
-  } else {
-    // Skip if file already exists
-    if (fs.existsSync(dest)) return;
-    // Ensure parent directory exists
-    const dir = path.dirname(dest);
-    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    fs.copyFileSync(src, dest);
-  }
-}
+import { applyTemplate } from '@/lib/template';
 
 export async function POST(req: NextRequest) {
   try {
     const body = await req.json();
     const template = body.template as string;
 
-    if (!['en', 'zh', 'empty'].includes(template)) {
-      return NextResponse.json({ error: 'Invalid template' }, { status: 400 });
-    }
-
-    // Resolve template source directory
-    // templates/ is at the repo root (sibling of app/)
-    const repoRoot = path.resolve(process.cwd(), '..');
-    const templateDir = path.join(repoRoot, 'templates', template);
-
-    if (!fs.existsSync(templateDir)) {
-      return NextResponse.json({ error: `Template "${template}" not found` }, { status: 404 });
-    }
-
     const mindRoot = getMindRoot();
-    if (!fs.existsSync(mindRoot)) {
-      fs.mkdirSync(mindRoot, { recursive: true });
-    }
-
-    copyRecursive(templateDir, mindRoot);
+    applyTemplate(template, mindRoot);
 
     return NextResponse.json({ ok: true, template });
   } catch (e) {
     console.error('[/api/init] Error:', e);
-    return NextResponse.json(
-      { error: e instanceof Error ? e.message : String(e) },
-      { status: 500 },
-    );
+    const msg = e instanceof Error ? e.message : String(e);
+    const status = msg.startsWith('Invalid template') ? 400
+      : msg.includes('not found') ? 404
+      : 500;
+    return NextResponse.json({ error: msg }, { status });
   }
 }

package/app/app/api/mcp/agents/route.ts

@@ -0,0 +1,72 @@
+export const dynamic = 'force-dynamic';
+import { NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+function expandHome(p: string): string {
+  return p.startsWith('~/') ? path.resolve(os.homedir(), p.slice(2)) : p;
+}
+
+interface AgentDef {
+  name: string;
+  project: string | null;
+  global: string;
+  key: string;
+}
+
+const MCP_AGENTS: Record<string, AgentDef> = {
+  'claude-code':    { name: 'Claude Code',    project: '.mcp.json',                       global: '~/.claude.json',    key: 'mcpServers' },
+  'claude-desktop': { name: 'Claude Desktop', project: null,                               global: process.platform === 'darwin' ? '~/Library/Application Support/Claude/claude_desktop_config.json' : '~/.config/Claude/claude_desktop_config.json', key: 'mcpServers' },
+  'cursor':         { name: 'Cursor',          project: '.cursor/mcp.json',                global: '~/.cursor/mcp.json', key: 'mcpServers' },
+  'windsurf':       { name: 'Windsurf',        project: null,                               global: '~/.codeium/windsurf/mcp_config.json', key: 'mcpServers' },
+  'cline':          { name: 'Cline',           project: null,                               global: process.platform === 'darwin' ? '~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json' : '~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json', key: 'mcpServers' },
+  'trae':           { name: 'Trae',            project: '.trae/mcp.json',                  global: '~/.trae/mcp.json', key: 'mcpServers' },
+  'gemini-cli':     { name: 'Gemini CLI',      project: '.gemini/settings.json',           global: '~/.gemini/settings.json', key: 'mcpServers' },
+  'openclaw':       { name: 'OpenClaw',        project: null,                               global: '~/.openclaw/mcp.json', key: 'mcpServers' },
+  'codebuddy':      { name: 'CodeBuddy',       project: null,                               global: '~/.claude-internal/.claude.json', key: 'mcpServers' },
+};
+
+function detectInstalled(agentKey: string): { installed: boolean; scope?: string; transport?: string; configPath?: string } {
+  const agent = MCP_AGENTS[agentKey];
+  if (!agent) return { installed: false };
+
+  // Check global first, then project
+  for (const [scope, cfgPath] of [['global', agent.global], ['project', agent.project]] as const) {
+    if (!cfgPath) continue;
+    const absPath = expandHome(cfgPath);
+    if (!fs.existsSync(absPath)) continue;
+    try {
+      const config = JSON.parse(fs.readFileSync(absPath, 'utf-8'));
+      const servers = config[agent.key];
+      if (servers?.mindos) {
+        const entry = servers.mindos;
+        const transport = entry.type === 'stdio' ? 'stdio' : entry.url ? 'http' : 'unknown';
+        return { installed: true, scope, transport, configPath: cfgPath };
+      }
+    } catch { /* ignore parse errors */ }
+  }
+
+  return { installed: false };
+}
+
+export async function GET() {
+  try {
+    const agents = Object.entries(MCP_AGENTS).map(([key, agent]) => {
+      const status = detectInstalled(key);
+      return {
+        key,
+        name: agent.name,
+        installed: status.installed,
+        scope: status.scope,
+        transport: status.transport,
+        configPath: status.configPath,
+        hasProjectScope: !!agent.project,
+        hasGlobalScope: !!agent.global,
+      };
+    });
+    return NextResponse.json({ agents });
+  } catch (err) {
+    return NextResponse.json({ error: String(err) }, { status: 500 });
+  }
+}

package/app/app/api/mcp/install/route.ts

@@ -0,0 +1,95 @@
+export const dynamic = 'force-dynamic';
+import { NextRequest, NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+function expandHome(p: string): string {
+  return p.startsWith('~/') ? path.resolve(os.homedir(), p.slice(2)) : p;
+}
+
+interface AgentDef {
+  name: string;
+  project: string | null;
+  global: string;
+  key: string;
+}
+
+const MCP_AGENTS: Record<string, AgentDef> = {
+  'claude-code':    { name: 'Claude Code',    project: '.mcp.json',                       global: '~/.claude.json',    key: 'mcpServers' },
+  'claude-desktop': { name: 'Claude Desktop', project: null,                               global: process.platform === 'darwin' ? '~/Library/Application Support/Claude/claude_desktop_config.json' : '~/.config/Claude/claude_desktop_config.json', key: 'mcpServers' },
+  'cursor':         { name: 'Cursor',          project: '.cursor/mcp.json',                global: '~/.cursor/mcp.json', key: 'mcpServers' },
+  'windsurf':       { name: 'Windsurf',        project: null,                               global: '~/.codeium/windsurf/mcp_config.json', key: 'mcpServers' },
+  'cline':          { name: 'Cline',           project: null,                               global: process.platform === 'darwin' ? '~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json' : '~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json', key: 'mcpServers' },
+  'trae':           { name: 'Trae',            project: '.trae/mcp.json',                  global: '~/.trae/mcp.json', key: 'mcpServers' },
+  'gemini-cli':     { name: 'Gemini CLI',      project: '.gemini/settings.json',           global: '~/.gemini/settings.json', key: 'mcpServers' },
+  'openclaw':       { name: 'OpenClaw',        project: null,                               global: '~/.openclaw/mcp.json', key: 'mcpServers' },
+  'codebuddy':      { name: 'CodeBuddy',       project: null,                               global: '~/.claude-internal/.claude.json', key: 'mcpServers' },
+};
+
+interface InstallRequest {
+  agents: Array<{ key: string; scope: 'project' | 'global' }>;
+  transport: 'stdio' | 'http';
+  url?: string;
+  token?: string;
+}
+
+function buildEntry(transport: string, url?: string, token?: string) {
+  if (transport === 'stdio') {
+    return { type: 'stdio', command: 'mindos', args: ['mcp'], env: { MCP_TRANSPORT: 'stdio' } };
+  }
+  const entry: Record<string, unknown> = { url: url || 'http://localhost:8787/mcp' };
+  if (token) entry.headers = { Authorization: `Bearer ${token}` };
+  return entry;
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = (await req.json()) as InstallRequest;
+    const { agents, transport, url, token } = body;
+    const entry = buildEntry(transport, url, token);
+    const results: Array<{ agent: string; status: string; path?: string; message?: string }> = [];
+
+    for (const { key, scope } of agents) {
+      const agent = MCP_AGENTS[key];
+      if (!agent) {
+        results.push({ agent: key, status: 'error', message: `Unknown agent: ${key}` });
+        continue;
+      }
+
+      const isGlobal = scope === 'global';
+      const configPath = isGlobal ? agent.global : agent.project;
+      if (!configPath) {
+        results.push({ agent: key, status: 'error', message: `${agent.name} does not support ${scope} scope` });
+        continue;
+      }
+
+      const absPath = expandHome(configPath);
+
+      try {
+        // Read existing config
+        let config: Record<string, unknown> = {};
+        if (fs.existsSync(absPath)) {
+          config = JSON.parse(fs.readFileSync(absPath, 'utf-8'));
+        }
+
+        // Merge — only touch mcpServers.mindos
+        if (!config[agent.key]) config[agent.key] = {};
+        (config[agent.key] as Record<string, unknown>).mindos = entry;
+
+        // Write
+        const dir = path.dirname(absPath);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(absPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+
+        results.push({ agent: key, status: 'ok', path: configPath });
+      } catch (err) {
+        results.push({ agent: key, status: 'error', message: String(err) });
+      }
+    }
+
+    return NextResponse.json({ results });
+  } catch (err) {
+    return NextResponse.json({ error: String(err) }, { status: 500 });
+  }
+}

package/app/app/api/mcp/status/route.ts

@@ -0,0 +1,47 @@
+export const dynamic = 'force-dynamic';
+import { NextResponse } from 'next/server';
+import { readSettings } from '@/lib/settings';
+
+export async function GET() {
+  try {
+    const settings = readSettings();
+    const port = settings.mcpPort ?? 8787;
+    const endpoint = `http://127.0.0.1:${port}/mcp`;
+    const authConfigured = !!settings.authToken;
+
+    // Check if MCP server is running
+    let running = false;
+    let toolCount = 0;
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 2000);
+      const res = await fetch(endpoint, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} }),
+        signal: controller.signal,
+      });
+      clearTimeout(timeout);
+      if (res.ok) {
+        running = true;
+        try {
+          const data = await res.json();
+          if (data?.result?.tools) toolCount = data.result.tools.length;
+        } catch { /* non-JSON response — still running */ }
+      }
+    } catch {
+      // Connection refused or timeout — not running
+    }
+
+    return NextResponse.json({
+      running,
+      transport: 'http',
+      endpoint,
+      port,
+      toolCount,
+      authConfigured,
+    });
+  } catch (err) {
+    return NextResponse.json({ error: String(err) }, { status: 500 });
+  }
+}

package/app/app/api/settings/route.ts

@@ -112,6 +112,9 @@ export async function POST(req: NextRequest) {
       mindRoot: body.mindRoot ?? current.mindRoot,
       webPassword: resolvedWebPassword,
       authToken: resolvedAuthToken,
+      port: typeof body.port === 'number' ? body.port : current.port,
+      mcpPort: typeof body.mcpPort === 'number' ? body.mcpPort : current.mcpPort,
+      startMode: body.startMode ?? current.startMode,
     };
 
     writeSettings(next);

package/app/app/api/setup/generate-token/route.ts

@@ -0,0 +1,23 @@
+export const dynamic = 'force-dynamic';
+import { NextResponse } from 'next/server';
+import { randomBytes, createHash } from 'crypto';
+
+export async function POST(req: Request) {
+  try {
+    const { seed } = await req.json().catch(() => ({} as { seed?: string }));
+    let raw: string;
+    if (seed && typeof seed === 'string' && seed.trim()) {
+      raw = createHash('sha256').update(seed.trim()).digest('hex').slice(0, 24);
+    } else {
+      raw = randomBytes(12).toString('hex'); // 24 hex chars
+    }
+    // Format as xxxx-xxxx-xxxx-xxxx-xxxx-xxxx
+    const token = raw.match(/.{4}/g)!.join('-');
+    return NextResponse.json({ token });
+  } catch (e) {
+    return NextResponse.json(
+      { error: e instanceof Error ? e.message : String(e) },
+      { status: 500 },
+    );
+  }
+}

package/app/app/api/setup/route.ts

@@ -0,0 +1,81 @@
+export const dynamic = 'force-dynamic';
+import { NextRequest, NextResponse } from 'next/server';
+import fs from 'fs';
+import os from 'os';
+import { readSettings, writeSettings, ServerSettings } from '@/lib/settings';
+import { applyTemplate } from '@/lib/template';
+
+function expandHome(p: string): string {
+  if (p.startsWith('~/')) return p.replace('~', os.homedir());
+  if (p === '~') return os.homedir();
+  return p;
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { mindRoot, template, port, mcpPort, authToken, webPassword, ai } = body;
+
+    // Validate required fields
+    if (!mindRoot || typeof mindRoot !== 'string') {
+      return NextResponse.json({ error: 'mindRoot is required' }, { status: 400 });
+    }
+
+    const resolvedRoot = expandHome(mindRoot.trim());
+
+    // Validate ports
+    const webPort = typeof port === 'number' ? port : 3000;
+    const mcpPortNum = typeof mcpPort === 'number' ? mcpPort : 8787;
+    if (webPort < 1024 || webPort > 65535) {
+      return NextResponse.json({ error: `Invalid web port: ${webPort}` }, { status: 400 });
+    }
+    if (mcpPortNum < 1024 || mcpPortNum > 65535) {
+      return NextResponse.json({ error: `Invalid MCP port: ${mcpPortNum}` }, { status: 400 });
+    }
+
+    // Apply template if mindRoot doesn't exist or is empty
+    const dirExists = fs.existsSync(resolvedRoot);
+    let dirEmpty = true;
+    if (dirExists) {
+      try {
+        const entries = fs.readdirSync(resolvedRoot).filter(e => !e.startsWith('.'));
+        dirEmpty = entries.length === 0;
+      } catch { /* treat as empty */ }
+    }
+
+    if (template && (!dirExists || dirEmpty)) {
+      applyTemplate(template, resolvedRoot);
+    } else if (!dirExists) {
+      fs.mkdirSync(resolvedRoot, { recursive: true });
+    }
+
+    // Read current running port for portChanged detection
+    const current = readSettings();
+    const currentPort = current.port ?? 3000;
+
+    // Build config
+    const config: ServerSettings = {
+      ai: ai ?? current.ai,
+      mindRoot: resolvedRoot,
+      port: webPort,
+      mcpPort: mcpPortNum,
+      authToken: authToken ?? current.authToken,
+      webPassword: webPassword ?? '',
+      startMode: current.startMode,
+      setupPending: false,  // clear the flag
+    };
+
+    writeSettings(config);
+
+    return NextResponse.json({
+      ok: true,
+      portChanged: webPort !== currentPort,
+    });
+  } catch (e) {
+    console.error('[/api/setup] Error:', e);
+    return NextResponse.json(
+      { error: e instanceof Error ? e.message : String(e) },
+      { status: 500 },
+    );
+  }
+}

package/app/app/api/skills/route.ts

@@ -0,0 +1,208 @@
+export const dynamic = 'force-dynamic';
+import { NextRequest, NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { readSettings, writeSettings } from '@/lib/settings';
+
+const PROJECT_ROOT = path.resolve(process.cwd(), '..');
+
+function getMindRoot(): string {
+  const s = readSettings();
+  return s.mindRoot || process.env.MIND_ROOT || path.join(os.homedir(), 'MindOS');
+}
+
+interface SkillInfo {
+  name: string;
+  description: string;
+  path: string;
+  source: 'builtin' | 'user';
+  enabled: boolean;
+  editable: boolean;
+}
+
+function parseSkillMd(content: string): { name: string; description: string } {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return { name: '', description: '' };
+  const yaml = match[1];
+  const nameMatch = yaml.match(/^name:\s*(.+)/m);
+  const descMatch = yaml.match(/^description:\s*>?\s*\n?([\s\S]*?)(?=\n\w|\n---)/m);
+  const name = nameMatch ? nameMatch[1].trim() : '';
+  let description = '';
+  if (descMatch) {
+    description = descMatch[1].trim().split('\n').map(l => l.trim()).join(' ').slice(0, 200);
+  } else {
+    const simpleDesc = yaml.match(/^description:\s*(.+)/m);
+    if (simpleDesc) description = simpleDesc[1].trim().slice(0, 200);
+  }
+  return { name, description };
+}
+
+function scanSkillDirs(disabledSkills: string[]): SkillInfo[] {
+  const skills: SkillInfo[] = [];
+  const seen = new Set<string>();
+
+  // 1. app/data/skills/ — builtin
+  const builtinDir = path.join(PROJECT_ROOT, 'app', 'data', 'skills');
+  if (fs.existsSync(builtinDir)) {
+    for (const entry of fs.readdirSync(builtinDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const skillFile = path.join(builtinDir, entry.name, 'SKILL.md');
+      if (!fs.existsSync(skillFile)) continue;
+      const content = fs.readFileSync(skillFile, 'utf-8');
+      const { name, description } = parseSkillMd(content);
+      const skillName = name || entry.name;
+      seen.add(skillName);
+      skills.push({
+        name: skillName,
+        description,
+        path: `app/data/skills/${entry.name}/SKILL.md`,
+        source: 'builtin',
+        enabled: !disabledSkills.includes(skillName),
+        editable: false,
+      });
+    }
+  }
+
+  // 2. skills/ — project root builtin
+  const skillsDir = path.join(PROJECT_ROOT, 'skills');
+  if (fs.existsSync(skillsDir)) {
+    for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const skillFile = path.join(skillsDir, entry.name, 'SKILL.md');
+      if (!fs.existsSync(skillFile)) continue;
+      const content = fs.readFileSync(skillFile, 'utf-8');
+      const { name, description } = parseSkillMd(content);
+      const skillName = name || entry.name;
+      if (seen.has(skillName)) continue; // already listed from app/data/skills/
+      seen.add(skillName);
+      skills.push({
+        name: skillName,
+        description,
+        path: `skills/${entry.name}/SKILL.md`,
+        source: 'builtin',
+        enabled: !disabledSkills.includes(skillName),
+        editable: false,
+      });
+    }
+  }
+
+  // 3. {mindRoot}/.skills/ — user custom
+  const mindRoot = getMindRoot();
+  const userSkillsDir = path.join(mindRoot, '.skills');
+  if (fs.existsSync(userSkillsDir)) {
+    for (const entry of fs.readdirSync(userSkillsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const skillFile = path.join(userSkillsDir, entry.name, 'SKILL.md');
+      if (!fs.existsSync(skillFile)) continue;
+      const content = fs.readFileSync(skillFile, 'utf-8');
+      const { name, description } = parseSkillMd(content);
+      const skillName = name || entry.name;
+      if (seen.has(skillName)) continue;
+      seen.add(skillName);
+      skills.push({
+        name: skillName,
+        description,
+        path: `{mindRoot}/.skills/${entry.name}/SKILL.md`,
+        source: 'user',
+        enabled: !disabledSkills.includes(skillName),
+        editable: true,
+      });
+    }
+  }
+
+  return skills;
+}
+
+export async function GET() {
+  try {
+    const settings = readSettings();
+    const disabledSkills = settings.disabledSkills ?? [];
+    const skills = scanSkillDirs(disabledSkills);
+    return NextResponse.json({ skills });
+  } catch (err) {
+    return NextResponse.json({ error: String(err) }, { status: 500 });
+  }
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { action, name, description, content, enabled } = body as {
+      action: 'create' | 'update' | 'delete' | 'toggle';
+      name?: string;
+      description?: string;
+      content?: string;
+      enabled?: boolean;
+    };
+
+    const settings = readSettings();
+    const mindRoot = getMindRoot();
+    const userSkillsDir = path.join(mindRoot, '.skills');
+
+    // Validate skill name — prevent path traversal
+    if (name && !/^[a-z0-9][a-z0-9-]*$/.test(name)) {
+      return NextResponse.json({ error: 'Invalid skill name. Use lowercase letters, numbers, and hyphens only.' }, { status: 400 });
+    }
+
+    switch (action) {
+      case 'toggle': {
+        if (!name) return NextResponse.json({ error: 'name required' }, { status: 400 });
+        const disabled = settings.disabledSkills ?? [];
+        if (enabled === false) {
+          if (!disabled.includes(name)) disabled.push(name);
+        } else {
+          const idx = disabled.indexOf(name);
+          if (idx >= 0) disabled.splice(idx, 1);
+        }
+        writeSettings({ ...settings, disabledSkills: disabled });
+        return NextResponse.json({ ok: true });
+      }
+
+      case 'create': {
+        if (!name) return NextResponse.json({ error: 'name required' }, { status: 400 });
+        // Check for conflicts with builtin
+        const builtinDir = path.join(PROJECT_ROOT, 'app', 'data', 'skills', name);
+        const skillsRootDir = path.join(PROJECT_ROOT, 'skills', name);
+        if (fs.existsSync(builtinDir) || fs.existsSync(skillsRootDir)) {
+          return NextResponse.json({ error: 'A built-in skill with this name already exists' }, { status: 409 });
+        }
+        const skillDir = path.join(userSkillsDir, name);
+        if (fs.existsSync(skillDir)) {
+          return NextResponse.json({ error: 'A skill with this name already exists' }, { status: 409 });
+        }
+        fs.mkdirSync(skillDir, { recursive: true });
+        const frontmatter = `---\nname: ${name}\ndescription: ${description || name}\n---\n\n${content || ''}`;
+        fs.writeFileSync(path.join(skillDir, 'SKILL.md'), frontmatter, 'utf-8');
+        return NextResponse.json({ ok: true });
+      }
+
+      case 'update': {
+        if (!name) return NextResponse.json({ error: 'name required' }, { status: 400 });
+        const skillDir = path.join(userSkillsDir, name);
+        if (!fs.existsSync(skillDir)) {
+          return NextResponse.json({ error: 'Skill not found' }, { status: 404 });
+        }
+        if (content !== undefined) {
+          fs.writeFileSync(path.join(skillDir, 'SKILL.md'), content, 'utf-8');
+        }
+        return NextResponse.json({ ok: true });
+      }
+
+      case 'delete': {
+        if (!name) return NextResponse.json({ error: 'name required' }, { status: 400 });
+        const skillDir = path.join(userSkillsDir, name);
+        if (!fs.existsSync(skillDir)) {
+          return NextResponse.json({ error: 'Skill not found' }, { status: 404 });
+        }
+        fs.rmSync(skillDir, { recursive: true, force: true });
+        return NextResponse.json({ ok: true });
+      }
+
+      default:
+        return NextResponse.json({ error: `Unknown action: ${action}` }, { status: 400 });
+    }
+  } catch (err) {
+    return NextResponse.json({ error: String(err) }, { status: 500 });
+  }
+}

package/app/app/api/sync/route.ts

@@ -1,8 +1,8 @@
 export const dynamic = 'force-dynamic';
 import { NextRequest, NextResponse } from 'next/server';
-import { execSync } from 'child_process';
+import { execSync, execFile } from 'child_process';
 import { existsSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { homedir } from 'os';
 
 const MINDOS_DIR = join(homedir(), '.mindos');
@@ -68,7 +68,7 @@ export async function GET() {
 
 export async function POST(req: NextRequest) {
   try {
-    const body = await req.json() as { action: string };
+    const body = await req.json() as { action: string; remote?: string; branch?: string; token?: string };
     const config = loadConfig();
     const mindRoot = config.mindRoot;
 
@@ -77,6 +77,57 @@ export async function POST(req: NextRequest) {
     }
 
     switch (body.action) {
+      case 'init': {
+        const remote = body.remote?.trim();
+        if (!remote) {
+          return NextResponse.json({ error: 'Remote URL is required' }, { status: 400 });
+        }
+
+        // Validate URL format
+        const isHTTPS = remote.startsWith('https://');
+        const isSSH = /^git@[\w.-]+:.+/.test(remote);
+        if (!isHTTPS && !isSSH) {
+          return NextResponse.json({ error: 'Invalid remote URL — must be HTTPS or SSH format' }, { status: 400 });
+        }
+
+        // Check if sync is already configured
+        if (config.sync?.enabled && isGitRepo(mindRoot) && getRemoteUrl(mindRoot)) {
+          return NextResponse.json({ error: 'Sync already configured' }, { status: 400 });
+        }
+
+        // Build the effective remote URL (inject token for HTTPS)
+        let effectiveRemote = remote;
+        if (isHTTPS && body.token) {
+          try {
+            const urlObj = new URL(remote);
+            urlObj.username = 'oauth2';
+            urlObj.password = body.token;
+            effectiveRemote = urlObj.toString();
+          } catch {
+            return NextResponse.json({ error: 'Invalid remote URL' }, { status: 400 });
+          }
+        }
+
+        const branch = body.branch?.trim() || 'main';
+
+        // Call CLI's sync init via execFile (avoids module resolution issues with Turbopack)
+        try {
+          const cliPath = resolve(process.cwd(), '..', 'bin', 'cli.js');
+          const args = ['sync', 'init', '--non-interactive', '--remote', effectiveRemote, '--branch', branch];
+
+          await new Promise<void>((res, rej) => {
+            execFile('node', [cliPath, ...args], { timeout: 30000 }, (err, stdout, stderr) => {
+              if (err) rej(new Error(stderr?.trim() || err.message));
+              else res();
+            });
+          });
+          return NextResponse.json({ success: true, message: 'Sync initialized' });
+        } catch (err: unknown) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          return NextResponse.json({ error: errMsg }, { status: 400 });
+        }
+      }
+
       case 'now': {
         if (!isGitRepo(mindRoot)) {
           return NextResponse.json({ error: 'Not a git repository' }, { status: 400 });