@aion0/forge 0.10.36 → 0.10.37

package/RELEASE_NOTES.md

@@ -1,16 +1,8 @@
-# Forge v0.10.36
+# Forge v0.10.37
 
 Released: 2026-06-04
 
-## Changes since v0.10.35
+## Changes since v0.10.36
 
-### Documentation
-- docs: README install section gets one-liner + optional deps line
 
-### Other
-- scripts: add install-deps.sh cross-platform installer
-- feat(chat): add 5 schedule builtin tools (create/list/delete/run/update)
-- feat(vscode-ext): add Chat + Schedules views + session switcher
-
-
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.35...v0.10.36
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.36...v0.10.37

package/app/api/connectors/import-config-template/route.ts

@@ -0,0 +1,358 @@
+/**
+ * POST /api/connectors/import-config-template
+ *
+ * Two phases driven by the request body:
+ *
+ *   multipart/form-data with `file` (JSON) → analyze:
+ *     Parse template, scan for ${key} placeholders, return a deduplicated
+ *     list of prompts the user still needs to answer. Same key referenced
+ *     by multiple connectors (e.g. gitlab_pat in both gitlab.token and
+ *     jenkins.instances[0].gitlab_pat) is asked once.
+ *
+ *   application/json `{ template, values }` → apply:
+ *     Substitute ${key} with the user-supplied values, then merge each
+ *     connector row into connector-configs.json. Existing non-empty
+ *     fields are preserved — the template never overwrites a real token.
+ *
+ * Template shape (see ~/MyDocuments/obsidian-project/30-Resources/forge/
+ * connector-configs.template.json):
+ *   {
+ *     "_README": "...",
+ *     "_prompts": { "gitlab_pat": {label, hint, secret, required}, ... },
+ *     "<connector_id>": { "config": {...}, "enabled": bool },
+ *     ...
+ *   }
+ * Keys starting with "_" are metadata, not connectors.
+ */
+
+import { NextResponse } from 'next/server';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getDataDir } from '@/lib/dirs';
+import { loadSettings } from '@/lib/settings';
+import {
+  getConnector,
+  getInstalledConnector,
+  setConnectorConfig,
+  setConnectorEnabled,
+} from '@/lib/connectors/registry';
+import { installFromRegistry } from '@/lib/connectors/sync';
+// Bundled fallback — shipped with Forge so the "Import Template" button
+// works out of the box without any extra setup. Users can override by
+// dropping their own at <dataDir>/config-template.json.
+import bundledTemplate from '@/templates/connector-config-template.json';
+
+const LOCAL_TEMPLATE_FILE = 'config-template.json';
+
+/** Resolve template source: user override in dataDir wins, else bundled. */
+function resolveTemplate(): { source: 'local' | 'bundled'; template: any; path: string | null } {
+  const userPath = join(getDataDir(), LOCAL_TEMPLATE_FILE);
+  if (existsSync(userPath)) {
+    try {
+      return { source: 'local', template: JSON.parse(readFileSync(userPath, 'utf-8')), path: userPath };
+    } catch {
+      // Fall through to bundled if user file is malformed.
+    }
+  }
+  return { source: 'bundled', template: bundledTemplate, path: null };
+}
+
+interface PromptDef {
+  label: string;
+  hint?: string;
+  /** Optional link to the page where the user creates/finds this value. */
+  url?: string;
+  /** Display label for the link; defaults to "Open token page" in the UI. */
+  url_label?: string;
+  secret?: boolean;
+  required?: boolean;
+  /** UI grouping override. Defaults to the first-target connector id when
+   *  unset. Use this when a prompt is semantically tied to connector A
+   *  (e.g. gitlab token-name) but only USED inside connector B's config
+   *  (e.g. jenkins.instances[0].username) — wizard groups it under A. */
+  group?: string;
+  /** Pre-filled value the wizard shows in the input by default. User can
+   *  still edit. Useful for "instance name = default-jenkins" type fields. */
+  default?: string;
+}
+
+interface PendingPrompt extends PromptDef {
+  key: string;
+  targets: Array<{ connector: string; field_path: string }>;
+}
+
+const PLACEHOLDER_RE = /\$\{([a-zA-Z0-9_]+)\}/g;
+
+// ─── Helpers ──────────────────────────────────────────────
+
+function isMetaKey(k: string): boolean {
+  return k.startsWith('_');
+}
+
+/** Walk a value, collect every ${key} usage with its source path. */
+function scanPlaceholders(
+  value: unknown,
+  path: string,
+  out: Map<string, Set<string>>,
+): void {
+  if (typeof value === 'string') {
+    const matches = value.matchAll(PLACEHOLDER_RE);
+    for (const m of matches) {
+      const key = m[1];
+      if (!out.has(key)) out.set(key, new Set());
+      out.get(key)!.add(path);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((v, i) => scanPlaceholders(v, `${path}[${i}]`, out));
+    return;
+  }
+  if (value && typeof value === 'object') {
+    for (const [k, v] of Object.entries(value)) {
+      scanPlaceholders(v, path ? `${path}.${k}` : k, out);
+    }
+  }
+}
+
+/** Replace every ${key} in a string with values[key]. Unmapped keys → empty string. */
+function substituteString(s: string, values: Record<string, string>): string {
+  return s.replace(PLACEHOLDER_RE, (_, key) => values[key] ?? '');
+}
+
+function substituteAll(value: unknown, values: Record<string, string>): unknown {
+  if (typeof value === 'string') return substituteString(value, values);
+  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;
+}
+
+// ─── Analyze ──────────────────────────────────────────────
+
+function analyze(template: any): {
+  pending: PendingPrompt[];
+  static_apply_targets: string[];
+  missing_manifests: string[];
+} {
+  const promptsDict: Record<string, PromptDef> = template._prompts || {};
+
+  // Map: placeholder_key → Set of "connector.field_path"
+  const usage = new Map<string, Set<string>>();
+  const staticTargets: string[] = [];
+  const missing: string[] = [];
+
+  for (const [id, row] of Object.entries(template)) {
+    if (isMetaKey(id)) continue;
+    if (!getConnector(id)) { missing.push(id); continue; }
+    staticTargets.push(id);
+    scanPlaceholders((row as any).config, id, usage);
+  }
+
+  const pending: PendingPrompt[] = [];
+  for (const [key, paths] of usage.entries()) {
+    const def = promptsDict[key] || { label: key };
+    pending.push({
+      key,
+      label: def.label || key,
+      hint: def.hint,
+      url: def.url,
+      url_label: def.url_label,
+      secret: def.secret,
+      required: def.required,
+      targets: Array.from(paths).map(p => {
+        const dot = p.indexOf('.');
+        return dot < 0
+          ? { connector: p, field_path: '' }
+          : { connector: p.slice(0, dot), field_path: p.slice(dot + 1) };
+      }),
+    });
+  }
+  // Sort required first, then by label
+  pending.sort((a, b) =>
+    (b.required ? 1 : 0) - (a.required ? 1 : 0)
+    || a.label.localeCompare(b.label),
+  );
+
+  return { pending, static_apply_targets: staticTargets, missing_manifests: missing };
+}
+
+// ─── Apply ────────────────────────────────────────────────
+
+async function apply(template: any, values: Record<string, string>): Promise<{
+  applied: string[];
+  installed_from_registry: string[];
+  enabled_changed: string[];
+  skipped_missing_manifest: string[];
+  fields_preserved: Array<{ connector: string; field: string; reason: string }>;
+  fields_left_empty: Array<{ connector: string; field: string }>;
+}> {
+  // Auto-inject user identity from settings so connectors (e.g. tp.username)
+  // can use {user_name} / {user_email} without prompting the user again.
+  // User-supplied values still win over auto-injected ones.
+  const settings = loadSettings();
+  values = {
+    user_name: settings.displayName || '',
+    user_email: settings.displayEmail || '',
+    ...values,
+  };
+
+  const applied: string[] = [];
+  const installedFromRegistry: string[] = [];
+  const enabledChanged: string[] = [];
+  const missing: string[] = [];
+  const preserved: Array<{ connector: string; field: string; reason: string }> = [];
+  const leftEmpty: Array<{ connector: string; field: string }> = [];
+
+  for (const [id, row] of Object.entries(template)) {
+    if (isMetaKey(id)) continue;
+    let def = getConnector(id);
+    if (!def) {
+      // Manifest not installed yet — pull from forge-connectors registry
+      // and install. installFromRegistry auto-syncs cache if empty.
+      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, values);
+
+      // If still contains unresolved ${...} (user left blank for non-required),
+      // keep resolved as-is (empty strings collapsed already by substituteString).
+      const existingVal = existing[field];
+      const existingNonEmpty = !isEffectivelyEmpty(existingVal)
+        && !(typeof existingVal === 'string' && existingVal.startsWith('TODO_'));
+
+      if (existingNonEmpty) {
+        // Compare — if template would have set the same thing (after substitution),
+        // no-op silently; otherwise note as preserved.
+        if (JSON.stringify(existingVal) !== JSON.stringify(resolved)) {
+          preserved.push({ connector: id, field, reason: 'existing value kept' });
+        }
+        continue;
+      }
+
+      if (isEffectivelyEmpty(resolved)) {
+        leftEmpty.push({ connector: id, field });
+        // still write empty so the field shape exists (e.g. instances=[] is valid)
+        // — but for plain string fields, an empty string is fine too.
+      }
+      merged[field] = resolved;
+    }
+
+    setConnectorConfig(id, merged);
+    applied.push(id);
+
+    if (typeof enabledTemplate === 'boolean') {
+      setConnectorEnabled(id, enabledTemplate);
+      enabledChanged.push(id);
+    }
+  }
+
+  return {
+    applied,
+    installed_from_registry: installedFromRegistry,
+    enabled_changed: enabledChanged,
+    skipped_missing_manifest: missing,
+    fields_preserved: preserved,
+    fields_left_empty: leftEmpty,
+  };
+}
+
+// ─── Route ────────────────────────────────────────────────
+
+/**
+ * HEAD — existence probe. Always 200 because Forge ships a bundled
+ * template. Kept HEAD-only for the UI mount probe (no body cost).
+ */
+export async function HEAD() {
+  return new NextResponse(null, { status: 200 });
+}
+
+/**
+ * GET — one-click flow. Returns an analyzed template:
+ *   1. user override at <dataDir>/config-template.json, OR
+ *   2. bundled fallback (templates/connector-config-template.json).
+ * The UI uses this to pop the prompt modal without a file picker.
+ */
+export async function GET() {
+  try {
+    const { source, template, path } = resolveTemplate();
+    const result = analyze(template);
+    return NextResponse.json({ ok: true, source, path, template, ...result });
+  } catch (e) {
+    return NextResponse.json(
+      { ok: false, error: e instanceof Error ? e.message : String(e) },
+      { status: 500 },
+    );
+  }
+}
+
+export async function POST(req: Request) {
+  const ct = req.headers.get('content-type') || '';
+
+  try {
+    // Phase 1: analyze (multipart upload)
+    if (ct.startsWith('multipart/form-data')) {
+      const fd = await req.formData();
+      const file = fd.get('file');
+      if (!(file instanceof File)) {
+        return NextResponse.json({ ok: false, error: 'file field required' }, { status: 400 });
+      }
+      const text = await file.text();
+      let template: any;
+      try { template = JSON.parse(text); }
+      catch (e) {
+        return NextResponse.json(
+          { ok: false, error: `invalid JSON: ${(e as Error).message}` },
+          { status: 400 },
+        );
+      }
+      const result = analyze(template);
+      return NextResponse.json({ ok: true, template, ...result });
+    }
+
+    // Phase 2: apply (JSON body)
+    if (ct.includes('application/json')) {
+      const body = await req.json();
+      const template = body?.template;
+      const values = (body?.values ?? {}) as Record<string, string>;
+      if (!template || typeof template !== 'object') {
+        return NextResponse.json({ ok: false, error: 'template required' }, { status: 400 });
+      }
+      const result = await apply(template, values);
+      return NextResponse.json({ ok: true, ...result });
+    }
+
+    return NextResponse.json(
+      { ok: false, error: 'send multipart with `file` (analyze) or JSON {template,values} (apply)' },
+      { status: 400 },
+    );
+  } catch (e) {
+    return NextResponse.json(
+      { ok: false, error: e instanceof Error ? e.message : String(e) },
+      { status: 500 },
+    );
+  }
+}

package/app/api/onboarding/detect-cli/route.ts

@@ -0,0 +1,46 @@
+/**
+ * GET /api/onboarding/detect-cli
+ *
+ * Async, parallel `which <name> && <name> --version` for claude/codex/aider.
+ * Returns whichever ones are present. Fast — each probe capped at ~1.5s
+ * with explicit abort, then all 3 race in parallel (Promise.all).
+ *
+ * Split out from the main onboarding GET so Dashboard mount stays
+ * instant (3 × execSync was blocking the Node event loop up to 15s on
+ * misses, which froze every other API on the same worker).
+ *
+ * Wizard calls this when the drawer opens — by which time the user
+ * has already seen the rest of their config load.
+ */
+
+import { NextResponse } from 'next/server';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execAsync = promisify(exec);
+
+async function probe(name: string): Promise<{ name: string; path: string; version: string } | null> {
+  try {
+    const which = await execAsync(`which ${name}`, { timeout: 800 });
+    const path = which.stdout.trim();
+    if (!path) return null;
+    let version = '';
+    try {
+      const v = await execAsync(`${path} --version`, { timeout: 1500 });
+      const out = v.stdout.trim();
+      const m = out.match(/v?(\d+\.\d+\.\d+)/);
+      version = m ? m[1] : out.slice(0, 30);
+    } catch { /* optional */ }
+    return { name, path, version };
+  } catch {
+    return null;
+  }
+}
+
+export async function GET() {
+  const probes = await Promise.all(['claude', 'codex', 'aider'].map(probe));
+  return NextResponse.json({
+    ok: true,
+    detected: probes.filter((x): x is { name: string; path: string; version: string } => x != null),
+  });
+}