@polderlabs/bizar 4.4.13 → 4.5.0

package/bizar-dash/src/server/routes/config.mjs

@@ -8,6 +8,8 @@
  * /api/config/providers (POST)          — add
  * /api/config/providers/:id (PUT)       — update
  * /api/config/providers/:id (DELETE)    — remove
+ * /api/config/providers/auto (POST)     — add with key, auto-discover models
+ *                                          + apply systemLlm config
  * /api/config/mcps                      — list MCP servers
  * /api/config/mcps (POST)               — add
  * /api/config/mcps/:id (PUT)            — update
@@ -22,7 +24,12 @@
 import { Router } from 'express';
 import { existsSync, mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
-import { providersStore, mcpsStore } from '../providers-store.mjs';
+import {
+  providersStore,
+  mcpsStore,
+  loadConfig,
+  saveConfig,
+} from '../providers-store.mjs';
 import { OPENCODE_JSON, atomicWriteJson, safeReadJSON, wrap } from './_shared.mjs';
 
 /**
@@ -101,11 +108,55 @@ export function createConfigRouter({ state, watcher }) {
     res.status(204).end();
   }));
 
+  // v4.4.14 — "Add with key" — the user pastes a key, we figure out the
+  // rest. Auto-discovers the live model list (probes /v1/models), writes
+  // the full provider block, and (if requested) applies the system LLM
+  // config so the rest of the dashboard's /api/llm/* calls hit this
+  // provider+model.
+  router.post('/config/providers/auto', wrap(async (req, res) => {
+    const body = req.body || {};
+    const result = await providersStore.addWithAuto({
+      id: typeof body.id === 'string' ? body.id.trim() : undefined,
+      name: typeof body.name === 'string' ? body.name.trim() : undefined,
+      apiKey: typeof body.apiKey === 'string' ? body.apiKey : '',
+      groupId: typeof body.groupId === 'string' ? body.groupId : 'default',
+      setAsSystemLlm: body.setAsSystemLlm !== false,
+      preferredModel: typeof body.preferredModel === 'string' ? body.preferredModel : undefined,
+      systemLlmModel: typeof body.systemLlmModel === 'string' ? body.systemLlmModel : undefined,
+    });
+    if (!result.ok) {
+      res.status(result.error === 'unknown_provider' ? 400 : 400).json(result);
+      return;
+    }
+    res.status(201).json(result);
+  }));
+
   // ── /api/config/mcps ───────────────────────────────────────────────────
   router.get('/config/mcps', wrap(async (_req, res) => {
     res.json({ mcps: mcpsStore.list() });
   }));
 
+  // v4.4.14 — System LLM settings. The dashboard reads / writes the
+  // opencode.json#systemLlm block via this thin surface. The block
+  // controls which provider+model is used for the dashboard's own
+  // /api/llm/* calls (auto-title, enhance-prompt, summarization).
+  router.get('/llm/system-llm', wrap(async (_req, res) => {
+    const cfg = loadConfig();
+    res.json(cfg.systemLlm || { enabled: false, provider: null, model: null });
+  }));
+
+  router.put('/llm/system-llm', wrap(async (req, res) => {
+    const cfg = loadConfig();
+    const body = req.body || {};
+    cfg.systemLlm = {
+      enabled: body.enabled !== false,
+      provider: typeof body.provider === 'string' ? body.provider : (cfg.systemLlm?.provider || null),
+      model: typeof body.model === 'string' ? body.model : (cfg.systemLlm?.model || null),
+    };
+    saveConfig(cfg);
+    res.json(cfg.systemLlm);
+  }));
+
   router.post('/config/mcps', wrap(async (req, res) => {
     const mcp = mcpsStore.add(req.body || {});
     res.status(201).json(mcp);

package/bizar-dash/src/server/routes/env-vars.mjs

@@ -0,0 +1,165 @@
+/**
+ * src/server/routes/env-vars.mjs
+ *
+ * v1 — Bizar env vars stored in ~/.config/bizar/env.json (mode 0600).
+ *
+ * Endpoints:
+ *   GET    /api/env-vars           — list all (masked values)
+ *   POST   /api/env-vars           — create {name, value}
+ *   PUT    /api/env-vars/:name     — update {value}
+ *   DELETE /api/env-vars/:name     — remove + delete from process.env
+ *   POST   /api/env-vars/:name/test — {referenced, inProcessEnv}
+ *
+ * Name must match /^BIZAR_[A-Z0-9_]+$/.
+ * On startup, loadEnvJson() sets process.env[name] = value for every entry.
+ */
+import { Router } from 'express';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { wrap } from './_shared.mjs';
+
+const HOME = homedir();
+const BIZAR_DIR = join(HOME, '.config', 'bizar');
+const ENV_FILE = join(BIZAR_DIR, 'env.json');
+
+// Lazy-load store
+let _store = null;
+
+function readStore() {
+  if (_store !== null) return _store;
+  if (!existsSync(ENV_FILE)) {
+    _store = {};
+    return _store;
+  }
+  try {
+    _store = JSON.parse(readFileSync(ENV_FILE, 'utf8')) || {};
+  } catch {
+    _store = {};
+  }
+  return _store;
+}
+
+function writeStore(store) {
+  mkdirSync(BIZAR_DIR, { recursive: true });
+  const tmp = `${ENV_FILE}.tmp.${process.pid}`;
+  writeFileSync(tmp, JSON.stringify(store, null, 2) + '\n', { mode: 0o600 });
+  renameSync(tmp, ENV_FILE);
+  _store = store;
+}
+
+/**
+ * Load env.json into process.env at startup.
+ * Called once from server.mjs after createApiRouter().
+ */
+export function loadEnvJson() {
+  const store = readStore();
+  for (const [name, entry] of Object.entries(store)) {
+    if (name.startsWith('BIZAR_')) {
+      process.env[name] = entry.value;
+    }
+  }
+}
+
+/** Reset in-memory store — used by tests to ensure isolation between test cases. */
+export function resetStore() {
+  _store = null;
+}
+
+/** Mask a value — return last 4 chars, prefixed with ***. */
+function mask(value) {
+  if (!value || value.length <= 4) return '****';
+  return '*'.repeat(Math.max(0, value.length - 4)) + value.slice(-4);
+}
+
+const NAME_RE = /^BIZAR_[A-Z0-9_]+$/;
+
+export function createEnvVarsRouter() {
+  const router = Router();
+
+  // GET /api/env-vars — list all (masked)
+  router.get('/env-vars', wrap(async (_req, res) => {
+    const store = readStore();
+    const list = Object.entries(store).map(([name, entry]) => ({
+      name,
+      value: mask(entry.value),
+      createdAt: entry.createdAt,
+      source: entry.source,
+    }));
+    res.json(list);
+  }));
+
+  // POST /api/env-vars — create
+  router.post('/env-vars', wrap(async (req, res) => {
+    const { name, value } = req.body || {};
+    if (!name || typeof name !== 'string') {
+      res.status(400).json({ error: 'name_required', message: 'name is required' });
+      return;
+    }
+    if (!NAME_RE.test(name)) {
+      res.status(400).json({
+        error: 'invalid_name',
+        message: 'name must match /^BIZAR_[A-Z0-9_]+$/',
+      });
+      return;
+    }
+    if (!value || typeof value !== 'string') {
+      res.status(400).json({ error: 'value_required', message: 'value is required' });
+      return;
+    }
+    const store = readStore();
+    if (store[name]) {
+      res.status(409).json({ error: 'already_exists', message: `${name} already exists` });
+      return;
+    }
+    const entry = { value, createdAt: new Date().toISOString(), source: 'dashboard' };
+    store[name] = entry;
+    writeStore(store);
+    process.env[name] = value;
+    res.status(201).json({ name, value: mask(value), createdAt: entry.createdAt, source: entry.source });
+  }));
+
+  // PUT /api/env-vars/:name — update
+  router.put('/env-vars/:name', wrap(async (req, res) => {
+    const { name } = req.params;
+    const { value } = req.body || {};
+    if (!value || typeof value !== 'string') {
+      res.status(400).json({ error: 'value_required', message: 'value is required' });
+      return;
+    }
+    const store = readStore();
+    if (!store[name]) {
+      res.status(404).json({ error: 'not_found', message: `${name} not found` });
+      return;
+    }
+    store[name] = { ...store[name], value };
+    writeStore(store);
+    process.env[name] = value;
+    res.json({ name, value: mask(value), createdAt: store[name].createdAt, source: store[name].source });
+  }));
+
+  // DELETE /api/env-vars/:name — remove
+  router.delete('/env-vars/:name', wrap(async (req, res) => {
+    const { name } = req.params;
+    const store = readStore();
+    if (!store[name]) {
+      res.status(404).json({ error: 'not_found', message: `${name} not found` });
+      return;
+    }
+    delete store[name];
+    writeStore(store);
+    delete process.env[name];
+    res.json({ ok: true });
+  }));
+
+  // POST /api/env-vars/:name/test — check if referenced
+  router.post('/env-vars/:name/test', wrap(async (req, res) => {
+    const { name } = req.params;
+    const store = readStore();
+    const inProcessEnv = name in process.env;
+    // Conservative: we don't statically analyze code, so referenced = inProcessEnv for now
+    res.json({ referenced: inProcessEnv, inProcessEnv });
+  }));
+
+  return router;
+}

package/bizar-dash/src/server/routes/lightrag.mjs

@@ -0,0 +1,154 @@
+/**
+ * src/server/routes/lightrag.mjs
+ *
+ * v4.6.0 — LightRAG settings endpoints.
+ *
+ * Mounted at /api/lightrag/*. Used by the Settings view (handled by
+ * the sibling thor-settings agent) to surface and override the
+ * free-tier opencode Zen defaults that lightrag starts with.
+ *
+ * Endpoints:
+ *   GET  /lightrag/defaults      — current default models + provenance
+ *   PUT  /lightrag/defaults      — set env-var overrides (process-scoped, not persisted)
+ *   GET  /lightrag/status        — current running config (delegates to resolveLightRAGConfig)
+ *
+ * The PUT endpoint mutates `process.env` for the lifetime of the
+ * dashboard server process. We do NOT persist this to disk because:
+ *   1. env-var overrides are conventionally process-scoped, and
+ *   2. the proper way to persist is via PUT /api/memory/config which
+ *      writes to .bizar/memory.json (see routes/memory.mjs).
+ */
+import { Router } from 'express';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  getDefaultLightRAGConfig,
+  LIGHTRAG_DEFAULT_LLM,
+  LIGHTRAG_DEFAULT_EMBEDDING,
+} from '../memory-store.mjs';
+import { resolveLightRAGConfig } from '../memory-lightrag.mjs';
+import { wrap } from './_shared.mjs';
+
+/**
+ * @param {object} deps
+ * @param {string} deps.projectRoot
+ * @returns {import('express').Router}
+ */
+export function createLightragRouter({ projectRoot }) {
+  const router = Router();
+
+  // GET /api/lightrag/defaults — current defaults + where they came from.
+  router.get('/lightrag/defaults', wrap(async (_req, res) => {
+    const cfg = getDefaultLightRAGConfig();
+    res.json({
+      llm: cfg.llm,
+      embedding: cfg.embedding,
+      source: cfg.source,
+      llmSource: cfg.llmSource,
+      embeddingSource: cfg.embeddingSource,
+      builtin: {
+        llm: LIGHTRAG_DEFAULT_LLM,
+        embedding: LIGHTRAG_DEFAULT_EMBEDDING,
+      },
+      envVars: {
+        BIZAR_LIGHTRAG_LLM: process.env.BIZAR_LIGHTRAG_LLM || null,
+        BIZAR_LIGHTRAG_EMBEDDING: process.env.BIZAR_LIGHTRAG_EMBEDDING || null,
+      },
+    });
+  }));
+
+  // PUT /api/lightrag/defaults — set env-var overrides.
+  // Body: { llm?: string, embedding?: string }
+  // Both fields are optional; only the supplied ones are set. To clear
+  // an override, send an empty string ''.
+  router.put('/lightrag/defaults', wrap(async (req, res) => {
+    const body = req.body || {};
+    const updates = {};
+    if (Object.prototype.hasOwnProperty.call(body, 'llm')) {
+      const v = typeof body.llm === 'string' ? body.llm.trim() : '';
+      if (v) {
+        process.env.BIZAR_LIGHTRAG_LLM = v;
+        updates.llm = v;
+      } else {
+        delete process.env.BIZAR_LIGHTRAG_LLM;
+        updates.llmCleared = true;
+      }
+    }
+    if (Object.prototype.hasOwnProperty.call(body, 'embedding')) {
+      const v = typeof body.embedding === 'string' ? body.embedding.trim() : '';
+      if (v) {
+        process.env.BIZAR_LIGHTRAG_EMBEDDING = v;
+        updates.embedding = v;
+      } else {
+        delete process.env.BIZAR_LIGHTRAG_EMBEDDING;
+        updates.embeddingCleared = true;
+      }
+    }
+    const next = getDefaultLightRAGConfig();
+    res.json({
+      ok: true,
+      applied: updates,
+      llm: next.llm,
+      embedding: next.embedding,
+      source: next.source,
+    });
+  }));
+
+  // GET /api/lightrag/status — current resolved config + server status.
+  // Mirrors /api/memory/lightrag/status but is the canonical surface
+  // for the Settings view.
+  router.get('/lightrag/status', wrap(async (_req, res) => {
+    const cfg = resolveLightRAGConfig(projectRoot);
+    const pidFile = join(cfg.workingDir, 'lightrag.pid');
+    let pid = null;
+    let alive = false;
+    if (existsSync(pidFile)) {
+      try {
+        pid = parseInt(readFileSync(pidFile, 'utf8').trim(), 10);
+        if (Number.isFinite(pid) && pid > 0) {
+          try {
+            process.kill(pid, 0);
+            alive = true;
+          } catch {
+            alive = false;
+          }
+        } else {
+          pid = null;
+        }
+      } catch {
+        pid = null;
+      }
+    }
+
+    const logFile = join(cfg.workingDir, 'lightrag.log');
+    const logTail = [];
+    if (existsSync(logFile)) {
+      try {
+        const content = readFileSync(logFile, 'utf8');
+        const lines = content.split('\n');
+        logTail.push(...lines.slice(-30));
+      } catch { /* ignore */ }
+    }
+
+    let logSize = 0;
+    try {
+      if (existsSync(logFile)) logSize = statSync(logFile).size;
+    } catch { /* ignore */ }
+
+    res.json({
+      running: alive,
+      pid: alive ? pid : null,
+      host: cfg.host,
+      port: cfg.port,
+      llmBinding: cfg.llmBinding,
+      embeddingBinding: cfg.embeddingBinding,
+      llmModel: cfg.llmModel,
+      embeddingModel: cfg.embeddingModel,
+      workingDir: cfg.workingDir,
+      logSize,
+      logTail,
+    });
+  }));
+
+  return router;
+}

package/bizar-dash/src/server/routes/memory.mjs

@@ -12,7 +12,8 @@
 import { Router } from 'express';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, statSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
 
 const SERVER_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
 const memoryStore = await import(`${SERVER_ROOT}/memory-store.mjs`).then((m) => m);
@@ -654,5 +655,244 @@ export function createMemoryRouter({ projectRoot }) {
     }
   }));
 
+  // ── v4.6.0 Global memory-config surface ─────────────────────────────────
+  //
+  // A second config file at `~/.config/bizar/memory-config.json` holds
+  // operator-facing settings that aren't tied to a single project —
+  // e.g. the global default LightRAG URL, the global obsidian vault
+  // path, and git push defaults. The Settings view (handled by the
+  // sibling thor-settings agent) reads + writes this file via these
+  // endpoints.
+  //
+  // Distinct from the per-project `.bizar/memory.json` (the existing
+  // /memory/config surfaces that). We use a separate path to keep the
+  // two systems cleanly separated.
+
+  const GLOBAL_MEMORY_CONFIG_PATH = join(
+    process.env.HOME || '/tmp',
+    '.config',
+    'bizar',
+    'memory-config.json',
+  );
+
+  function loadGlobalMemoryConfig() {
+    try {
+      if (!existsSync(GLOBAL_MEMORY_CONFIG_PATH)) {
+        return {
+          exists: false,
+          config: {
+            lightrag: { enabled: false, url: 'http://127.0.0.1:9621', llm: '', embedding: '' },
+            obsidian: { vaultPath: '', syncInterval: 300 },
+            git: { repoPath: '', remoteUrl: '', branch: 'main', autoSync: false },
+          },
+        };
+      }
+      const raw = JSON.parse(readFileSync(GLOBAL_MEMORY_CONFIG_PATH, 'utf8'));
+      return { exists: true, config: raw };
+    } catch {
+      return {
+        exists: false,
+        error: 'corrupt_json',
+        config: {
+          lightrag: { enabled: false, url: 'http://127.0.0.1:9621', llm: '', embedding: '' },
+          obsidian: { vaultPath: '', syncInterval: 300 },
+          git: { repoPath: '', remoteUrl: '', branch: 'main', autoSync: false },
+        },
+      };
+    }
+  }
+
+  function saveGlobalMemoryConfig(config) {
+    const dir = dirname(GLOBAL_MEMORY_CONFIG_PATH);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    atomicWriteJson(GLOBAL_MEMORY_CONFIG_PATH, config);
+  }
+
+  // GET /memory/config/global — grouped shape (lightrag/obsidian/git).
+  router.get('/memory/config/global', wrap(async (_req, res) => {
+    const { exists, config, error } = loadGlobalMemoryConfig();
+    res.json({
+      exists,
+      path: GLOBAL_MEMORY_CONFIG_PATH,
+      config,
+      ...(error ? { error } : {}),
+    });
+  }));
+
+  // PUT /memory/config/global — partial update. Validates each block
+  // and merges on top of the existing config.
+  router.put('/memory/config/global', wrap(async (req, res) => {
+    const body = req.body || {};
+    const { exists, config: existing } = loadGlobalMemoryConfig();
+
+    // Light validation — no zod import (keep surface small). Each
+    // block is shallow-merged; if a block is present, we shallow-merge
+    // its top-level fields, rejecting unknown top-level keys.
+    const next = JSON.parse(JSON.stringify(existing));
+
+    const VALID_TOP_KEYS = new Set(['lightrag', 'obsidian', 'git']);
+    const EXTRA_KEYS = Object.keys(body).filter((k) => !VALID_TOP_KEYS.has(k));
+    if (EXTRA_KEYS.length > 0) {
+      res.status(400).json({
+        error: 'bad_request',
+        message: `unknown top-level keys: ${EXTRA_KEYS.join(', ')}`,
+      });
+      return;
+    }
+
+    if (body.lightrag !== undefined) {
+      if (typeof body.lightrag !== 'object' || body.lightrag === null || Array.isArray(body.lightrag)) {
+        res.status(400).json({ error: 'bad_request', message: 'lightrag must be an object' });
+        return;
+      }
+      const l = body.lightrag;
+      if ('enabled' in l && typeof l.enabled !== 'boolean') {
+        res.status(400).json({ error: 'bad_request', message: 'lightrag.enabled must be boolean' });
+        return;
+      }
+      if ('url' in l && typeof l.url !== 'string') {
+        res.status(400).json({ error: 'bad_request', message: 'lightrag.url must be a string' });
+        return;
+      }
+      if ('llm' in l && typeof l.llm !== 'string') {
+        res.status(400).json({ error: 'bad_request', message: 'lightrag.llm must be a string' });
+        return;
+      }
+      if ('embedding' in l && typeof l.embedding !== 'string') {
+        res.status(400).json({ error: 'bad_request', message: 'lightrag.embedding must be a string' });
+        return;
+      }
+      next.lightrag = { ...next.lightrag, ...l };
+    }
+
+    if (body.obsidian !== undefined) {
+      if (typeof body.obsidian !== 'object' || body.obsidian === null || Array.isArray(body.obsidian)) {
+        res.status(400).json({ error: 'bad_request', message: 'obsidian must be an object' });
+        return;
+      }
+      const o = body.obsidian;
+      if ('vaultPath' in o && typeof o.vaultPath !== 'string') {
+        res.status(400).json({ error: 'bad_request', message: 'obsidian.vaultPath must be a string' });
+        return;
+      }
+      if ('syncInterval' in o) {
+        const n = Number(o.syncInterval);
+        if (!Number.isFinite(n) || n < 0 || n > 86400 * 30) {
+          res.status(400).json({ error: 'bad_request', message: 'obsidian.syncInterval must be 0..2592000 seconds' });
+          return;
+        }
+        next.obsidian.syncInterval = n;
+      }
+      if ('vaultPath' in o) next.obsidian.vaultPath = o.vaultPath;
+    }
+
+    if (body.git !== undefined) {
+      if (typeof body.git !== 'object' || body.git === null || Array.isArray(body.git)) {
+        res.status(400).json({ error: 'bad_request', message: 'git must be an object' });
+        return;
+      }
+      const g = body.git;
+      if ('repoPath' in g && typeof g.repoPath !== 'string') {
+        res.status(400).json({ error: 'bad_request', message: 'git.repoPath must be a string' });
+        return;
+      }
+      if ('remoteUrl' in g && typeof g.remoteUrl !== 'string') {
+        res.status(400).json({ error: 'bad_request', message: 'git.remoteUrl must be a string' });
+        return;
+      }
+      if ('branch' in g) {
+        if (typeof g.branch !== 'string' || !/^[A-Za-z0-9._/-]{1,200}$/.test(g.branch)) {
+          res.status(400).json({ error: 'bad_request', message: 'git.branch must be a valid git ref name' });
+          return;
+        }
+        next.git.branch = g.branch;
+      }
+      if ('autoSync' in g && typeof g.autoSync !== 'boolean') {
+        res.status(400).json({ error: 'bad_request', message: 'git.autoSync must be boolean' });
+        return;
+      }
+      if ('repoPath' in g) next.git.repoPath = g.repoPath;
+      if ('remoteUrl' in g) next.git.remoteUrl = g.remoteUrl;
+      if ('autoSync' in g) next.git.autoSync = g.autoSync;
+    }
+
+    try {
+      saveGlobalMemoryConfig(next);
+    } catch (err) {
+      res.status(500).json({ error: 'write_failed', message: err.message });
+      return;
+    }
+    res.json({ ok: true, exists: true, path: GLOBAL_MEMORY_CONFIG_PATH, config: next });
+  }));
+
+  // POST /memory/test-git — test the configured git repo. Returns:
+  //   { ok: bool, checks: [...], message?: string }
+  // Steps performed:
+  //   1. Path exists?
+  //   2. Is a directory?
+  //   3. Is a valid git repo (has .git/)?
+  //   4. (Optional) Has a configured remote?
+  //   5. (Optional) Can we push (skipped unless ?push=1)?
+  router.post('/memory/test-git', wrap(async (req, res) => {
+    const { config } = loadGlobalMemoryConfig();
+    const repoPath = config?.git?.repoPath || '';
+    const remoteUrl = config?.git?.remoteUrl || '';
+    const wantPush = req.query.push === '1' || req.body?.push === true;
+
+    const checks = [];
+    if (!repoPath) {
+      checks.push({ name: 'repo_path_set', pass: false, detail: 'git.repoPath is empty — set it in Settings first' });
+      res.json({ ok: false, checks, message: 'repo path not configured' });
+      return;
+    }
+
+    checks.push({
+      name: 'repo_path_exists',
+      pass: existsSync(repoPath),
+      detail: existsSync(repoPath) ? repoPath : `${repoPath} does not exist`,
+    });
+
+    let isGit = false;
+    let isDir = false;
+    try {
+      const s = statSync(repoPath);
+      isDir = s.isDirectory();
+      checks.push({ name: 'repo_is_directory', pass: isDir, detail: isDir ? 'yes' : 'not a directory' });
+    } catch (err) {
+      checks.push({ name: 'repo_is_directory', pass: false, detail: err.message });
+    }
+
+    if (isDir) {
+      isGit = existsSync(join(repoPath, '.git'));
+      checks.push({ name: 'is_git_repo', pass: isGit, detail: isGit ? 'yes' : 'no .git/ directory' });
+    } else {
+      checks.push({ name: 'is_git_repo', pass: false, detail: 'skipped (not a directory)' });
+    }
+
+    if (remoteUrl) {
+      checks.push({ name: 'remote_url_set', pass: true, detail: remoteUrl });
+    } else {
+      checks.push({ name: 'remote_url_set', pass: false, detail: 'no remote configured' });
+    }
+
+    if (wantPush && isGit && remoteUrl) {
+      try {
+        const out = execFileSync('git', ['ls-remote', '--heads', remoteUrl], { timeout: 5000 }).toString();
+        checks.push({ name: 'remote_reachable', pass: true, detail: `${out.split('\n').filter(Boolean).length} heads` });
+      } catch (err) {
+        checks.push({ name: 'remote_reachable', pass: false, detail: err.message });
+      }
+    }
+
+    const ok = checks.every((c) => c.pass);
+    res.json({
+      ok,
+      checks,
+      message: ok ? 'git config looks healthy' : 'one or more checks failed',
+    });
+  }));
+
   return router;
 }