@aion0/forge 0.10.36 → 0.10.38

package/app/api/onboarding/route.ts

@@ -0,0 +1,461 @@
+/**
+ * Onboarding wizard API — first-run setup.
+ *
+ *   GET  → returns current onboarding state + suggested defaults
+ *          (so the UI can pre-populate from existing settings on re-run).
+ *
+ *   POST { action: 'apply', payload } → atomic apply:
+ *     1. identity (settings.displayName / .displayEmail)
+ *     2. API profile (add/upsert apiProfiles[id] + set chatAgent)
+ *     3. connectors (run the template apply path with the user-supplied values)
+ *     4. pipelines (install selected pipelines from workflow marketplace)
+ *     5. projects (settings.projectRoots add unique)
+ *     6. flip settings.onboardingCompleted = true
+ *
+ *   POST { action: 'reset' } → flips onboardingCompleted=false so the
+ *   wizard pops again. Doesn't undo anything else.
+ *
+ * Failure mode: best-effort. Each phase logs+collects its own errors and
+ * keeps going so a missing API profile doesn't prevent connectors from
+ * being configured. The response surfaces a per-phase status array.
+ */
+
+import { NextResponse } from 'next/server';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadSettings, saveSettings } from '@/lib/settings';
+import { getDataDir } from '@/lib/dirs';
+import {
+  getConnector,
+  getInstalledConnector,
+  setConnectorConfig,
+  setConnectorEnabled,
+} from '@/lib/connectors/registry';
+import { installFromMarketplace, listMarketplace } from '@/lib/workflow-marketplace';
+import { installFromRegistry } from '@/lib/connectors/sync';
+import bundledTemplate from '@/templates/connector-config-template.json';
+
+interface OnboardingPayload {
+  identity?: {
+    displayName?: string;
+    displayEmail?: string;
+  };
+  apiProfile?: {
+    id: string;                  // e.g. "deepseek"
+    name?: string;
+    provider: 'anthropic' | 'openai-compatible';
+    model: string;
+    /** Empty/omitted = keep the existing apiKey on the profile if any. */
+    apiKey?: string;
+    baseUrl?: string;
+    /** If true, set as default chat profile. */
+    setAsDefault?: boolean;
+  };
+  cliAgent?: {
+    id: string;                  // e.g. "claude"
+    tool: 'claude' | 'codex' | 'aider' | 'opencode';
+    path?: string;
+    setAsDefault?: boolean;
+  };
+  connectorValues?: Record<string, string>;     // template ${key} → value
+  /** Subset of template connector ids to install. Missing/empty = install
+   *  everything in the template. Unselected ids are skipped entirely —
+   *  no installFromRegistry, no setConnectorConfig. Lets users opt out of
+   *  Jenkins/NAC/FortiNCM etc. on first run. */
+  selectedConnectors?: string[];
+  pipelines?: string[];                          // marketplace names to install
+  projectRoots?: string[];                       // paths to append
+}
+
+// ─── Helpers (mirrors import-config-template/route.ts) ───────
+
+const PLACEHOLDER_RE = /\$\{([a-zA-Z0-9_]+)\}/g;
+function substituteAll(value: unknown, values: Record<string, string>): unknown {
+  if (typeof value === 'string') {
+    return value.replace(PLACEHOLDER_RE, (_, key) => values[key] ?? '');
+  }
+  if (Array.isArray(value)) return value.map((v) => substituteAll(v, values));
+  if (value && typeof value === 'object') {
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value)) out[k] = substituteAll(v, values);
+    return out;
+  }
+  return value;
+}
+
+function isEffectivelyEmpty(v: unknown): boolean {
+  if (v == null) return true;
+  if (typeof v === 'string') return v.trim() === '';
+  if (Array.isArray(v)) return v.length === 0;
+  if (typeof v === 'object') return Object.keys(v as object).length === 0;
+  return false;
+}
+
+function resolveTemplate(): any {
+  const userPath = join(getDataDir(), 'config-template.json');
+  if (existsSync(userPath)) {
+    try { return JSON.parse(readFileSync(userPath, 'utf-8')); }
+    catch { /* fall through */ }
+  }
+  return bundledTemplate;
+}
+
+// ─── Phase appliers ──────────────────────────────────────────
+
+function applyIdentity(identity: OnboardingPayload['identity']): string | null {
+  if (!identity) return null;
+  const settings = loadSettings();
+  if (identity.displayName != null) settings.displayName = identity.displayName;
+  if (identity.displayEmail != null) settings.displayEmail = identity.displayEmail;
+  saveSettings(settings);
+  return null;
+}
+
+function applyApiProfile(p: OnboardingPayload['apiProfile']): string | null {
+  if (!p) return null;
+  if (!p.id) return 'api profile id required';
+  const settings = loadSettings();
+  settings.apiProfiles = settings.apiProfiles || {};
+  const existing = settings.apiProfiles[p.id];
+  // Empty/omitted apiKey → keep the existing one (lets users re-confirm
+  // a profile through the wizard without re-typing the secret).
+  const apiKey = (p.apiKey && p.apiKey.trim()) ? p.apiKey.trim() : (existing?.apiKey || '');
+  if (!apiKey) return `api profile ${p.id}: apiKey required (no existing key to preserve)`;
+  settings.apiProfiles[p.id] = {
+    name: p.name || existing?.name || p.id,
+    enabled: true,
+    provider: p.provider,
+    model: p.model || existing?.model || '',
+    apiKey,
+    ...(p.baseUrl ? { baseUrl: p.baseUrl } : (existing?.baseUrl ? { baseUrl: existing.baseUrl } : {})),
+  };
+  if (p.setAsDefault) settings.chatAgent = p.id;
+  saveSettings(settings);
+  return null;
+}
+
+function applyCliAgent(a: OnboardingPayload['cliAgent']): string | null {
+  if (!a) return null;
+  if (!a.id || !a.tool) return 'cli agent id and tool required';
+  const settings = loadSettings();
+  settings.agents = settings.agents || {};
+  const existing = settings.agents[a.id] || {};
+  settings.agents[a.id] = {
+    ...existing,
+    tool: a.tool,
+    name: existing.name || a.id,
+    enabled: true,
+    ...(a.path ? { path: a.path } : {}),
+  };
+  if (a.setAsDefault) settings.defaultAgent = a.id;
+  // Terminal launch (lib/claude-process.ts) reads settings.claudePath,
+  // NOT agent.path. Set it explicitly when the user picked a claude
+  // tool with an absolute path — otherwise Forge falls back to PATH
+  // lookup and may pick up a different (e.g. conda-base) claude binary.
+  if (a.tool === 'claude' && a.path && a.path.startsWith('/')) {
+    settings.claudePath = a.path;
+  }
+  saveSettings(settings);
+  return null;
+}
+
+async function applyConnectors(
+  values: Record<string, string> | undefined,
+  selectedConnectors: string[] | undefined,
+): Promise<{
+  applied: string[];
+  installed_from_registry: string[];
+  skipped_missing_manifest: string[];
+  skipped_unselected: string[];
+  fields_preserved: Array<{ connector: string; field: string }>;
+}> {
+  const template = resolveTemplate();
+  // Undefined = install everything; explicit [] = install nothing.
+  const selected = selectedConnectors ? new Set(selectedConnectors) : null;
+  // Auto-inject user identity from settings so connectors (e.g. tp.username)
+  // can reference {user_name} / {user_email} without prompting again.
+  // User-supplied values still win over auto-injected ones.
+  const settings = loadSettings();
+  const subst: Record<string, string> = {
+    user_name: settings.displayName || '',
+    user_email: settings.displayEmail || '',
+    ...(values || {}),
+  };
+  const applied: string[] = [];
+  const installedFromRegistry: string[] = [];
+  const missing: string[] = [];
+  const skippedUnselected: string[] = [];
+  const preserved: Array<{ connector: string; field: string }> = [];
+
+  for (const [id, row] of Object.entries(template)) {
+    if (id.startsWith('_')) continue;     // metadata keys
+    if (selected && !selected.has(id)) { skippedUnselected.push(id); continue; }
+    let def = getConnector(id);
+    if (!def) {
+      // Manifest not on disk yet — fetch from forge-connectors registry
+      // and install. installFromRegistry auto-syncs if cache is missing.
+      const r = await installFromRegistry(id);
+      if (r.ok) {
+        installedFromRegistry.push(id);
+        def = getConnector(id);
+      }
+      if (!def) { missing.push(id); continue; }
+    }
+
+    const templateConfig = (row as any)?.config ?? {};
+    const enabledTemplate = (row as any)?.enabled;
+    const existing = getInstalledConnector(id)?.config ?? {};
+    const merged: Record<string, unknown> = { ...existing };
+
+    for (const [field, rawVal] of Object.entries(templateConfig)) {
+      const resolved = substituteAll(rawVal, subst);
+      const existingVal = existing[field];
+      const existingNonEmpty = !isEffectivelyEmpty(existingVal)
+        && !(typeof existingVal === 'string' && existingVal.startsWith('TODO_'));
+      if (existingNonEmpty) {
+        if (JSON.stringify(existingVal) !== JSON.stringify(resolved)) {
+          preserved.push({ connector: id, field });
+        }
+        continue;
+      }
+      merged[field] = resolved;
+    }
+
+    setConnectorConfig(id, merged);
+    applied.push(id);
+    if (typeof enabledTemplate === 'boolean') setConnectorEnabled(id, enabledTemplate);
+  }
+
+  return {
+    applied,
+    installed_from_registry: installedFromRegistry,
+    skipped_missing_manifest: missing,
+    skipped_unselected: skippedUnselected,
+    fields_preserved: preserved,
+  };
+}
+
+async function applyPipelines(names: string[] | undefined): Promise<{
+  installed: string[];
+  errors: Array<{ name: string; error: string }>;
+}> {
+  if (!names || names.length === 0) return { installed: [], errors: [] };
+  const installed: string[] = [];
+  const errors: Array<{ name: string; error: string }> = [];
+  for (const name of names) {
+    try {
+      const r = await installFromMarketplace('pipeline', name, { overwrite: false });
+      if (r.ok) installed.push(name);
+      else errors.push({ name, error: r.error || 'unknown' });
+    } catch (e) {
+      errors.push({ name, error: e instanceof Error ? e.message : String(e) });
+    }
+  }
+  return { installed, errors };
+}
+
+function applyProjectRoots(paths: string[] | undefined): string | null {
+  if (!paths || paths.length === 0) return null;
+  const settings = loadSettings();
+  const existing = new Set(settings.projectRoots || []);
+  for (const p of paths) {
+    const trimmed = p.trim();
+    if (trimmed) existing.add(trimmed);
+  }
+  settings.projectRoots = Array.from(existing);
+  saveSettings(settings);
+  return null;
+}
+
+// ─── Routes ──────────────────────────────────────────────────
+
+export async function GET() {
+  const settings = loadSettings();
+  const template = resolveTemplate();
+
+  // Suggest fortinet-* pipelines from the marketplace as default-selected.
+  let suggested_pipelines: string[] = [];
+  try {
+    const m = listMarketplace();
+    suggested_pipelines = (m.pipelines || [])
+      .filter((e: any) => e.name?.startsWith('fortinet-'))
+      .map((e: any) => e.name);
+  } catch { /* marketplace may be unsynced — ok */ }
+
+  // Surface the current chat API profile for prefill — key never leaves
+  // the server (we just signal whether one is set so the UI can show
+  // 'leave blank to keep current').
+  const profiles = settings.apiProfiles || {};
+  const currentChatId = settings.chatAgent || Object.keys(profiles)[0] || '';
+  const currentChat = profiles[currentChatId];
+  const apiProfileDetail = currentChat ? {
+    id: currentChatId,
+    name: currentChat.name || currentChatId,
+    provider: currentChat.provider,
+    model: currentChat.model || '',
+    baseUrl: currentChat.baseUrl || '',
+    apiKeySet: !!currentChat.apiKey,
+  } : null;
+
+  // Existing CLI agents (settings.agents — CLI subprocess wrappers).
+  const agents = settings.agents || {};
+  const agentList = Object.entries(agents).map(([id, a]) => ({
+    id,
+    name: a.name || id,
+    tool: a.tool || '',
+    path: a.path || '',
+    enabled: a.enabled !== false,
+  }));
+
+  // CLI detection moved to /api/onboarding/detect-cli (async, called by
+  // the wizard when the drawer opens). Doing 3 × execSync('which …')
+  // here was blocking the Node event loop for up to 15s on misses,
+  // which froze Dashboard mount + every other API on the same worker.
+  const detected: Array<{ name: string; path: string; version: string }> = [];
+
+  // Connector list from the template (excluding `_*` metadata keys),
+  // in template order. UI renders this as checkboxes — default all
+  // selected, user can opt out before Apply. `default_enabled` mirrors
+  // the template's `enabled:` (e.g. fortincm is opt-in).
+  const templateConnectors: Array<{
+    id: string;
+    default_enabled: boolean;
+    has_prompts: boolean;
+    already_installed: boolean;
+  }> = [];
+  for (const [connId, row] of Object.entries(template)) {
+    if (connId.startsWith('_')) continue;
+    const cfg = (row as any)?.config ?? {};
+    const hasPrompts = Object.values(cfg).some(
+      v => typeof v === 'string' && /\$\{[a-zA-Z0-9_]+\}/.test(v),
+    );
+    templateConnectors.push({
+      id: connId,
+      default_enabled: (row as any)?.enabled !== false,
+      has_prompts: hasPrompts,
+      already_installed: !!getInstalledConnector(connId),
+    });
+  }
+
+  // Per-prompt "already set" probe — for each ${key} the template uses,
+  // find which connector field references it and check if that field
+  // is already non-empty. Lets the wizard show "•••• (keep existing)"
+  // instead of asking the user to re-type tokens.
+  const promptValuesSet: Record<string, boolean> = {};
+  const promptTargets: Record<string, Array<{ connector: string; field: string }>> = {};
+  const placeholderRe = /\$\{([a-zA-Z0-9_]+)\}/g;
+  for (const [connId, row] of Object.entries(template)) {
+    if (connId.startsWith('_')) continue;
+    const cfg = (row as any)?.config ?? {};
+    const inst = getInstalledConnector(connId);
+    const existingCfg = inst?.config || {};
+    for (const [field, rawVal] of Object.entries(cfg)) {
+      if (typeof rawVal !== 'string') continue;
+      const matches = [...rawVal.matchAll(placeholderRe)];
+      for (const m of matches) {
+        const key = m[1];
+        if (!promptTargets[key]) promptTargets[key] = [];
+        promptTargets[key].push({ connector: connId, field });
+        // "set" = the target field already has a real (non-empty, non-TODO_) value.
+        const existing = existingCfg[field];
+        const isSet = typeof existing === 'string'
+          ? (existing.trim() !== '' && !existing.startsWith('TODO_') && !existing.includes('${'))
+          : (existing != null && !isEffectivelyEmpty(existing));
+        if (isSet) promptValuesSet[key] = true;
+      }
+    }
+  }
+
+  return NextResponse.json({
+    ok: true,
+    onboardingCompleted: !!settings.onboardingCompleted,
+    current: {
+      displayName: settings.displayName || '',
+      displayEmail: settings.displayEmail || '',
+      apiProfileIds: Object.keys(profiles),
+      apiProfile: apiProfileDetail,
+      chatAgent: settings.chatAgent || '',
+      defaultAgent: settings.defaultAgent || '',
+      agents: agentList,
+      projectRoots: settings.projectRoots || [],
+    },
+    detected_cli: detected,
+    template_connectors: templateConnectors,
+    template_prompts: template._prompts || {},
+    prompt_values_set: promptValuesSet,
+    prompt_targets: promptTargets,
+    suggested_pipelines,
+  });
+}
+
+export async function POST(req: Request) {
+  let body: any;
+  try { body = await req.json(); }
+  catch { return NextResponse.json({ ok: false, error: 'invalid JSON' }, { status: 400 }); }
+
+  const action = body?.action;
+
+  if (action === 'reset') {
+    const settings = loadSettings();
+    settings.onboardingCompleted = false;
+    saveSettings(settings);
+    return NextResponse.json({ ok: true });
+  }
+
+  if (action !== 'apply') {
+    return NextResponse.json({ ok: false, error: 'unknown action' }, { status: 400 });
+  }
+
+  const payload = (body?.payload || {}) as OnboardingPayload;
+  const phases: Array<{ phase: string; ok: boolean; error?: string; detail?: any }> = [];
+
+  try {
+    const e1 = applyIdentity(payload.identity);
+    phases.push({ phase: 'identity', ok: !e1, ...(e1 ? { error: e1 } : {}) });
+  } catch (e) {
+    phases.push({ phase: 'identity', ok: false, error: e instanceof Error ? e.message : String(e) });
+  }
+
+  try {
+    const e2 = applyApiProfile(payload.apiProfile);
+    phases.push({ phase: 'apiProfile', ok: !e2, ...(e2 ? { error: e2 } : {}) });
+  } catch (e) {
+    phases.push({ phase: 'apiProfile', ok: false, error: e instanceof Error ? e.message : String(e) });
+  }
+
+  try {
+    const e2b = applyCliAgent(payload.cliAgent);
+    phases.push({ phase: 'cliAgent', ok: !e2b, ...(e2b ? { error: e2b } : {}) });
+  } catch (e) {
+    phases.push({ phase: 'cliAgent', ok: false, error: e instanceof Error ? e.message : String(e) });
+  }
+
+  try {
+    const r = await applyConnectors(payload.connectorValues, payload.selectedConnectors);
+    phases.push({ phase: 'connectors', ok: true, detail: r });
+  } catch (e) {
+    phases.push({ phase: 'connectors', ok: false, error: e instanceof Error ? e.message : String(e) });
+  }
+
+  try {
+    const r = await applyPipelines(payload.pipelines);
+    phases.push({ phase: 'pipelines', ok: r.errors.length === 0, detail: r });
+  } catch (e) {
+    phases.push({ phase: 'pipelines', ok: false, error: e instanceof Error ? e.message : String(e) });
+  }
+
+  try {
+    const e5 = applyProjectRoots(payload.projectRoots);
+    phases.push({ phase: 'projects', ok: !e5, ...(e5 ? { error: e5 } : {}) });
+  } catch (e) {
+    phases.push({ phase: 'projects', ok: false, error: e instanceof Error ? e.message : String(e) });
+  }
+
+  // Flip the gate regardless — partial setups still count as "user has
+  // seen and acted on the wizard". They can re-run from Settings to fix.
+  const settings = loadSettings();
+  settings.onboardingCompleted = true;
+  saveSettings(settings);
+
+  return NextResponse.json({ ok: true, phases });
+}