borgmcp 1.0.6 → 1.0.8

package/dist/assimilate-deps.js

@@ -1,177 +1,3 @@
-/**
- * Real-IO factory for the `borg assimilate` orchestrator. Produces a
- * fully-wired `AssimilateDeps` whose seams call into the existing
- * client modules (remote-client HTTP, cubes.ts persistence, auth.ts
- * setup wizard, terminal-title helper).
- *
- * Test code never calls this — tests construct stub deps directly
- * (see `client/__tests__/assimilate-cmd.test.ts:makeStubDeps`).
- */
-import { spawnSync, spawn as spawnChild } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { hostname as osHostname } from 'node:os';
-import { createInterface } from 'node:readline/promises';
-import { API_URL, getValidToken, listCubes as remoteListCubes, getCube as remoteGetCube, createCube as remoteCreateCube, assimilate as remoteAssimilate, listTemplates as remoteListTemplates, } from './remote-client.js';
-import { findProjectRoot as cubesFindProjectRoot, getActiveCube as cubesGetActive, setActiveCube as cubesSetActive, inboxPathForDrone, setCodexWakeTarget, } from './cubes.js';
-import { authenticateWithGoogle } from './auth.js';
-import { setTerminalTitle as setTitle } from './terminal-title.js';
-import { defaultCliChoiceDeps, resolveCliChoice } from './cli-platform.js';
-import { prepareCodexRemoteLaunch, defaultCodexRemoteDeps } from './codex-remote.js';
-import { findLoadedCodexThread } from './codex-app-server.js';
-export function buildDefaultAssimilateDeps() {
-    return {
-        runSync: (cmd, args, cwd) => {
-            const r = spawnSync(cmd, args, { cwd, encoding: 'utf-8' });
-            return {
-                status: r.status,
-                stdout: r.stdout ?? '',
-                stderr: r.stderr ?? '',
-            };
-        },
-        pathExists: (p) => existsSync(p),
-        cwd: () => process.cwd(),
-        chdir: (p) => process.chdir(p),
-        exec: (cmd, args, cwd, env) => new Promise((resolveExit, rejectExit) => {
-            const child = spawnChild(cmd, args, {
-                cwd,
-                stdio: 'inherit',
-                shell: false,
-                env: env ? { ...process.env, ...env } : process.env,
-            });
-            child.on('error', rejectExit);
-            child.on('exit', (code) => resolveExit(code ?? 0));
-        }),
-        stderr: (line) => process.stderr.write(line),
-        stdout: (line) => process.stdout.write(line),
-        prompt: async (message) => {
-            const rl = createInterface({ input: process.stdin, output: process.stdout });
-            try {
-                return await rl.question(message);
-            }
-            finally {
-                rl.close();
-            }
-        },
-        isTTY: () => process.stdin.isTTY === true,
-        getHostname: () => osHostname(),
-        setTerminalTitle: (label, cubeName) => {
-            setTitle({ label, cubeName }, cubeName);
-        },
-        getActiveCube: () => cubesGetActive(),
-        setActiveCube: (a) => cubesSetActive(a),
-        findProjectRoot: (cwd) => cubesFindProjectRoot(cwd),
-        getCachedAuth: async () => {
-            try {
-                const token = await getValidToken();
-                return { token, apiUrl: API_URL };
-            }
-            catch {
-                return null;
-            }
-        },
-        runSetup: async () => {
-            await authenticateWithGoogle();
-            const token = await getValidToken();
-            return { token, apiUrl: API_URL };
-        },
-        listCubes: async (_apiUrl, _token) => {
-            const { cubes } = await remoteListCubes();
-            return cubes.map((c) => ({ id: c.id, name: c.name }));
-        },
-        getCube: async (_apiUrl, _token, cubeId) => {
-            // BUG-2 fix (v0.9.2): remote-client now unwraps the server's
-            // `{cube, roles, drones}` shape, so the returned object is
-            // already flat with id/name/roles at the top level.
-            const cube = await remoteGetCube(cubeId);
-            return { id: cube.id, name: cube.name, roles: cube.roles };
-        },
-        createCube: async (_apiUrl, _token, params) => {
-            const cube = await remoteCreateCube(params.name, '', params.template ? { template: params.template } : undefined);
-            return { id: cube.id, name: cube.name, roles: cube.roles };
-        },
-        assimilate: async (_apiUrl, _token, params) => {
-            const result = await remoteAssimilate({ cube_id: params.cube_id, role_id: params.role_id }, undefined, params.hostname ?? null);
-            return {
-                cube_id: result.cube.id,
-                drone_id: result.drone.id,
-                drone_label: result.drone.label,
-                session_token: result.sessionToken,
-                role_id: result.role.id,
-            };
-        },
-        listTemplates: async (_apiUrl, _token) => {
-            const { templates } = await remoteListTemplates();
-            return templates.map((t) => ({ name: t.name, description: t.description }));
-        },
-        // CR-PE-F1 wiring (Phase E merge brought this seam in): compute the
-        // inbox file path used by the borg-inbox-monitor command in step 8
-        // kickoff. Pure helper from cubes.ts; same computation claude.ts uses.
-        getInboxPath: (cubeId, droneId) => inboxPathForDrone(cubeId, droneId),
-        // BUG-5 / v0.9.3 wiring: spawn `borg-mcp` as a stdio child, send
-        // an initialize request, await a response (or timeout), then kill
-        // the child. Probe success indicates the MCP server starts cleanly
-        // and tools/list is reachable; failure means the launched Claude
-        // session will hit the race and need the kickoff prompt's
-        // ToolSearch recovery clause.
-        probeMcpReady: () => new Promise((resolveProbe) => {
-            const child = spawnChild('borg-mcp', [], { stdio: ['pipe', 'pipe', 'pipe'], shell: false });
-            let buffer = '';
-            let settled = false;
-            const settle = (result) => {
-                if (settled)
-                    return;
-                settled = true;
-                try {
-                    child.kill('SIGTERM');
-                }
-                catch { /* ignore */ }
-                resolveProbe(result);
-            };
-            const timeout = setTimeout(() => settle(false), 2000);
-            child.on('error', () => { clearTimeout(timeout); settle(false); });
-            child.on('exit', () => { clearTimeout(timeout); settle(settled); });
-            child.stdout?.on('data', (chunk) => {
-                buffer += chunk.toString('utf-8');
-                // initialize response contains "result" with "protocolVersion"
-                // and "capabilities". Light parse: line-buffered JSON-RPC.
-                for (const line of buffer.split('\n')) {
-                    if (line.includes('"protocolVersion"') && line.includes('"result"')) {
-                        clearTimeout(timeout);
-                        settle(true);
-                        return;
-                    }
-                }
-            });
-            const initReq = JSON.stringify({
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'initialize',
-                params: {
-                    protocolVersion: '2024-11-05',
-                    capabilities: {},
-                    clientInfo: { name: 'borg-assimilate-probe', version: '0.9.3' },
-                },
-            });
-            try {
-                child.stdin?.write(initReq + '\n');
-            }
-            catch {
-                clearTimeout(timeout);
-                settle(false);
-            }
-        }),
-        resolveCli: (explicit) => resolveCliChoice(explicit, defaultCliChoiceDeps(async (message) => {
-            const rl = createInterface({ input: process.stdin, output: process.stdout });
-            try {
-                return await rl.question(message);
-            }
-            finally {
-                rl.close();
-            }
-        }, () => process.stdin.isTTY === true)),
-        prepareCodexRemoteLaunch: () => prepareCodexRemoteLaunch(defaultCodexRemoteDeps()),
-        setCodexWakeTarget,
-        findLoadedCodexThread,
-    };
-}
-//# sourceMappingURL=assimilate-deps.js.map
+import{spawnSync as m,spawn as l}from"node:child_process";import{existsSync as f}from"node:fs";import{hostname as b}from"node:os";import{createInterface as u}from"node:readline/promises";import{API_URL as d,getValidToken as p,listCubes as h,getCube as C,createCube as T,assimilate as y,listTemplates as w}from"./remote-client.js";import{findProjectRoot as _,getActiveCube as g,setActiveCube as k,inboxPathForDrone as x,setCodexWakeTarget as v}from"./cubes.js";import{authenticateWithGoogle as A}from"./auth.js";import{setTerminalTitle as R}from"./terminal-title.js";import{defaultCliChoiceDeps as P,resolveCliChoice as S}from"./cli-platform.js";import{prepareCodexRemoteLaunch as U,defaultCodexRemoteDeps as L}from"./codex-remote.js";import{findLoadedCodexThread as D}from"./codex-app-server.js";function z(){return{runSync:(e,s,o)=>{const t=m(e,s,{cwd:o,encoding:"utf-8"});return{status:t.status,stdout:t.stdout??"",stderr:t.stderr??""}},pathExists:e=>f(e),cwd:()=>process.cwd(),chdir:e=>process.chdir(e),exec:(e,s,o,t)=>new Promise((r,i)=>{const a=l(e,s,{cwd:o,stdio:"inherit",shell:!1,env:t?{...process.env,...t}:process.env});a.on("error",i),a.on("exit",n=>r(n??0))}),stderr:e=>process.stderr.write(e),stdout:e=>process.stdout.write(e),prompt:async e=>{const s=u({input:process.stdin,output:process.stdout});try{return await s.question(e)}finally{s.close()}},isTTY:()=>process.stdin.isTTY===!0,getHostname:()=>b(),setTerminalTitle:(e,s)=>{R({label:e,cubeName:s},s)},getActiveCube:()=>g(),setActiveCube:e=>k(e),findProjectRoot:e=>_(e),getCachedAuth:async()=>{try{return{token:await p(),apiUrl:d}}catch{return null}},runSetup:async()=>(await A(),{token:await p(),apiUrl:d}),listCubes:async(e,s)=>{const{cubes:o}=await h();return o.map(t=>({id:t.id,name:t.name}))},getCube:async(e,s,o)=>{const t=await C(o);return{id:t.id,name:t.name,roles:t.roles}},createCube:async(e,s,o)=>{const t=await T(o.name,"",o.template?{template:o.template}:void 0);return{id:t.id,name:t.name,roles:t.roles}},assimilate:async(e,s,o)=>{const t=await y({cube_id:o.cube_id,role_id:o.role_id},void 0,o.hostname??null);return{cube_id:t.cube.id,drone_id:t.drone.id,drone_label:t.drone.label,session_token:t.sessionToken,role_id:t.role.id}},listTemplates:async(e,s)=>{const{templates:o}=await w();return o.map(t=>({name:t.name,description:t.description}))},getInboxPath:(e,s)=>x(e,s),probeMcpReady:()=>new Promise(e=>{const s=l("borg-mcp",[],{stdio:["pipe","pipe","pipe"],shell:!1});let o="",t=!1;const r=n=>{if(!t){t=!0;try{s.kill("SIGTERM")}catch{}e(n)}},i=setTimeout(()=>r(!1),2e3);s.on("error",()=>{clearTimeout(i),r(!1)}),s.on("exit",()=>{clearTimeout(i),r(t)}),s.stdout?.on("data",n=>{o+=n.toString("utf-8");for(const c of o.split(`
+`))if(c.includes('"protocolVersion"')&&c.includes('"result"')){clearTimeout(i),r(!0);return}});const a=JSON.stringify({jsonrpc:"2.0",id:1,method:"initialize",params:{protocolVersion:"2024-11-05",capabilities:{},clientInfo:{name:"borg-assimilate-probe",version:"0.9.3"}}});try{s.stdin?.write(a+`
+`)}catch{clearTimeout(i),r(!1)}}),resolveCli:e=>S(e,P(async s=>{const o=u({input:process.stdin,output:process.stdout});try{return await o.question(s)}finally{o.close()}},()=>process.stdin.isTTY===!0)),prepareCodexRemoteLaunch:()=>U(L()),setCodexWakeTarget:v,findLoadedCodexThread:D}}export{z as buildDefaultAssimilateDeps};

package/dist/assimilate-welcome.js

@@ -1,24 +1,2 @@
-// Pedagogical hint rendered to stdout immediately after assimilation
-// completes, before Claude Code launches. The cube-agnostic shape points
-// the user at borg:role / borg:cube / borg:roster / borg:regen /
-// borg:read-log rather than embedding role-specific text — so cubes
-// using non-default templates (writers-room, ops, etc.) render
-// identically to software-dev cubes.
-//
-// Color: ANSI green on the ✓ glyph only; gated on the caller's useColor
-// boolean (computed from process.stdout.isTTY && !NO_COLOR && !CI in the
-// assimilate-cmd call site). Body text carries no ANSI by design — color
-// is hierarchy-cueing, not decoration.
-const GREEN = '\x1b[32m';
-const RESET = '\x1b[0m';
-export function renderAssimilationWelcome(roleName, cubeName, useColor) {
-    const check = useColor ? `${GREEN}✓${RESET}` : '✓';
-    return [
-        `${check} Joined as \`${roleName}\` in cube \`${cubeName}\`.`,
-        ``,
-        `Next: run \`borg:regen\` inside Claude to see your cube.`,
-        `You're set up — your team can now see you in the cube.`,
-        ``,
-    ].join('\n');
-}
-//# sourceMappingURL=assimilate-welcome.js.map
+const c="\x1B[32m",t="\x1B[0m";function r(e,n,o){return[`${o?`${c}\u2713${t}`:"\u2713"} Joined as \`${e}\` in cube \`${n}\`.`,"","Next: run `borg:regen` inside Claude to see your cube.","You're set up \u2014 your team can now see you in the cube.",""].join(`
+`)}export{r as renderAssimilationWelcome};

package/dist/auth-env.js

@@ -1,107 +1 @@
-/**
- * gh#557 — environment / capability detection for remote-terminal auth.
- *
- * The default OAuth path (auth.ts) opens a browser and listens on a
- * localhost-loopback callback server. Both assumptions break on a remote
- * terminal: there's no browser to open, and the loopback URL Google would
- * redirect to is unreachable from the user's actual browser on another
- * machine. These pure helpers decide when to fall back to the RFC 8628
- * device-grant flow (no browser) and when the OS keychain is unavailable
- * (so a keychain-less token store must be used instead).
- *
- * Kept free of side effects (env + platform are injected) so the decision
- * logic is unit-testable without a real display / SSH session / keychain.
- */
-import { AsyncEntry } from '@napi-rs/keyring';
-/**
- * A BORG_* toggle is "on" only when present and not one of the falsy
- * spellings. Mirrors how the rest of the client reads boolean env vars:
- * an unset var and the explicit "0"/"false"/"" spellings are all off.
- */
-function envToggleOn(value) {
-    if (value === undefined)
-        return false;
-    const v = value.trim().toLowerCase();
-    return v !== '' && v !== '0' && v !== 'false' && v !== 'no';
-}
-/**
- * Decide whether the current environment lacks a usable local browser, so
- * the loopback OAuth flow can't work and the device-grant flow should be
- * used instead.
- *
- * Decision order (first match wins):
- *  1. BORG_FORCE_BROWSER on  → false  (escape hatch: operator has an
- *     SSH-forwarded / X-forwarded browser and wants the loopback flow)
- *  2. BORG_NO_BROWSER on     → true   (explicit opt-in to device flow)
- *  3. SSH session            → true   (remote terminal — even on a Mac the
- *     browser that opens is on the *server*, unreachable to the user)
- *  4. container marker        → true  (headless by construction)
- *  5. Linux without any display (no DISPLAY, no WAYLAND_DISPLAY) → true
- *  6. otherwise              → false  (desktop macOS/Windows, or Linux with
- *     a display — the loopback flow works)
- *
- * The `--no-browser` / `--device` CLI flag is surfaced by the caller as
- * BORG_NO_BROWSER (or by passing an env with it set) so there's a single
- * decision funnel.
- */
-export function isNoBrowserEnv(probe) {
-    const env = probe?.env ?? process.env;
-    const platform = probe?.platform ?? process.platform;
-    // 1. Explicit force-browser escape hatch wins over every no-browser signal.
-    if (envToggleOn(env.BORG_FORCE_BROWSER))
-        return false;
-    // 2. Explicit opt-in to the no-browser/device flow.
-    if (envToggleOn(env.BORG_NO_BROWSER))
-        return true;
-    // 3. SSH session — the terminal is remote, so any browser we open is on
-    //    the far end and the loopback redirect is unreachable to the user.
-    if (env.SSH_TTY || env.SSH_CONNECTION || env.SSH_CLIENT)
-        return true;
-    // 4. Container (systemd/Docker/podman set `container=`); headless by build.
-    if (env.container)
-        return true;
-    // 5. Headless Linux: no X11 and no Wayland display = no browser to open.
-    if (platform === 'linux' && !env.DISPLAY && !env.WAYLAND_DISPLAY)
-        return true;
-    // 6. Desktop (macOS/Windows) or Linux-with-display: loopback flow is fine.
-    return false;
-}
-/**
- * The probe round-trip used to decide whether the OS keychain is usable.
- * Performs a real set/get/delete against a throwaway account so a missing
- * Secret Service (headless Linux), a locked keychain, or any other backend
- * failure surfaces as a thrown error rather than a later mid-auth crash.
- */
-async function defaultKeyringRoundTrip() {
-    const PROBE_SERVICE = 'borg-mcp';
-    const PROBE_ACCOUNT = '__borg_keyring_probe__';
-    const entry = new AsyncEntry(PROBE_SERVICE, PROBE_ACCOUNT);
-    await entry.setPassword('probe');
-    await entry.getPassword();
-    // Best-effort cleanup; a failed delete still proves the keychain works.
-    try {
-        await entry.deletePassword();
-    }
-    catch {
-        /* leave the probe entry — its presence is harmless */
-    }
-}
-/**
- * Returns true when the OS keychain can be written to and read from. The
- * round-trip is injectable so callers/tests can supply a deterministic
- * probe; in production the default probe touches the real keychain.
- *
- * Any thrown error from the probe (no Secret Service, locked keychain,
- * permission denial) is treated as "unavailable" — the caller then selects
- * the encrypted-file fallback store.
- */
-export async function isKeyringAvailable(roundTrip = defaultKeyringRoundTrip) {
-    try {
-        await roundTrip();
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-//# sourceMappingURL=auth-env.js.map
+import{AsyncEntry as o}from"@napi-rs/keyring";function n(t){if(t===void 0)return!1;const r=t.trim().toLowerCase();return r!==""&&r!=="0"&&r!=="false"&&r!=="no"}function i(t){const r=t?.env??process.env,e=t?.platform??process.platform;return n(r.BORG_FORCE_BROWSER)?!1:!!(n(r.BORG_NO_BROWSER)||r.SSH_TTY||r.SSH_CONNECTION||r.SSH_CLIENT||r.container||e==="linux"&&!r.DISPLAY&&!r.WAYLAND_DISPLAY)}async function s(){const t="borg-mcp",r="__borg_keyring_probe__",e=new o(t,r);await e.setPassword("probe"),await e.getPassword();try{await e.deletePassword()}catch{}}async function u(t=s){try{return await t(),!0}catch{return!1}}export{u as isKeyringAvailable,i as isNoBrowserEnv};