@monoes/monomindcli 2.16.11 → 2.16.13

package/dist/src/ui/routes-org-agents.mjs

@@ -0,0 +1,318 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+// Org dashboard routes: adapters, agent detail and agent avatar.
+// Registered, in order, by handleOrgRoutes in routes-org.mjs.
+export async function handleOrgAgentRoutes(req, res, url, corsOrigin, ctx) {
+  // GET /api/org/:name/adapters — org adapter registry
+  if (req.method === 'GET' && /^\/api\/org\/[a-z0-9][a-z0-9_-]{0,63}\/adapters$/i.test(url)) {
+    try {
+      const parts = url.split('/');
+      const orgName = decodeURIComponent(parts[3]);
+      if (orgName.length > 64 || !/^[a-z0-9][a-z0-9_-]*$/i.test(orgName)) {
+        res.writeHead(400);
+        res.end('{}');
+        return true;
+      }
+      const _adaptersQs = new URL(req.url, 'http://localhost').searchParams;
+      const _adaptersRoot = path.resolve(_adaptersQs.get('dir') || ctx.projectDir || process.cwd());
+      const d = ctx._resolveOrgProjectDir(orgName, _adaptersRoot) || _adaptersRoot;
+      const adaptersFile = path.join(d, '.monomind', 'orgs', `${orgName}-adapters.json`);
+      if (!fs.existsSync(adaptersFile)) {
+        // Return defaults derived from org config if available
+        const orgFile = path.join(d, '.monomind', 'orgs', `${orgName}.json`);
+        // claude-sonnet-5 = DEFAULT_CLAUDE_MODEL (src/orgrt/vercel-providers.ts); .mjs can't import TS.
+        let defaultAdapter = 'claude-sonnet-5';
+        try {
+          defaultAdapter =
+            JSON.parse(fs.readFileSync(orgFile, 'utf8'))?.run_config?.ceo_adapter || defaultAdapter;
+        } catch (_) {}
+        res.writeHead(200, {
+          'Content-Type': 'application/json',
+          ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}),
+        });
+        // This list mirrors the runtimes orgrt/daemon.ts actually registers
+        // (resolveRunner()'s if-chain + the ClaudeAgentRunner default it falls
+        // through to) rather than an independent, hand-maintained catalog — a
+        // standalone 'gemini-local' entry used to be advertised here even
+        // though no runner is ever registered for it (autoRuntimeFromProvider
+        // has no 'gemini' case, so a role requesting it silently falls back to
+        // Claude — see daemon.ts#startOrg's fail-fast warning). Gemini is only
+        // actually reachable via the 'vercel' runtime (vendor: 'google') or via
+        // 'antigravity' (Google-account CLI), both listed below. 'http' maps to
+        // provider.kind === 'base-url' (ANTHROPIC_BASE_URL + optional auth
+        // token) — a real, usable path, not disabled.
+        res.end(
+          JSON.stringify({
+            default_adapter: defaultAdapter,
+            adapters: [
+              {
+                type: 'claude-local',
+                label: 'Claude (local CLI)',
+                source: 'built-in',
+                disabled: false,
+                modelsCount: 3,
+              },
+              {
+                type: 'codex-local',
+                label: 'Codex CLI',
+                source: 'built-in',
+                disabled: false,
+                modelsCount: 1,
+              },
+              {
+                type: 'antigravity',
+                label: 'Antigravity (Google CLI)',
+                source: 'built-in',
+                disabled: false,
+                modelsCount: 1,
+              },
+              {
+                type: 'grok',
+                label: 'Grok CLI',
+                source: 'built-in',
+                disabled: false,
+                modelsCount: 1,
+              },
+              {
+                type: 'qwen',
+                label: 'Qwen CLI',
+                source: 'built-in',
+                disabled: false,
+                modelsCount: 1,
+              },
+              {
+                type: 'crush',
+                label: 'Crush CLI',
+                source: 'built-in',
+                disabled: false,
+                modelsCount: 1,
+              },
+              {
+                type: 'copilot',
+                label: 'GitHub Copilot CLI',
+                source: 'built-in',
+                disabled: false,
+                modelsCount: 1,
+              },
+              { type: 'pi', label: 'Pi CLI', source: 'built-in', disabled: false, modelsCount: 1 },
+              {
+                type: 'opencode',
+                label: 'OpenCode CLI',
+                source: 'built-in',
+                disabled: false,
+                modelsCount: 1,
+              },
+              {
+                type: 'kimicode',
+                label: 'KimiCode CLI',
+                source: 'built-in',
+                disabled: false,
+                modelsCount: 1,
+              },
+              {
+                type: 'vercel',
+                label: 'Vercel AI SDK (multi-vendor, incl. Gemini/OpenAI)',
+                source: 'built-in',
+                disabled: false,
+                modelsCount: 14,
+              },
+              {
+                type: 'http',
+                label: 'Custom HTTP (base-url provider)',
+                source: 'built-in',
+                disabled: false,
+                modelsCount: 0,
+              },
+            ],
+          }),
+        );
+        return true;
+      }
+      const data = JSON.parse(fs.readFileSync(adaptersFile, 'utf8'));
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+        ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}),
+      });
+      res.end(JSON.stringify(data));
+    } catch (_) {
+      res.writeHead(500);
+      res.end('{}');
+    }
+    return true;
+  }
+
+  // GET /api/org/:name/agent/:roleId — full agent detail: org role + .claude/agents definition
+  //   (characteristics, responsibilities, instructions document)
+  if (
+    req.method === 'GET' &&
+    /^\/api\/org\/[a-z0-9][a-z0-9_-]{0,63}\/agent\/[a-z0-9][a-z0-9_-]{0,63}$/i.test(url)
+  ) {
+    try {
+      const parts = url.split('/');
+      const orgName = decodeURIComponent(parts[3]);
+      const roleId = decodeURIComponent(parts[5]);
+      if (orgName.length > 64 || !/^[a-z0-9][a-z0-9_-]*$/i.test(orgName)) {
+        res.writeHead(400);
+        res.end('{}');
+        return true;
+      }
+      if (roleId.length > 64 || !/^[a-z0-9][a-z0-9_-]*$/i.test(roleId)) {
+        res.writeHead(400);
+        res.end('{}');
+        return true;
+      }
+      const _agentQs = new URL(req.url, 'http://localhost').searchParams;
+      const d = path.resolve(_agentQs.get('dir') || ctx.projectDir || process.cwd());
+      const orgFile = path.join(d, '.monomind', 'orgs', `${orgName}.json`);
+      if (!fs.existsSync(orgFile)) {
+        res.writeHead(404);
+        res.end('{}');
+        return true;
+      }
+      const config = JSON.parse(fs.readFileSync(orgFile, 'utf8'));
+      const role = (config.roles || []).find((r) => r.id === roleId);
+      if (!role) {
+        res.writeHead(404);
+        res.end('{}');
+        return true;
+      }
+
+      const agentType = String(role.agent_type || role.type || '').toLowerCase();
+      const wanted = [agentType, String(role.id).toLowerCase()].filter(Boolean);
+
+      // Find a matching agent definition under .claude/agents (recursive); match frontmatter name then filename.
+      const agentsDir = path.join(d, '.claude', 'agents');
+      let definition = { found: false };
+      if (wanted.length && fs.existsSync(agentsDir)) {
+        const stack = [agentsDir];
+        let nameMatch = null,
+          slugMatch = null;
+        while (stack.length && !nameMatch) {
+          const dir = stack.pop();
+          let entries = [];
+          try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+          } catch (_) {
+            continue;
+          }
+          for (const e of entries) {
+            const full = path.join(dir, e.name);
+            if (e.isDirectory()) {
+              stack.push(full);
+              continue;
+            }
+            if (!e.name.endsWith('.md') || e.name.startsWith('_')) continue;
+            const slug = e.name.replace(/\.md$/, '').toLowerCase();
+            let raw = '';
+            try {
+              raw = fs.readFileSync(full, 'utf8');
+            } catch (_) {
+              continue;
+            }
+            const fmName = ((raw.match(/^name:\s*(.+)$/m) || [])[1] || '').trim().toLowerCase();
+            if (fmName && wanted.includes(fmName)) {
+              nameMatch = { full, raw };
+              break;
+            }
+            if (!slugMatch && wanted.includes(slug)) slugMatch = { full, raw };
+          }
+        }
+        const match = nameMatch || slugMatch;
+        if (match) {
+          definition = ctx.parseAgentDef(match.raw);
+          definition.found = true;
+          definition.file = path.relative(d, match.full);
+        }
+      }
+
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+        ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}),
+        'Cache-Control': 'no-cache',
+      });
+      res.end(JSON.stringify({ role, definition }));
+    } catch (_) {
+      res.writeHead(500);
+      res.end('{}');
+    }
+    return true;
+  }
+
+  // POST /api/org/:name/agent/:roleId/avatar — set (or clear) a custom avatar for one
+  // role, stored inline as a data URL on the role itself so it travels with the org
+  // config export/import. Body: { avatarDataUrl } — null/omitted avatarDataUrl clears
+  // the custom avatar and reverts to the built-in library picture. `dir` (like every
+  // other dir-accepting route in this file, POST included — see /goals above) comes
+  // from the query string, not the body.
+  if (
+    req.method === 'POST' &&
+    /^\/api\/org\/[a-z0-9][a-z0-9_-]{0,63}\/agent\/[a-z0-9][a-z0-9_-]{0,63}\/avatar$/i.test(url)
+  ) {
+    let body = '';
+    for await (const chunk of req) {
+      body += chunk;
+      if (body.length > 8388608) {
+        req.destroy();
+        break;
+      }
+    }
+    try {
+      const parts = url.split('/');
+      const orgName = decodeURIComponent(parts[3]);
+      const roleId = decodeURIComponent(parts[5]);
+      if (orgName.length > 64 || !/^[a-z0-9][a-z0-9_-]*$/i.test(orgName)) {
+        res.writeHead(400);
+        res.end('{"ok":false,"error":"Invalid org name"}');
+        return true;
+      }
+      if (roleId.length > 64 || !/^[a-z0-9][a-z0-9_-]*$/i.test(roleId)) {
+        res.writeHead(400);
+        res.end('{"ok":false,"error":"Invalid role id"}');
+        return true;
+      }
+      const parsed = JSON.parse(body);
+      const avatarDataUrl = parsed.avatarDataUrl;
+      if (
+        avatarDataUrl != null &&
+        (typeof avatarDataUrl !== 'string' ||
+          avatarDataUrl.length > 2_000_000 ||
+          !/^data:image\/(png|jpe?g|webp|gif);base64,[A-Za-z0-9+/=]+$/.test(avatarDataUrl))
+      ) {
+        res.writeHead(400);
+        res.end('{"ok":false,"error":"Invalid or oversized avatarDataUrl"}');
+        return true;
+      }
+      const _avatarQs = new URL(req.url, 'http://localhost').searchParams;
+      const d = path.resolve(_avatarQs.get('dir') || ctx.projectDir || process.cwd());
+      const orgFile = path.join(d, '.monomind', 'orgs', `${orgName}.json`);
+      if (!fs.existsSync(orgFile)) {
+        res.writeHead(404);
+        res.end('{"ok":false,"error":"org not found"}');
+        return true;
+      }
+      const config = JSON.parse(fs.readFileSync(orgFile, 'utf8'));
+      const role = (config.roles || []).find((r) => r.id === roleId);
+      if (!role) {
+        res.writeHead(404);
+        res.end('{"ok":false,"error":"role not found"}');
+        return true;
+      }
+      if (avatarDataUrl) role.avatar = avatarDataUrl;
+      else delete role.avatar;
+      const tmp = `${orgFile}.tmp`;
+      fs.writeFileSync(tmp, JSON.stringify(config, null, 2), 'utf-8');
+      fs.renameSync(tmp, orgFile);
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+        ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}),
+      });
+      res.end(JSON.stringify({ ok: true }));
+    } catch (e) {
+      res.writeHead(500);
+      res.end(JSON.stringify({ ok: false, error: String(e.message || e) }));
+    }
+    return true;
+  }
+  return false;
+}

package/dist/src/ui/routes-org-approvals.mjs

@@ -0,0 +1,133 @@
+import path from 'node:path';
+import * as hil from './org-hil.mjs';
+import {
+  decodeHilSegment,
+  hilEvent,
+  hilRespond,
+  hilRoot,
+  readHilBody,
+  validOrgName,
+} from './routes-org-helpers.mjs';
+
+// Org dashboard routes: human-in-the-loop approvals, gates and questions.
+// Registered, in order, by handleOrgRoutes in routes-org.mjs.
+export async function handleOrgApprovalRoutes(req, res, url, corsOrigin, ctx) {
+  // GET /api/org/:name/approvals — the org's tool/action approvals
+  // (<org>/approvals.json, written by orgrt/approvals.ts), newest first.
+  if (
+    req.method === 'GET' &&
+    url.match(/^\/api\/org\/[a-z0-9][a-z0-9_-]{0,63}\/approvals(\?.*)?$/i)
+  ) {
+    const orgName = decodeURIComponent(url.split('/')[3].split('?')[0]);
+    return hilRespond(res, corsOrigin, () => {
+      const approvals = hil.listApprovals(hilRoot(req, ctx), orgName);
+      return { approvals, pending: approvals.filter((a) => a.status === 'pending').length };
+    });
+  }
+
+  // GET /api/org/:name/gates — the org's decision gates (<org>/gates.json).
+  if (req.method === 'GET' && url.match(/^\/api\/org\/[a-z0-9][a-z0-9_-]{0,63}\/gates(\?.*)?$/i)) {
+    const orgName = decodeURIComponent(url.split('/')[3].split('?')[0]);
+    return hilRespond(res, corsOrigin, () => {
+      const gates = hil.listGates(hilRoot(req, ctx), orgName);
+      return { gates, pending: gates.filter((g) => g.status === 'pending').length };
+    });
+  }
+
+  // GET /api/questions?dir= — ask_human questions (pending and answered) for
+  // every org in one project, each with its `blocking` flag.
+  if (req.method === 'GET' && (url === '/api/questions' || url.startsWith('/api/questions?'))) {
+    return hilRespond(res, corsOrigin, () => ({
+      questions: hil.pendingForProject(hilRoot(req, ctx)).questions,
+    }));
+  }
+
+  // GET /api/hil?dir= — everything in one project that waits on a human:
+  // questions, approvals and decision gates across all its orgs.
+  if (req.method === 'GET' && (url === '/api/hil' || url.startsWith('/api/hil?'))) {
+    return hilRespond(res, corsOrigin, () => hil.pendingForProject(hilRoot(req, ctx)));
+  }
+
+  // POST /api/questions/answer { dir, org, questionId, answer } — live to the
+  // hosting daemon (operator credential), else queued for the org's next run.
+  if (req.method === 'POST' && url === '/api/questions/answer') {
+    return hilRespond(res, corsOrigin, async () => {
+      const body = await readHilBody(req);
+      const { org, questionId, answer } = body || {};
+      if (!validOrgName(org) || !questionId || typeof answer !== 'string' || !answer.trim())
+        throw Object.assign(new Error('org, questionId and a non-empty answer are required'), {
+          status: 400,
+        });
+      const root = path.resolve(body.dir || ctx.projectDir || process.cwd());
+      const r = await hil.answerQuestion(root, org, String(questionId), answer.trim());
+      hilEvent(ctx, root, {
+        type: 'org:question-answered',
+        org,
+        role: r.role,
+        questionId,
+        delivery: r.delivery,
+      });
+      return { ok: true, ...r };
+    });
+  }
+
+  // POST /api/org/:name/gates/:id { approved: boolean, resolution? } — resolve
+  // a decision gate, live or (org not running) in gates.json.
+  if (
+    req.method === 'POST' &&
+    url.match(/^\/api\/org\/[a-z0-9][a-z0-9_-]{0,63}\/gates\/[^/?]+(\?.*)?$/i)
+  ) {
+    const parts = url.split('?')[0].split('/');
+    const orgName = decodeURIComponent(parts[3]);
+    const root = hilRoot(req, ctx);
+    return hilRespond(res, corsOrigin, async () => {
+      const gateId = decodeHilSegment(parts[5]);
+      const body = await readHilBody(req);
+      const resolution =
+        typeof body?.resolution === 'string' && body.resolution.trim()
+          ? body.resolution.trim().slice(0, 4000)
+          : undefined;
+      if (typeof body?.approved !== 'boolean')
+        throw Object.assign(new Error('approved (boolean) is required'), { status: 400 });
+      const r = await hil.resolveGate(root, orgName, gateId, body.approved, resolution);
+      const status = body.approved ? 'approved' : 'rejected';
+      hilEvent(ctx, root, {
+        type: 'org:gate:resolved',
+        org: orgName,
+        gateId,
+        status,
+        delivery: r.delivery,
+      });
+      return { ok: true, status, ...r };
+    });
+  }
+
+  // POST /api/org/:name/approvals/:requestId { action: "approve" | "reject" } —
+  // resolve one tool/action approval, live or (org not running) in approvals.json.
+  if (
+    req.method === 'POST' &&
+    url.match(/^\/api\/org\/[a-z0-9][a-z0-9_-]{0,63}\/approvals\/[^/?]+(\?.*)?$/i)
+  ) {
+    const parts = url.split('?')[0].split('/');
+    const orgName = decodeURIComponent(parts[3]);
+    const root = hilRoot(req, ctx);
+    return hilRespond(res, corsOrigin, async () => {
+      const requestId = decodeHilSegment(parts[5]);
+      const body = await readHilBody(req);
+      if (body?.action !== 'approve' && body?.action !== 'reject')
+        throw Object.assign(new Error('action must be approve or reject'), { status: 400 });
+      const approved = body.action === 'approve';
+      const r = await hil.resolveApproval(root, orgName, requestId, approved);
+      const status = approved ? 'approved' : 'denied';
+      hilEvent(ctx, root, {
+        type: 'org:approval:resolved',
+        org: orgName,
+        requestId,
+        status,
+        delivery: r.delivery,
+      });
+      return { ok: true, status, ...r };
+    });
+  }
+  return false;
+}