@nac3/forge-cli 1.0.34 → 1.0.38

package/dist/chat/server.js

@@ -1918,6 +1918,28 @@ async function route(req, res, ctx) {
         await handleBrainConfigSet(req, res, ctx);
         return;
     }
+    /* F4 brain federation -- connect to another Forge's brain, mint
+       authorize/route codes, host the answer loop, all from the panel. */
+    if (req.method === 'GET' && url.pathname === '/api/forge/federation') {
+        await handleFederationGet(req, res);
+        return;
+    }
+    if (req.method === 'POST' && url.pathname === '/api/forge/federation/join') {
+        await handleFederationJoin(req, res);
+        return;
+    }
+    if (req.method === 'POST' && url.pathname === '/api/forge/federation/leave') {
+        await handleFederationLeave(req, res);
+        return;
+    }
+    if (req.method === 'POST' && url.pathname === '/api/forge/federation/invite') {
+        await handleFederationInvite(req, res);
+        return;
+    }
+    if (req.method === 'POST' && url.pathname === '/api/forge/federation/host') {
+        await handleFederationHost(req, res);
+        return;
+    }
     /* PND-069 -- modelos disponibles por provider (API en vivo con
        fallback estatico). */
     if (req.method === 'GET' && url.pathname === '/api/forge/brain-models') {
@@ -3208,6 +3230,192 @@ async function handleBrainConfigSet(req, res, ctx) {
         restart_needed_for: applied_live ? [] : ['anthropic_mode'],
     });
 }
+/* ============================================================
+ * F4 brain federation -- settings-panel handlers (2026-06-21).
+ *
+ * The federation protocol (client/host/broker/CLI) already exists;
+ * this exposes it in the panel so a non-terminal user can: connect
+ * to another Forge's brain (child join), mint an authorize/route
+ * code (parent invite), see status, leave, and toggle hosting. The
+ * host answer-loop runs INSIDE the panel process while the toggle is
+ * on; closing the panel (process exit) stops it.
+ *
+ * Routing is automatic: once federation.json is active, cost_router's
+ * maybeApplyFederation() points every turn at the parent's brain, so
+ * join only has to write the config + vault key (CLI parity).
+ * ============================================================ */
+const federationHostRuntime = {
+    running: false, controller: null,
+};
+/** Mask the child id in a fed handle for display: fed:<parent>:<id> -> fed:<parent>:<id6>... */
+function maskFedHandle(fedHandle) {
+    const i = fedHandle.lastIndexOf(':');
+    if (i < 0)
+        return fedHandle;
+    return fedHandle.slice(0, i + 1) + fedHandle.slice(i + 1, i + 7) + '...';
+}
+/** GET /api/forge/federation -- current child link, parent invite
+ *  capability, and host-loop state. */
+async function handleFederationGet(_req, res) {
+    const { readFederationConfig, getFederationKey } = await import('../core/federation_config.js');
+    const { resolveParentAuth } = await import('../llm/federation_host.js');
+    const cfg = await readFederationConfig();
+    const keyPresent = (await getFederationKey()) !== null;
+    const auth = await resolveParentAuth();
+    sendJson(res, 200, {
+        ok: true,
+        child: cfg ? {
+            active: cfg.active,
+            parent_handle: cfg.parent_handle,
+            fed_handle: maskFedHandle(cfg.fed_handle),
+            base_url: cfg.base_url,
+            joined_at: cfg.joined_at,
+            key_present: keyPresent,
+        } : null,
+        parent: { can_invite: !!auth, handle: auth ? auth.handle : null },
+        host: { running: federationHostRuntime.running },
+    });
+}
+/** POST /api/forge/federation/join { token } -- redeem a parent's
+ *  code; from now on every turn routes to the parent's brain. */
+async function handleFederationJoin(req, res) {
+    const { setFederationKey, writeFederationConfig } = await import('../core/federation_config.js');
+    const { HITO4_BASE_URL } = await import('../license/hito4_client.js');
+    let body;
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch {
+        sendJson(res, 400, { ok: false, error: 'invalid json body' });
+        return;
+    }
+    const token = typeof body.token === 'string' ? body.token.trim() : '';
+    if (!token) {
+        sendJson(res, 400, { ok: false, error: 'falta el codigo de federacion' });
+        return;
+    }
+    const baseUrl = (typeof body.base_url === 'string' && body.base_url ? body.base_url : HITO4_BASE_URL).replace(/\/+$/, '');
+    let r;
+    try {
+        r = await fetch(baseUrl + '/v1/federation/redeem', {
+            method: 'POST', headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ token }),
+        });
+    }
+    catch (e) {
+        sendJson(res, 502, { ok: false, error: 'no pude contactar el broker: ' + (e instanceof Error ? e.message : String(e)) });
+        return;
+    }
+    const j = await r.json().catch(() => ({}));
+    if (!r.ok || !j.ok || !j.fed_handle || !j.fed_key || !j.parent_handle) {
+        sendJson(res, r.status === 400 ? 400 : 502, {
+            ok: false,
+            error: (j.error || ('HTTP ' + r.status)) + (r.status === 400 ? ' (codigo invalido o vencido)' : ''),
+        });
+        return;
+    }
+    await setFederationKey(j.fed_key);
+    await writeFederationConfig({
+        active: true,
+        parent_handle: j.parent_handle,
+        fed_handle: j.fed_handle,
+        base_url: baseUrl,
+        joined_at: new Date().toISOString(),
+    });
+    sendJson(res, 200, { ok: true, parent_handle: j.parent_handle });
+}
+/** POST /api/forge/federation/leave -- drop the link; route locally. */
+async function handleFederationLeave(_req, res) {
+    const { readFederationConfig, clearFederationConfig } = await import('../core/federation_config.js');
+    const cfg = await readFederationConfig();
+    await clearFederationConfig();
+    sendJson(res, 200, { ok: true, was_federated: !!cfg, parent_handle: cfg ? cfg.parent_handle : null });
+}
+/** POST /api/forge/federation/invite { ttl_seconds? } -- PARENT mints a
+ *  single-use authorize/route code to lend its brain to a child. */
+async function handleFederationInvite(req, res) {
+    const { resolveParentAuth } = await import('../llm/federation_host.js');
+    const { HITO4_BASE_URL, signBearer } = await import('../license/hito4_client.js');
+    const auth = await resolveParentAuth();
+    if (!auth) {
+        sendJson(res, 400, { ok: false, error: 'Necesitas una licencia activa (handle provisto) para prestar tu brain.' });
+        return;
+    }
+    let body = {};
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch { /* empty body ok */ }
+    const baseUrl = (typeof body.base_url === 'string' && body.base_url ? body.base_url : HITO4_BASE_URL).replace(/\/+$/, '');
+    const payload = {};
+    if (Number.isFinite(Number(body.ttl_seconds)))
+        payload.ttl_seconds = Number(body.ttl_seconds);
+    let r;
+    try {
+        r = await fetch(baseUrl + '/v1/federation/invite', {
+            method: 'POST',
+            headers: {
+                'authorization': 'Bearer ' + signBearer(auth.secret, auth.handle),
+                'x-yf-user-handle': auth.handle,
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+    }
+    catch (e) {
+        sendJson(res, 502, { ok: false, error: 'no pude contactar el broker: ' + (e instanceof Error ? e.message : String(e)) });
+        return;
+    }
+    const j = await r.json().catch(() => ({}));
+    if (!r.ok || !j.ok || !j.token) {
+        sendJson(res, 502, { ok: false, error: j.error || ('HTTP ' + r.status) });
+        return;
+    }
+    sendJson(res, 200, { ok: true, token: j.token, expires_in: j.expires_in ?? 1800 });
+}
+/** POST /api/forge/federation/host { enabled } -- start/stop the answer
+ *  loop inside the panel process so children get this brain's replies. */
+async function handleFederationHost(req, res) {
+    let body = {};
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch { /* default */ }
+    const enable = body.enabled === true;
+    if (enable) {
+        if (federationHostRuntime.running) {
+            sendJson(res, 200, { ok: true, running: true });
+            return;
+        }
+        const { resolveParentAuth, runFederationHost } = await import('../llm/federation_host.js');
+        const auth = await resolveParentAuth();
+        if (!auth) {
+            sendJson(res, 400, { ok: false, error: 'Necesitas una licencia activa para hospedar.' });
+            return;
+        }
+        const controller = new AbortController();
+        federationHostRuntime.controller = controller;
+        federationHostRuntime.running = true;
+        /* Fire-and-forget: the loop runs until aborted (panel close or toggle
+         * off). Reset the flag if it ever returns/throws on its own. */
+        void runFederationHost({ signal: controller.signal })
+            .catch(() => undefined)
+            .finally(() => {
+            if (federationHostRuntime.controller === controller) {
+                federationHostRuntime.running = false;
+                federationHostRuntime.controller = null;
+            }
+        });
+        sendJson(res, 200, { ok: true, running: true });
+        return;
+    }
+    /* Disable. */
+    if (federationHostRuntime.controller)
+        federationHostRuntime.controller.abort();
+    federationHostRuntime.running = false;
+    federationHostRuntime.controller = null;
+    sendJson(res, 200, { ok: true, running: false });
+}
 /** PND-064 -- POST /api/forge/panel-invoke. Paridad total de tools
  *  en modo Plan: el MCP server local reenvia aca cada nac3_invoke
  *  del subproceso `claude -p`. Corre el MISMO dispatcher que el
@@ -4714,6 +4922,19 @@ async function handleChat(req, res, ctx) {
         const chatRequest = {
             messages: turnMessages,
             signal: turnSignal,
+            /* Path A (2026-06-22) -- thread the SSE emitter so the brain client
+             * streams the model's inter-round prose (assistant_round_text) to the
+             * panel as a running commentary. The CLI path already gets this via
+             * the callerForChat wrapper; this closes the parity gap for the HTTP/
+             * unified (Console BYOK + managed) path. wrap() forwards it to the
+             * underlying ClaudeClient; non-Anthropic clients simply ignore it. */
+            onStreamEvent: sseEmit,
+            /* Pendiente B (2026-06-22) -- token streaming. Only when the panel
+             * opened an SSE stream (streamMode); the brain client then emits
+             * assistant_delta per fragment so the panel writes token-by-token.
+             * Non-stream callers (mobile loopback, internal) keep the buffered
+             * path. The CLI provider ignores it (it streams via the subprocess). */
+            stream: streamMode,
             /* Pablo 2026-06-15 -- the model MUST follow the brain config in
              * BOTH paths. Console (unified client) already bakes it into the
              * client; Plan (`claude -p`) reads it per turn -> without this the