borgmcp 1.0.6 → 1.0.8

package/dist/debug.js

@@ -1,71 +1 @@
-/**
- * Opt-in debug logging for the borg CLI (Queen observability ask — surface
- * exactly what failed on errors like the cross-account assimilate 404).
- *
- * Enabled by `--debug` on the command line OR a truthy `BORG_DEBUG` env var,
- * wired at the CLI entry points (top-level `borg` dispatcher + `borg setup`
- * + `borg assimilate`). When on, `authedFetch` (remote-client.ts) emits one
- * line per HTTP request + the server error body on failure.
- *
- * Output goes to STDERR with a `[borg:debug]` prefix so it never contaminates
- * STDOUT (the MCP / tool output stream a drone session proxies).
- *
- * HARD INVARIANT: debug output must NEVER contain token material — no
- * Authorization header, id_token, or refresh_token. Call sites log only
- * method / path / status / server-error-body; the Bearer token is omitted.
- */
-let debugEnabled = false;
-/** Enable or disable debug logging for the lifetime of the process. */
-export function setDebug(on) {
-    debugEnabled = on;
-}
-/** Whether debug logging is currently enabled. */
-export function isDebug() {
-    return debugEnabled;
-}
-/**
- * Emit a debug line to STDERR with the `[borg:debug]` prefix. No-op when
- * debug is disabled, so call sites need not guard. STDOUT is left clean for
- * MCP / tool output.
- */
-export function debugLog(...args) {
-    if (!debugEnabled)
-        return;
-    if (args.length > 0 && typeof args[0] === 'string') {
-        console.error(`[borg:debug] ${args[0]}`, ...args.slice(1));
-    }
-    else {
-        console.error('[borg:debug]', ...args);
-    }
-}
-/**
- * Resolve debug state from a process argv array + `BORG_DEBUG` at a CLI entry
- * point. Enables debug when `--debug` is present OR `BORG_DEBUG` is truthy,
- * then STRIPS every `--debug` token from the array IN PLACE so downstream
- * subcommand parsers (which reject unknown flags) never see it. Idempotent —
- * safe to call from more than one entry point in the same process.
- */
-export function initDebugFromArgv(argv) {
-    const hasFlag = argv.includes('--debug');
-    if (hasFlag || isTruthyEnv(process.env.BORG_DEBUG)) {
-        setDebug(true);
-    }
-    if (hasFlag) {
-        for (let i = argv.length - 1; i >= 0; i -= 1) {
-            if (argv[i] === '--debug')
-                argv.splice(i, 1);
-        }
-    }
-}
-/** A non-empty env value other than the common falsy spellings is truthy. */
-function isTruthyEnv(value) {
-    if (!value)
-        return false;
-    const v = value.trim().toLowerCase();
-    return v !== '' && v !== '0' && v !== 'false' && v !== 'no' && v !== 'off';
-}
-/** Test hook: reset module-level debug state between tests. */
-export function _resetDebugForTests() {
-    debugEnabled = false;
-}
-//# sourceMappingURL=debug.js.map
+let n=!1;function r(e){n=e}function u(){return n}function f(...e){n&&(e.length>0&&typeof e[0]=="string"?console.error(`[borg:debug] ${e[0]}`,...e.slice(1)):console.error("[borg:debug]",...e))}function s(e){const o=e.includes("--debug");if((o||i(process.env.BORG_DEBUG))&&r(!0),o)for(let t=e.length-1;t>=0;t-=1)e[t]==="--debug"&&e.splice(t,1)}function i(e){if(!e)return!1;const o=e.trim().toLowerCase();return o!==""&&o!=="0"&&o!=="false"&&o!=="no"&&o!=="off"}function l(){n=!1}export{l as _resetDebugForTests,f as debugLog,s as initDebugFromArgv,u as isDebug,r as setDebug};

package/dist/device-auth.js

@@ -1,167 +1 @@
-/**
- * gh#557 — Google OAuth 2.0 Device Authorization Grant (RFC 8628).
- *
- * The no-browser counterpart to the loopback flow in auth.ts. Instead of
- * opening a browser and listening on localhost, the device flow:
- *   1. asks Google for a device_code + a short human-typable user_code,
- *   2. prints a verification URL + the user_code for the human to open on
- *      ANY device (their phone, a laptop with a browser), and
- *   3. polls Google's token endpoint until the human authorizes (or the
- *      code expires / is denied).
- *
- * This module is decoupled from the live Google client: `fetch`, `sleep`,
- * and `now` are injected, and the client_id / client_secret / endpoints
- * come from the caller. The live device flow needs a Google OAuth client
- * of type "TVs & Limited Input devices" (a separate GOOGLE_DEVICE_CLIENT_ID
- * — Desktop/loopback clients reject /device/code with invalid_client); the
- * wiring layer supplies those credentials. Everything here is unit-tested
- * against a mocked Google.
- */
-const GOOGLE_DEVICE_CODE_URL = 'https://oauth2.googleapis.com/device/code';
-const GOOGLE_TOKEN_URL = 'https://oauth2.googleapis.com/token';
-const DEVICE_GRANT_TYPE = 'urn:ietf:params:oauth:grant-type:device_code';
-const DEFAULT_INTERVAL_SECONDS = 5;
-const SLOW_DOWN_INCREMENT_SECONDS = 5;
-/**
- * Failure of the device-grant flow. `code` is Google's OAuth error code
- * where one exists (`access_denied`, `expired_token`, `invalid_client`,
- * `slow_down`, `authorization_pending`) or a synthetic code for
- * transport/shape failures (`device_code_request_failed`,
- * `device_token_request_failed`, `malformed_token_response`).
- *
- * Token material is never placed in the message — only Google's error
- * code + description, mirroring RefreshTokenInvalidError's discipline.
- */
-export class DeviceAuthError extends Error {
-    code;
-    constructor(code, message) {
-        super(message ?? code);
-        this.code = code;
-        this.name = 'DeviceAuthError';
-    }
-}
-/**
- * Step 1 — request a device_code + user_code from Google.
- */
-export async function requestDeviceCode(config, deps) {
-    const url = config.deviceCodeUrl ?? GOOGLE_DEVICE_CODE_URL;
-    let response;
-    try {
-        response = await deps.fetch(url, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-            body: new URLSearchParams({
-                client_id: config.clientId,
-                scope: config.scopes.join(' '),
-            }),
-        });
-    }
-    catch (err) {
-        throw new DeviceAuthError('device_code_request_failed', `Could not reach Google device endpoint: ${err?.message ?? 'unknown'}`);
-    }
-    if (!response.ok) {
-        const code = await readErrorCode(response);
-        throw new DeviceAuthError(code ?? 'device_code_request_failed', `Device-code request failed (HTTP ${response.status}${code ? `, ${code}` : ''})`);
-    }
-    let data;
-    try {
-        data = (await response.json());
-    }
-    catch {
-        throw new DeviceAuthError('malformed_token_response', 'Device-code response was not JSON');
-    }
-    if (!data.device_code || !data.user_code || !data.verification_url) {
-        throw new DeviceAuthError('malformed_token_response', 'Device-code response missing device_code/user_code/verification_url');
-    }
-    return {
-        device_code: data.device_code,
-        user_code: data.user_code,
-        verification_url: data.verification_url,
-        expires_in: typeof data.expires_in === 'number' ? data.expires_in : 1800,
-        interval: typeof data.interval === 'number' ? data.interval : DEFAULT_INTERVAL_SECONDS,
-    };
-}
-/**
- * Step 2 — poll Google's token endpoint until the user authorizes the
- * device_code, honoring the RFC 8628 poll semantics.
- *
- * Sleeps `interval` BEFORE each poll (never hammers immediately). A local
- * deadline derived from `expires_in` bounds the loop so a code the user
- * abandons can't poll forever even if Google never returns expired_token.
- */
-export async function pollForDeviceToken(deviceCode, config, deps) {
-    const tokenUrl = config.tokenUrl ?? GOOGLE_TOKEN_URL;
-    const now = deps.now ?? Date.now;
-    const deadline = now() + deviceCode.expires_in * 1000;
-    let intervalSeconds = deviceCode.interval > 0 ? deviceCode.interval : DEFAULT_INTERVAL_SECONDS;
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        if (now() >= deadline) {
-            throw new DeviceAuthError('expired_token', 'Device code expired before the authorization was completed');
-        }
-        await deps.sleep(intervalSeconds * 1000);
-        let response;
-        try {
-            response = await deps.fetch(tokenUrl, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-                body: new URLSearchParams({
-                    client_id: config.clientId,
-                    ...(config.clientSecret ? { client_secret: config.clientSecret } : {}),
-                    device_code: deviceCode.device_code,
-                    grant_type: DEVICE_GRANT_TYPE,
-                }),
-            });
-        }
-        catch (err) {
-            throw new DeviceAuthError('device_token_request_failed', `Could not reach Google token endpoint: ${err?.message ?? 'unknown'}`);
-        }
-        if (response.ok) {
-            let data;
-            try {
-                data = (await response.json());
-            }
-            catch {
-                throw new DeviceAuthError('malformed_token_response', 'Token response was not JSON');
-            }
-            if (!data.id_token || typeof data.expires_in !== 'number') {
-                throw new DeviceAuthError('malformed_token_response', 'Token response missing id_token or expires_in');
-            }
-            return {
-                id_token: data.id_token,
-                refresh_token: data.refresh_token,
-                expires_in: data.expires_in,
-            };
-        }
-        const code = await readErrorCode(response);
-        switch (code) {
-            case 'authorization_pending':
-                // The user hasn't finished yet — keep polling at the same interval.
-                continue;
-            case 'slow_down':
-                // Google asks us to back off; RFC 8628 §3.5 → bump the interval.
-                intervalSeconds += SLOW_DOWN_INCREMENT_SECONDS;
-                continue;
-            case 'access_denied':
-                throw new DeviceAuthError('access_denied', 'Authorization was denied by the user');
-            case 'expired_token':
-                throw new DeviceAuthError('expired_token', 'Device code expired before authorization');
-            default:
-                throw new DeviceAuthError(code ?? 'device_token_request_failed', `Device token poll failed (HTTP ${response.status}${code ? `, ${code}` : ''})`);
-        }
-    }
-}
-/**
- * Extract Google's OAuth `error` code from a non-2xx response body without
- * throwing. Returns null when the body isn't JSON or has no error field.
- */
-async function readErrorCode(response) {
-    try {
-        const body = (await response.json());
-        return typeof body?.error === 'string' ? body.error : null;
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=device-auth.js.map
+const u="https://oauth2.googleapis.com/device/code",p="https://oauth2.googleapis.com/token",w="urn:ietf:params:oauth:grant-type:device_code",h=5,f=5;class n extends Error{code;constructor(o,i){super(i??o),this.code=o,this.name="DeviceAuthError"}}async function v(t,o){const i=t.deviceCodeUrl??u;let c;try{c=await o.fetch(i,{method:"POST",headers:{"Content-Type":"application/x-www-form-urlencoded"},body:new URLSearchParams({client_id:t.clientId,scope:t.scopes.join(" ")})})}catch(s){throw new n("device_code_request_failed",`Could not reach Google device endpoint: ${s?.message??"unknown"}`)}if(!c.ok){const s=await l(c);throw new n(s??"device_code_request_failed",`Device-code request failed (HTTP ${c.status}${s?`, ${s}`:""})`)}let e;try{e=await c.json()}catch{throw new n("malformed_token_response","Device-code response was not JSON")}if(!e.device_code||!e.user_code||!e.verification_url)throw new n("malformed_token_response","Device-code response missing device_code/user_code/verification_url");return{device_code:e.device_code,user_code:e.user_code,verification_url:e.verification_url,expires_in:typeof e.expires_in=="number"?e.expires_in:1800,interval:typeof e.interval=="number"?e.interval:5}}async function E(t,o,i){const c=o.tokenUrl??p,e=i.now??Date.now,s=e()+t.expires_in*1e3;let _=t.interval>0?t.interval:5;for(;;){if(e()>=s)throw new n("expired_token","Device code expired before the authorization was completed");await i.sleep(_*1e3);let a;try{a=await i.fetch(c,{method:"POST",headers:{"Content-Type":"application/x-www-form-urlencoded"},body:new URLSearchParams({client_id:o.clientId,...o.clientSecret?{client_secret:o.clientSecret}:{},device_code:t.device_code,grant_type:w})})}catch(r){throw new n("device_token_request_failed",`Could not reach Google token endpoint: ${r?.message??"unknown"}`)}if(a.ok){let r;try{r=await a.json()}catch{throw new n("malformed_token_response","Token response was not JSON")}if(!r.id_token||typeof r.expires_in!="number")throw new n("malformed_token_response","Token response missing id_token or expires_in");return{id_token:r.id_token,refresh_token:r.refresh_token,expires_in:r.expires_in}}const d=await l(a);switch(d){case"authorization_pending":continue;case"slow_down":_+=5;continue;case"access_denied":throw new n("access_denied","Authorization was denied by the user");case"expired_token":throw new n("expired_token","Device code expired before authorization");default:throw new n(d??"device_token_request_failed",`Device token poll failed (HTTP ${a.status}${d?`, ${d}`:""})`)}}}async function l(t){try{const o=await t.json();return typeof o?.error=="string"?o.error:null}catch{return null}}export{n as DeviceAuthError,E as pollForDeviceToken,v as requestDeviceCode};

package/dist/direct-log.js

@@ -1,11 +1 @@
-export function normalizeDirectLogRecipients(value) {
-    if (value == null)
-        return [];
-    const raw = Array.isArray(value) ? value : [value];
-    const recipients = raw
-        .filter((item) => typeof item === 'string')
-        .map((item) => item.trim())
-        .filter((item) => item.length > 0);
-    return [...new Set(recipients)];
-}
-//# sourceMappingURL=direct-log.js.map
+function e(t){if(t==null)return[];const i=(Array.isArray(t)?t:[t]).filter(r=>typeof r=="string").map(r=>r.trim()).filter(r=>r.length>0);return[...new Set(i)]}export{e as normalizeDirectLogRecipients};

package/dist/health-beat.js

@@ -1,168 +1 @@
-/**
- * gh#541 WU-2 — client health beat (the Part B "receipt watermark" producer).
- *
- * The MCP-client child process emits a periodic + event-driven health BEAT to
- * the server's `POST /api/drone/health` (WU-1). The beat reports:
- *   - `last_event_at`        — when this client last RECEIVED an inbound cube
- *                              event (the wake-path RECEIPT evidence). This is
- *                              produced BELOW the agent classifier (WU-0 proved
- *                              child-process HTTP is independent of the agent
- *                              tool-call path), so it stays fresh even during a
- *                              classifier outage and even when the agent /loop
- *                              never wakes — which is exactly what lets the
- *                              watchdog (WU-3) tell DEAF (Monitor down) apart
- *                              from POST-BLOCKED.
- *   - `sse_connected`        — the SSE wire state.
- *   - `inbox_monitor_armed`  — whether a tail-Monitor is watching the inbox.
- *
- * The beat carries NO token material in the body (auth is the X-Drone-Session
- * header, same as every other drone endpoint). It is strictly BEST-EFFORT: a
- * failed POST is swallowed and must never crash the SSE stream.
- *
- * Side-effecting deps (fetch, token, cube/status/monitor probes, clock) are
- * injected so the producer is unit-tested without real network/keychain/pgrep.
- */
-// ─── Module state (process-singleton, like the SSE stream state) ─────────
-let lastEventReceivedAt = null;
-// Cached monitor-health, refreshed by the ~60s tick so per-event beats don't
-// have to spawn pgrep on every inbound entry. `null` = unknown (treated as
-// armed by the payload mapping below).
-let cachedMonitorHealthy = null;
-// gh#633: cached transport-agnostic wake-armed (claude monitor OR codex bridge
-// liveness), refreshed by the ~60s tick so per-event beats reuse it without
-// re-probing. `null` = unknown (treated as armed by the payload mapping below).
-let cachedWakeArmed = null;
-/** Record that an inbound cube event was just received (the receipt evidence). */
-export function recordEventReceipt(now = new Date()) {
-    lastEventReceivedAt = now;
-}
-export function getLastEventReceivedAt() {
-    return lastEventReceivedAt;
-}
-export function getCachedMonitorHealthy() {
-    return cachedMonitorHealthy;
-}
-/** Cached transport-agnostic wake-armed (gh#633), for cheap per-event beats. */
-export function getCachedWakeArmed() {
-    return cachedWakeArmed;
-}
-/**
- * Reset module state. TEST-ONLY — the beat state is a process singleton in
- * normal operation; nothing in production code should call this.
- * @internal
- */
-export function __resetHealthBeatStateForTest() {
-    lastEventReceivedAt = null;
-    cachedMonitorHealthy = null;
-    cachedWakeArmed = null;
-}
-/**
- * Build the beat payload from the current receipt watermark + the supplied
- * wire/monitor state.
- *
- * `inbox_monitor_armed` maps the tri-state monitor probe to the boolean the
- * server schema requires: ONLY a POSITIVELY-broken probe (`false`) reports
- * `false`; both healthy (`true`) and unknown (`null`) report `true`. This
- * mirrors `shouldShowWakePathWarning` (which fires only on `=== false`) and is
- * the design's false-deaf-avoidance posture — an undeterminable probe must not
- * masquerade as a dead Monitor.
- */
-export function buildHealthPayload(sseConnected, inboxMonitorHealthy, wakeArmed, agentKind, hostname, version) {
-    return {
-        sse_connected: sseConnected,
-        inbox_monitor_armed: inboxMonitorHealthy !== false,
-        // gh#633: same false-deaf-avoidance map as inbox_monitor_armed — only a
-        // POSITIVELY-false probe reports false; healthy (true) and indeterminate
-        // (null) both report armed. Prevents a transient/undeterminable wake-path
-        // probe from masquerading as a dead wake path.
-        wake_armed: wakeArmed !== false,
-        // gh#634: live runtime agent_kind (caller passes resolveSessionAgentKind()).
-        agent_kind: agentKind,
-        hostname,
-        version,
-        last_event_at: lastEventReceivedAt ? lastEventReceivedAt.toISOString() : null,
-    };
-}
-/**
- * Best-effort POST of a beat. Swallows ALL errors (token fetch, network,
- * non-2xx) — a beat that can't be delivered must never propagate into the
- * stream loop. Body carries NO token material; auth is via headers.
- */
-export async function postHealthBeat(active, payload, deps) {
-    try {
-        const token = await deps.getToken();
-        await deps.fetchImpl(`${active.apiUrl}/api/drone/health`, {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${token}`,
-                'X-Drone-Session': active.sessionToken,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(payload),
-        });
-    }
-    catch {
-        // Best-effort: never crash the stream on a beat failure.
-    }
-}
-/** Build the current payload and post it (best-effort). */
-export async function emitHealthBeat(active, opts) {
-    const payload = buildHealthPayload(opts.sseConnected, opts.inboxMonitorHealthy, opts.wakeArmed, opts.agentKind, opts.hostname, opts.version);
-    await postHealthBeat(active, payload, opts);
-}
-/**
- * One tick of the periodic beat: resolve the active cube, probe the live
- * wire + Monitor state, cache the monitor result (so cheap per-event beats can
- * reuse it without re-spawning pgrep), and emit the beat. No active cube → no
- * beat. Best-effort: never throws.
- */
-export async function runHealthBeatOnce(deps) {
-    try {
-        const active = await deps.getActiveCube();
-        if (!active)
-            return;
-        const connected = deps.getStreamConnected();
-        const healthy = deps.checkMonitor(deps.getInboxPath(active));
-        cachedMonitorHealthy = healthy;
-        // gh#633: wake_armed = the running drone's OWN wake-transport health.
-        // codex (remote-wake) → app-server bridge liveness; claude → the same
-        // tail-F Monitor health (its wake path IS the Monitor). Transport-agnostic:
-        // HOP-2 reads one boolean, never branches on (mis-recordable) agent_kind.
-        const wakeArmed = deps.isCodexRemoteWake()
-            ? await deps.probeBridgeArmed(active)
-            : healthy;
-        cachedWakeArmed = wakeArmed;
-        // gh#634: live runtime agent_kind, beated every cycle to self-heal the
-        // recorded column (frozen at first-join; relaunch never re-assimilates).
-        const agentKind = deps.resolveAgentKind();
-        const hostname = deps.resolveHostname();
-        const version = deps.resolveVersion();
-        await emitHealthBeat(active, {
-            sseConnected: connected,
-            inboxMonitorHealthy: healthy,
-            wakeArmed,
-            agentKind,
-            hostname,
-            version,
-            fetchImpl: deps.fetchImpl,
-            getToken: deps.getToken,
-        });
-    }
-    catch {
-        // Best-effort tick: a probe/beat failure must not kill the interval.
-    }
-}
-/** Default periodic cadence for the health beat. */
-export const HEALTH_BEAT_INTERVAL_MS = 60_000;
-/**
- * Start the periodic beat. Fire-and-forget; the timer is `unref`'d so it never
- * keeps the process alive on its own. Returns the timer handle (tests clear it).
- */
-export function startHealthBeatTick(deps, intervalMs = HEALTH_BEAT_INTERVAL_MS) {
-    const handle = setInterval(() => {
-        void runHealthBeatOnce(deps);
-    }, intervalMs);
-    handle.unref?.();
-    return handle;
-}
-//# sourceMappingURL=health-beat.js.map
+let a=null,i=null,l=null;function x(e=new Date){a=e}function y(){return a}function k(){return i}function v(){return l}function A(){a=null,i=null,l=null}function u(e,t,n,o,r,c){return{sse_connected:e,inbox_monitor_armed:t!==!1,wake_armed:n!==!1,agent_kind:o,hostname:r,version:c,last_event_at:a?a.toISOString():null}}async function d(e,t,n){try{const o=await n.getToken();await n.fetchImpl(`${e.apiUrl}/api/drone/health`,{method:"POST",headers:{Authorization:`Bearer ${o}`,"X-Drone-Session":e.sessionToken,"Content-Type":"application/json"},body:JSON.stringify(t)})}catch{}}async function f(e,t){const n=u(t.sseConnected,t.inboxMonitorHealthy,t.wakeArmed,t.agentKind,t.hostname,t.version);await d(e,n,t)}async function m(e){try{const t=await e.getActiveCube();if(!t)return;const n=e.getStreamConnected(),o=e.checkMonitor(e.getInboxPath(t));i=o;const r=e.isCodexRemoteWake()?await e.probeBridgeArmed(t):o;l=r;const c=e.resolveAgentKind(),h=e.resolveHostname(),s=e.resolveVersion();await f(t,{sseConnected:n,inboxMonitorHealthy:o,wakeArmed:r,agentKind:c,hostname:h,version:s,fetchImpl:e.fetchImpl,getToken:e.getToken})}catch{}}const g=6e4;function H(e,t=g){const n=setInterval(()=>{m(e)},t);return n.unref?.(),n}export{g as HEALTH_BEAT_INTERVAL_MS,A as __resetHealthBeatStateForTest,u as buildHealthPayload,f as emitHealthBeat,k as getCachedMonitorHealthy,v as getCachedWakeArmed,y as getLastEventReceivedAt,d as postHealthBeat,x as recordEventReceipt,m as runHealthBeatOnce,H as startHealthBeatTick};

package/dist/inbox-monitor.js

@@ -1,130 +1,2 @@
 #!/usr/bin/env node
-/**
- * borg-inbox-monitor — per-entry pretty-printer for borgmcp inbox files.
- *
- * Per gh#8: Claude Code's task-notification title is the Monitor's
- * `description`, set once at arm-time. When the Monitor command is
- * `tail -F <inbox>`, every event's notification title is the same
- * static "Monitor event: ..." string regardless of which drone posted
- * what. Recipients have to read the body to triage.
- *
- * Replacement: tail the inbox file and emit one stdout line per cube
- * log entry, summarizing drone label + role + first ~80 chars of the
- * message body. Claude Code's Monitor batching then uses that single
- * line as the per-event task-notification title.
- *
- * Inbox file format (per client/src/log-stream.ts formatInboxLine):
- *   <iso-ts> <drone-label> (<role-name>): <message>
- *
- * Multi-line messages are appended as a single fs.appendFile() call
- * with embedded `\n` characters, so they become multiple physical
- * lines in the file. Continuation lines (those that don't start with
- * an ISO-8601 timestamp) are dropped — only the first line of each
- * entry surfaces, which is the part that summarizes the entry.
- *
- * Usage:
- *   borg-inbox-monitor <inbox-file-path>
- */
-import { spawn } from 'node:child_process';
-import { realpathSync } from 'node:fs';
-import { createInterface } from 'node:readline';
-import { fileURLToPath } from 'node:url';
-const ENTRY_LINE_RE = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\S*)\s+(\S+)\s+\(([^)]+)\):\s*(.*)$/;
-/**
- * Pure: parse one inbox-file line and produce the pretty summary line
- * (or null if the line is a continuation or unrecognized shape).
- *
- * Pass-through — no truncation. Claude Code does not impose a hard cap
- * on task-notification title length. The 200-char `MAX_SUMMARY_LEN` cap
- * removed here (and the 80-char predecessor) were borg-mcp conventions
- * built on a misunderstanding of the renderer's limits. Drones now see
- * the full first line of every entry; multi-signal batched posts no
- * longer have their second signal hidden.
- *
- * Exported so tests can exercise the parsing without spawning tail.
- */
-export function formatEventLine(inboxLine) {
-    const match = ENTRY_LINE_RE.exec(inboxLine);
-    if (!match)
-        return null;
-    const [, , label, role, body] = match;
-    const summary = body.trim();
-    return `${label} (${role}): ${summary}`;
-}
-function main() {
-    const inboxPath = process.argv[2];
-    if (!inboxPath) {
-        console.error('borg-inbox-monitor: usage: borg-inbox-monitor <inbox-path>');
-        process.exit(2);
-    }
-    // `tail -F` for rotation/truncation resilience on macOS + Linux.
-    // Node's fs.watch is unreliable across file rotation; subprocess
-    // tail matches the prior kickoff-Monitor shape (`tail -F`) so the
-    // wire behavior is identical — only the per-line projection changes.
-    // `-n 0` skips backfilling history so fresh sessions don't replay
-    // old entries on every restart.
-    const tail = spawn('tail', ['-F', '-n', '0', inboxPath], {
-        stdio: ['ignore', 'pipe', 'inherit'],
-    });
-    if (!tail.stdout) {
-        console.error('borg-inbox-monitor: tail subprocess has no stdout');
-        process.exit(1);
-    }
-    const rl = createInterface({ input: tail.stdout, crlfDelay: Infinity });
-    let shuttingDown = false;
-    rl.on('line', (line) => {
-        const pretty = formatEventLine(line);
-        if (pretty !== null) {
-            console.log(pretty);
-        }
-    });
-    tail.on('error', (err) => {
-        console.error(`borg-inbox-monitor: tail failed: ${err.message}`);
-        process.exit(1);
-    });
-    tail.on('exit', (code, signal) => {
-        if (shuttingDown)
-            process.exit(0);
-        if (signal)
-            process.exit(0);
-        process.exit(code ?? 0);
-    });
-    const shutdown = (signal) => {
-        if (shuttingDown)
-            return;
-        shuttingDown = true;
-        rl.close();
-        if (!tail.killed && !tail.kill(signal)) {
-            process.exit(0);
-        }
-        setTimeout(() => process.exit(0), 1000).unref();
-    };
-    process.once('SIGTERM', () => shutdown('SIGTERM'));
-    process.once('SIGINT', () => shutdown('SIGINT'));
-}
-/**
- * Is this module being invoked as the bin entry point?
- *
- * gh#114: under `npm install`, `process.argv[1]` is the npm-bin symlink
- * path while `fileURLToPath(import.meta.url)` is the realpath of the
- * installed file. A naive `===` check never matches → `main()` never
- * runs → the documented `borg-inbox-monitor` Monitor command silently
- * no-ops and drones go deaf without the wake-path-self-heal (gh#43)
- * triggering. Resolve the symlink before comparing.
- *
- * Exported for unit testing.
- */
-export function isEntryInvocation(argv1, importMetaUrl) {
-    try {
-        return realpathSync(argv1) === fileURLToPath(importMetaUrl);
-    }
-    catch {
-        return false;
-    }
-}
-// Only run main() when invoked as the bin entry — allow importing the
-// pure formatEventLine for unit testing without spawning tail.
-if (isEntryInvocation(process.argv[1], import.meta.url)) {
-    main();
-}
-//# sourceMappingURL=inbox-monitor.js.map
+import{spawn as c}from"node:child_process";import{realpathSync as l}from"node:fs";import{createInterface as a}from"node:readline";import{fileURLToPath as p}from"node:url";const f=/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\S*)\s+(\S+)\s+\(([^)]+)\):\s*(.*)$/;function u(r){const o=f.exec(r);if(!o)return null;const[,,n,e,i]=o,t=i.trim();return`${n} (${e}): ${t}`}function m(){const r=process.argv[2];r||(console.error("borg-inbox-monitor: usage: borg-inbox-monitor <inbox-path>"),process.exit(2));const o=c("tail",["-F","-n","0",r],{stdio:["ignore","pipe","inherit"]});o.stdout||(console.error("borg-inbox-monitor: tail subprocess has no stdout"),process.exit(1));const n=a({input:o.stdout,crlfDelay:1/0});let e=!1;n.on("line",t=>{const s=u(t);s!==null&&console.log(s)}),o.on("error",t=>{console.error(`borg-inbox-monitor: tail failed: ${t.message}`),process.exit(1)}),o.on("exit",(t,s)=>{e&&process.exit(0),s&&process.exit(0),process.exit(t??0)});const i=t=>{e||(e=!0,n.close(),!o.killed&&!o.kill(t)&&process.exit(0),setTimeout(()=>process.exit(0),1e3).unref())};process.once("SIGTERM",()=>i("SIGTERM")),process.once("SIGINT",()=>i("SIGINT"))}function x(r,o){try{return l(r)===p(o)}catch{return!1}}x(process.argv[1],import.meta.url)&&m();export{u as formatEventLine,x as isEntryInvocation};