@zeph-to/cli 1.13.2 → 1.15.0

package/dist/listener.js

@@ -25,7 +25,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleListener = exports.computeListenerDeviceId = exports.computeBackoff = exports.handlePush = exports.gcAttachments = exports.setAttachmentContext = exports.collectSessions = exports.collectSessionsVerbose = exports.detectClaudeSessionId = exports.parseSessionName = exports.invalidateTmuxSocketCache = exports.paneCurrentCommand = exports.checkRateLimit = exports.AUTH_FAILURE_CODES = void 0;
+exports.handleListener = exports.computeListenerDeviceId = exports.computeBackoff = exports.handlePush = exports.gcAttachments = exports.setAttachmentContext = exports.collectSessions = exports.collectSessionsVerbose = exports.handleScreenRequest = exports.collectWatchHits = exports.resetPatternWatches = exports.setPatternWatches = exports.deriveSessionState = exports.resetSessionStates = exports.detectRemoteAgent = exports.parseSessionName = exports.invalidateTmuxSocketCache = exports.paneCurrentCommand = exports.checkRateLimit = exports.AUTH_FAILURE_CODES = void 0;
 const child_process_1 = require("child_process");
 const crypto_1 = require("crypto");
 const fs_1 = require("fs");
@@ -33,6 +33,9 @@ const os_1 = require("os");
 const path_1 = require("path");
 const ws_1 = __importDefault(require("ws"));
 const config_js_1 = require("./config.js");
+const remote_agents_js_1 = require("./remote-agents.js");
+const agent_state_js_1 = require("./agent-state.js");
+const agent_rules_fetch_js_1 = require("./agent-rules-fetch.js");
 const PING_INTERVAL_MS = 25_000;
 const PONG_TIMEOUT_MS = 10_000;
 const RECONNECT_BASE_MS = 1_000;
@@ -54,7 +57,6 @@ const WS_STALL_TIMEOUT_MS = 90_000;
 // to reflect new `zeph cc` sessions within a few seconds, not half a
 // minute.
 const SESSION_REPORT_INTERVAL_MS = 5_000;
-const AGENT_KINDS = ['claude', 'codex', 'gemini'];
 // Per-session token bucket — caps a runaway/compromised sender. 30/min
 // is generous for human-driven phone use, tight enough to block flooding.
 const RATE_LIMIT_TOKENS = 30;
@@ -400,70 +402,6 @@ const parseSessionName = (name) => {
     return { project: rest, label: null };
 };
 exports.parseSessionName = parseSessionName;
-const CLAUDE_PROJECTS_DIR = (0, path_1.join)((0, os_1.homedir)(), '.claude', 'projects');
-/**
- * Cache for detectClaudeSessionId. The function walks every jsonl file
- * in `~/.claude/projects/<hash>/` on each call — after weeks of CC use
- * that directory holds hundreds of session files, and we were calling
- * this per tmux session per 5-second report cycle. Heavy disk I/O
- * compounded with multiple sessions caused the report cycle to spike
- * CPU and starve the host shell.
- *
- * The current-session UUID only changes when a new CC session starts
- * in that directory (rare, on the order of hours), so a 60-second TTL
- * is safe and cuts the per-cycle stat count by ~12×.
- */
-const claudeSessionCache = new Map();
-const CLAUDE_SESSION_CACHE_TTL_MS = 60_000;
-const doDetectClaudeSessionId = (cwd) => {
-    try {
-        const projectHash = cwd.replace(/\//g, '-');
-        const sessionsDir = (0, path_1.join)(CLAUDE_PROJECTS_DIR, projectHash);
-        let latest;
-        for (const entry of (0, fs_1.readdirSync)(sessionsDir)) {
-            const m = entry.match(/^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/);
-            if (!m)
-                continue;
-            const stat = (0, fs_1.statSync)((0, path_1.join)(sessionsDir, entry));
-            if (!stat.isFile())
-                continue;
-            if (!latest || stat.mtimeMs > latest.mtime) {
-                latest = { name: m[1], mtime: stat.mtimeMs };
-            }
-        }
-        return latest?.name ?? null;
-    }
-    catch {
-        return null;
-    }
-};
-/**
- * Locate the most recent Claude Code session UUID for the working
- * directory of a tmux pane. Mirrors `mcp-server/config.ts`'s
- * detectClaudeSessionId: CC writes per-session jsonl files at
- * `~/.claude/projects/<projectHash>/<UUID>.jsonl` where the hash is
- * the cwd with `/` replaced by `-`. Cached for 60s — see
- * claudeSessionCache.
- */
-const detectClaudeSessionId = (cwd) => {
-    const now = Date.now();
-    const cached = claudeSessionCache.get(cwd);
-    if (cached && cached.expiresAt > now)
-        return cached.sessionId;
-    // Cap cache size so a long-lived listener that's seen many cwds
-    // doesn't grow unbounded. 64 is plenty for any realistic setup.
-    if (claudeSessionCache.size >= 64) {
-        // Evict the oldest-expiring entry — Map iteration order is
-        // insertion order, so the first key we hit is the oldest.
-        const firstKey = claudeSessionCache.keys().next().value;
-        if (firstKey !== undefined)
-            claudeSessionCache.delete(firstKey);
-    }
-    const sessionId = doDetectClaudeSessionId(cwd);
-    claudeSessionCache.set(cwd, { sessionId, expiresAt: now + CLAUDE_SESSION_CACHE_TTL_MS });
-    return sessionId;
-};
-exports.detectClaudeSessionId = detectClaudeSessionId;
 // U+241F "Symbol for Unit Separator" — a *printable* Unicode glyph
 // (3-byte UTF-8) that visually represents the C0 Unit Separator but is
 // itself a normal character. Critical detail: tmux 3.5a's `-F` format
@@ -509,28 +447,19 @@ const firstTokenBasename = (cmd) => {
     return (0, path_1.basename)(stripped.split(/\s+/)[0] || '');
 };
 /**
- * Identify the agent type from the tmux pane. Prefer `pane_start_command`
+ * Identify the agent from the tmux pane. Prefer `pane_start_command`
  * because the foreground process is usually `node`/`python3` (the
  * interpreter), which doesn't tell us *what* was launched. Fall back to
  * `pane_current_command` when start_command is empty — tmux clears
  * start_command in some re-attach cases, especially when a pre-existing
  * session was joined via `tmux new -A` instead of being created fresh.
- * That fallback is safe because we only accept literal `claude` /
- * `codex` / `gemini` as a match.
+ * That fallback is safe because only the literal binaries registered in
+ * remote-agents.ts are accepted as a match.
  */
-const detectAgentKind = (info) => {
-    const startBase = firstTokenBasename(info.startCommand);
-    for (const k of AGENT_KINDS) {
-        if (startBase === k)
-            return k;
-    }
-    const currentBase = firstTokenBasename(info.currentCommand);
-    for (const k of AGENT_KINDS) {
-        if (currentBase === k)
-            return k;
-    }
-    return null;
-};
+const detectRemoteAgent = (info) => (0, remote_agents_js_1.matchAgentByPaneCommand)(firstTokenBasename(info.startCommand))
+    ?? (0, remote_agents_js_1.matchAgentByPaneCommand)(firstTokenBasename(info.currentCommand))
+    ?? null;
+exports.detectRemoteAgent = detectRemoteAgent;
 const epochToIso = (epoch) => {
     if (!epoch)
         return undefined;
@@ -539,6 +468,166 @@ const epochToIso = (epoch) => {
         return undefined;
     return new Date(n * 1000).toISOString();
 };
+// ─── Agent state detection (SPEC-AGENT-AWARENESS §S1) ──────────────
+// How many pane lines the state rules see. The live status area every
+// agent renders sits in the last handful of lines; 40 leaves margin for
+// tall dialogs without hauling whole scrollbacks through regex.
+const STATE_CAPTURE_LINES = 40;
+const sessionStates = new Map();
+/** Test hook. */
+const resetSessionStates = () => {
+    sessionStates.clear();
+};
+exports.resetSessionStates = resetSessionStates;
+const capturePaneText = (session) => {
+    const r = (0, child_process_1.spawnSync)('tmux', tmuxArgs(['capture-pane', '-p', '-t', session, '-S', `-${STATE_CAPTURE_LINES}`]), {
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (r.status !== 0)
+        return null;
+    return r.stdout ?? '';
+};
+/**
+ * Fold one pane capture into the per-session state machine and return
+ * the wire fields for this report cycle. Exported (with `paneText`
+ * injected) so tests can drive it without tmux.
+ *
+ * Hash short-circuit: an unchanged screen skips rule evaluation but
+ * still replays the previous observation through the debounce — cheap
+ * cycles stay cheap without wedging candidate promotion.
+ */
+const deriveSessionState = (name, agentKind, paneText, now = Date.now()) => {
+    if (paneText === null) {
+        // Pane unreadable this cycle (session racing shutdown, tmux
+        // hiccup) — report nothing rather than a stale confident state.
+        sessionStates.delete(name);
+        return {};
+    }
+    const contentHash = (0, crypto_1.createHash)('sha1').update(paneText).digest('hex');
+    const entry = sessionStates.get(name);
+    const observed = entry && entry.contentHash === contentHash
+        ? entry.lastObserved
+        : (0, agent_state_js_1.evaluateState)(paneText, agentKind, (0, agent_rules_fetch_js_1.getActiveManifest)(), entry?.tracker.confirmed ?? 'unknown');
+    const tracker = (0, agent_state_js_1.advanceState)(entry?.tracker, observed, now);
+    sessionStates.set(name, { tracker, lastObserved: observed, contentHash });
+    return {
+        state: tracker.confirmed,
+        stateChangedAt: new Date(tracker.confirmedAt).toISOString(),
+        stateRuleId: tracker.ruleId,
+    };
+};
+exports.deriveSessionState = deriveSessionState;
+/** Drop trackers for sessions gone from the inventory. */
+const pruneSessionStates = (liveNames) => {
+    for (const name of sessionStates.keys()) {
+        if (!liveNames.has(name))
+            sessionStates.delete(name);
+    }
+};
+let patternWatches = [];
+// One-shot: after a hit we stop re-evaluating that watch locally. The
+// server deletes the record on hit, and the next ack prunes it here —
+// the fired-set only bridges the gap between hit and ack.
+const firedWatchKeys = new Set();
+const patternWatchKey = (w) => `${w.sessionName}${w.pattern}`;
+/** Ack payload → active watch list. Prunes fired-markers for dead watches. */
+const setPatternWatches = (raw) => {
+    patternWatches = Array.isArray(raw)
+        ? raw.filter((w) => typeof w === 'object' && w !== null
+            && typeof w.sessionName === 'string'
+            && typeof w.pattern === 'string')
+        : [];
+    const live = new Set(patternWatches.map(patternWatchKey));
+    for (const key of firedWatchKeys) {
+        if (!live.has(key))
+            firedWatchKeys.delete(key);
+    }
+};
+exports.setPatternWatches = setPatternWatches;
+/** Test hook. */
+const resetPatternWatches = () => {
+    patternWatches = [];
+    firedWatchKeys.clear();
+};
+exports.resetPatternWatches = resetPatternWatches;
+/**
+ * Probe every un-fired watch whose session is live. `capture` is
+ * injectable for tests; production passes capturePaneText.
+ */
+const collectWatchHits = (liveNames, capture = capturePaneText) => {
+    const hits = [];
+    const textCache = new Map();
+    for (const w of patternWatches) {
+        if (!liveNames.has(w.sessionName))
+            continue;
+        const key = patternWatchKey(w);
+        if (firedWatchKeys.has(key))
+            continue;
+        if (!textCache.has(w.sessionName))
+            textCache.set(w.sessionName, capture(w.sessionName));
+        const text = textCache.get(w.sessionName);
+        if (text === null || text === undefined)
+            continue;
+        const match = (0, agent_state_js_1.findPatternMatch)(w.pattern, text);
+        if (!match)
+            continue;
+        firedWatchKeys.add(key);
+        hits.push({ sessionName: w.sessionName, pattern: w.pattern, matchedLine: match.line });
+    }
+    return hits;
+};
+exports.collectWatchHits = collectWatchHits;
+// ─── Screen peek (SPEC-AGENT-AWARENESS §S4) ────────────────────────
+// Pane lines returned to the phone. Taller than the state-detection
+// capture — the user wants to READ this, not regex it.
+const SCREEN_PEEK_LINES = 60;
+// Ephemeral frames ride API Gateway WS (32KB frame limit); stay well
+// under it after JSON envelope overhead.
+const SCREEN_PEEK_MAX_BYTES = 24 * 1024;
+/**
+ * Answer a phone's screen-peek request for one of OUR sessions.
+ * Returns null when the message isn't addressed to this machine (other
+ * ephemeral traffic — clipboard, mirrors — flows through constantly).
+ *
+ * Security posture: only sessions the inventory already exposes are
+ * readable — the phone can see exactly the panes it can already send
+ * commands into, nothing else. Rate-limited with the same per-session
+ * token bucket as command injection.
+ */
+const handleScreenRequest = (req) => {
+    if (req.subtype !== 'agent.screen.request')
+        return null;
+    if (!req.requestId || !req.sessionName)
+        return null;
+    if (req.targetDeviceId !== (0, exports.computeListenerDeviceId)())
+        return null;
+    const capturedAt = new Date().toISOString();
+    const base = { subtype: 'agent.screen.snapshot', requestId: req.requestId, sessionName: req.sessionName, capturedAt };
+    if (!(0, exports.checkRateLimit)(`screen:${req.sessionName}`)) {
+        return { ...base, error: 'rate_limited' };
+    }
+    if (!(0, exports.collectSessions)().some((s) => s.name === req.sessionName)) {
+        return { ...base, error: 'unknown_session' };
+    }
+    const r = (0, child_process_1.spawnSync)('tmux', tmuxArgs(['capture-pane', '-p', '-t', req.sessionName, '-S', `-${SCREEN_PEEK_LINES}`]), {
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (r.status !== 0) {
+        return { ...base, error: 'capture_failed' };
+    }
+    let content = r.stdout ?? '';
+    let truncated = false;
+    while (Buffer.byteLength(content, 'utf-8') > SCREEN_PEEK_MAX_BYTES) {
+        // Cut from the top — the bottom of the pane is what the user needs.
+        const cut = content.indexOf('\n', Math.floor(content.length / 8));
+        content = cut > 0 ? content.slice(cut + 1) : content.slice(-SCREEN_PEEK_MAX_BYTES);
+        truncated = true;
+    }
+    return { ...base, content, truncated };
+};
+exports.handleScreenRequest = handleScreenRequest;
 /**
  * Inventory pass that also records *why* each `zeph-*` session was
  * skipped. The verbose log uses the rejection notes to explain empty
@@ -583,38 +672,41 @@ const collectSessionsVerbose = () => {
             continue;
         }
         const info = readPaneInfo(name);
-        const agentKind = detectAgentKind(info);
-        if (!agentKind) {
+        const agent = (0, exports.detectRemoteAgent)(info);
+        if (!agent) {
             rejected.push({
                 name,
                 reason: `no agent in pane (start=${info.startCommand ?? 'null'}, current=${info.currentCommand ?? 'null'})`,
             });
             continue;
         }
-        const agentSessionId = agentKind === 'claude' && info.currentPath
-            ? (0, exports.detectClaudeSessionId)(info.currentPath)
+        const agentSessionId = info.currentPath
+            ? (agent.resolveSessionId?.(info.currentPath) ?? null)
             : null;
         sessions.push({
             name,
             attached: attached === '1',
-            agentKind,
+            agentKind: agent.kind,
             agentSessionId,
             project: parsed.project,
             label: parsed.label,
             createdAt: epochToIso(created),
             lastActivityAt: epochToIso(activity),
+            ...(0, exports.deriveSessionState)(name, agent.kind, capturePaneText(name)),
         });
     }
+    pruneSessionStates(new Set(sessions.map((s) => s.name)));
     return { sessions, rejected };
 };
 exports.collectSessionsVerbose = collectSessionsVerbose;
 /**
  * Snapshot the live `zeph-*` tmux sessions on this machine, enriched
- * with the running agent kind, CC session UUID (claude only), project,
- * and tmux activity timestamps. Returns [] when tmux is unreachable
- * or no agent sessions exist. Sessions whose pane is at a shell or
- * running something other than claude/codex/gemini are filtered out
- * — the phone can't usefully address them.
+ * with the running agent kind, the agent's own session id (when the
+ * registry has a resolver — currently Claude Code only), project, and
+ * tmux activity timestamps. Returns [] when tmux is unreachable or no
+ * agent sessions exist. Sessions whose pane is at a shell or running
+ * something not registered in remote-agents.ts are filtered out — the
+ * phone can't usefully address them.
  */
 const collectSessions = () => (0, exports.collectSessionsVerbose)().sessions;
 exports.collectSessions = collectSessions;
@@ -894,11 +986,20 @@ const streamSession = (wsUrl, apiKey) => {
                 return;
             const { sessions, rejected } = (0, exports.collectSessionsVerbose)();
             sock.send(JSON.stringify({ type: 'listener.sessions', data: { sessions } }));
+            // Output-match watches (§S5 v2): probe watched panes and
+            // report hits. One-shot per watch; the server consumes the
+            // record and the next ack prunes it locally.
+            for (const hit of (0, exports.collectWatchHits)(new Set(sessions.map((s) => s.name)))) {
+                sock.send(JSON.stringify({ type: 'listener.watch.hit', data: hit }));
+                log(`🔔 watch hit: ${hit.sessionName} ~ /${hit.pattern}/`);
+            }
             // One line per cycle gives the user immediate feedback on
             // what the phone picker will see — particularly important
             // during setup, when an empty picker has no other observable
             // cause.
-            const names = sessions.map((s) => s.name).join(', ') || '∅';
+            const names = sessions
+                .map((s) => (s.state ? `${s.name}[${s.state}]` : s.name))
+                .join(', ') || '∅';
             log(`reported ${sessions.length} session(s): ${names}`);
             // Explain skipped zeph-* sessions so the most common
             // confusion (pane lost its claude start_command after a
@@ -988,6 +1089,15 @@ const streamSession = (wsUrl, apiKey) => {
                 // logged, never thrown into the socket handler.
                 void (0, exports.handlePush)(m.data).catch((err) => log(`! handlePush: ${err.message}`));
             }
+            if (m.type === 'ephemeral' && m.data) {
+                // Screen peek (§S4): the phone asks for this machine's live
+                // pane content over the ephemeral relay; the reply rides the
+                // same channel. Nothing is persisted server-side.
+                const reply = (0, exports.handleScreenRequest)(m.data);
+                if (reply && sock.readyState === ws_1.default.OPEN) {
+                    sock.send(JSON.stringify({ type: 'ephemeral', data: reply }));
+                }
+            }
             // Surface server-side errors from listener.sessions reports.
             // Without this the daemon happily logs "reported N session(s)"
             // even when the server is silently dropping every message —
@@ -998,6 +1108,8 @@ const streamSession = (wsUrl, apiKey) => {
             if (m.type === 'listener.sessions.ack') {
                 const d = m.data;
                 log(`✓ server persisted ${d?.count ?? '?'} session(s)`);
+                // Pattern watches ride the ack (§S5 v2) — refresh ours.
+                (0, exports.setPatternWatches)(d?.watches);
             }
             // `push.sync` (offline batch on $connect) and other types ignored.
         });
@@ -1122,6 +1234,17 @@ const handleListener = async (args) => {
     sweepAttachments();
     const gcTimer = setInterval(sweepAttachments, 60 * 60 * 1000);
     gcTimer.unref();
+    // Agent detection rules: disk cache immediately (offline-safe),
+    // then a background OTA refresh now and every 6 h (§S7).
+    (0, agent_rules_fetch_js_1.loadManifestFromCache)();
+    const refreshRules = () => {
+        void (0, agent_rules_fetch_js_1.refreshManifest)().then((r) => {
+            log(`rules: source=${r.source} outcome=${r.outcome}${r.version ? ` version=${r.version}` : ''}`);
+        });
+    };
+    refreshRules();
+    const rulesTimer = setInterval(refreshRules, agent_rules_fetch_js_1.RULES_REFRESH_INTERVAL_MS);
+    rulesTimer.unref();
     let shuttingDown = false;
     let activeHandle = null;
     const stop = (sig) => {

package/dist/remote-agents.d.ts

@@ -0,0 +1,55 @@
+export interface RemoteAgent {
+    /** Wire value for AgentSession.agentKind (server/phone contract). */
+    kind: string;
+    /** Human name for --help text. */
+    displayName: string;
+    /** Binary launched in the tmux pane; also the primary pane-match token. */
+    binary: string;
+    /** `zeph <subcommand>` aliases that launch this agent. */
+    subcommands: readonly string[];
+    /** Extra pane_command basenames accepted as this agent (beyond binary). */
+    paneMatchAliases?: readonly string[];
+    /**
+     * Resolve the agent's own session id from the pane's cwd.
+     * EXTENSION POINT: omitted for codex/gemini until their session-file
+     * formats are confirmed — the listener then reports agentSessionId: null.
+     */
+    resolveSessionId?: (paneCwd: string) => string | null;
+}
+/**
+ * Locate the most recent Claude Code session UUID for the working
+ * directory of a tmux pane. Mirrors `mcp-server/config.ts`'s
+ * detectClaudeSessionId: CC writes per-session jsonl files at
+ * `~/.claude/projects/<projectHash>/<UUID>.jsonl` where the hash is
+ * the cwd with `/` replaced by `-`. Cached for 60s — see
+ * claudeSessionCache.
+ */
+export declare const detectClaudeSessionId: (cwd: string) => string | null;
+declare const REMOTE_AGENT_TABLE: readonly [{
+    readonly kind: "claude";
+    readonly displayName: "Claude Code";
+    readonly binary: "claude";
+    readonly subcommands: readonly ["cc", "claude"];
+    readonly resolveSessionId: (cwd: string) => string | null;
+}, {
+    readonly kind: "codex";
+    readonly displayName: "Codex CLI";
+    readonly binary: "codex";
+    readonly subcommands: readonly ["codex"];
+}, {
+    readonly kind: "gemini";
+    readonly displayName: "Gemini CLI";
+    readonly binary: "gemini";
+    readonly subcommands: readonly ["gemini"];
+}];
+/** Closed union of remote-controllable agent kinds ('claude' | 'codex' | 'gemini'). */
+export type AgentKind = (typeof REMOTE_AGENT_TABLE)[number]['kind'];
+/** A registry row: the uniform RemoteAgent shape with `kind` narrowed to the closed union. */
+export type RegisteredRemoteAgent = RemoteAgent & {
+    kind: AgentKind;
+};
+export declare const REMOTE_AGENTS: readonly RegisteredRemoteAgent[];
+export declare const findAgentBySubcommand: (cmd: string) => RegisteredRemoteAgent | undefined;
+export declare const matchAgentByPaneCommand: (base: string) => RegisteredRemoteAgent | undefined;
+export {};
+//# sourceMappingURL=remote-agents.d.ts.map

package/dist/remote-agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-agents.d.ts","sourceRoot":"","sources":["../src/remote-agents.ts"],"names":[],"mappings":"AAiBA,MAAM,WAAW,WAAW;IACxB,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb,kCAAkC;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAC;IACf,0DAA0D;IAC1D,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,2EAA2E;IAC3E,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;CACzD;AAyCD;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,GAAI,KAAK,MAAM,KAAG,MAAM,GAAG,IAiB5D,CAAC;AAIF,QAAA,MAAM,kBAAkB;;;;;qCArBmB,MAAM,KAAG,MAAM,GAAG,IAAI;;;;;;;;;;;EAyCtB,CAAC;AAE5C,uFAAuF;AACvF,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAEpE,8FAA8F;AAC9F,MAAM,MAAM,qBAAqB,GAAG,WAAW,GAAG;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC;AAEtE,eAAO,MAAM,aAAa,EAAE,SAAS,qBAAqB,EAAuB,CAAC;AAElF,eAAO,MAAM,qBAAqB,GAAI,KAAK,MAAM,KAAG,qBAAqB,GAAG,SAClB,CAAC;AAE3D,eAAO,MAAM,uBAAuB,GAAI,MAAM,MAAM,KAAG,qBAAqB,GAAG,SAG9E,CAAC"}

package/dist/remote-agents.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchAgentByPaneCommand = exports.findAgentBySubcommand = exports.REMOTE_AGENTS = exports.detectClaudeSessionId = void 0;
+/**
+ * Remote-control agent registry — the single table behind `zeph cc` /
+ * `zeph codex` / `zeph gemini`, the listener's pane matching, and the
+ * per-agent session-id enrichment. Adding a remote-controllable agent is
+ * one row here (plus, for a genuinely new kind, backend/phone support:
+ * `kind` is a wire contract — AgentSession.agentKind flows to the server
+ * and the phone picker, which may validate the enum).
+ *
+ * This is deliberately NOT merged into `agents.ts`: that table drives
+ * install/uninstall/verify detection (8 agents, incl. Cursor/Windsurf
+ * which can never be driven via tmux), and the two tables carry different
+ * name axes — install id vs subcommand alias vs pane binary.
+ */
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+// ── Claude Code session resolver ─────────────────────────────────
+const CLAUDE_PROJECTS_DIR = (0, path_1.join)((0, os_1.homedir)(), '.claude', 'projects');
+/**
+ * Cache for detectClaudeSessionId. The function walks every jsonl file
+ * in `~/.claude/projects/<hash>/` on each call — after weeks of CC use
+ * that directory holds hundreds of session files, and we were calling
+ * this per tmux session per 5-second report cycle. Heavy disk I/O
+ * compounded with multiple sessions caused the report cycle to spike
+ * CPU and starve the host shell.
+ *
+ * The current-session UUID only changes when a new CC session starts
+ * in that directory (rare, on the order of hours), so a 60-second TTL
+ * is safe and cuts the per-cycle stat count by ~12×.
+ */
+const claudeSessionCache = new Map();
+const CLAUDE_SESSION_CACHE_TTL_MS = 60_000;
+const doDetectClaudeSessionId = (cwd) => {
+    try {
+        const projectHash = cwd.replace(/\//g, '-');
+        const sessionsDir = (0, path_1.join)(CLAUDE_PROJECTS_DIR, projectHash);
+        let latest;
+        for (const entry of (0, fs_1.readdirSync)(sessionsDir)) {
+            const m = entry.match(/^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/);
+            if (!m)
+                continue;
+            const stat = (0, fs_1.statSync)((0, path_1.join)(sessionsDir, entry));
+            if (!stat.isFile())
+                continue;
+            if (!latest || stat.mtimeMs > latest.mtime) {
+                latest = { name: m[1], mtime: stat.mtimeMs };
+            }
+        }
+        return latest?.name ?? null;
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Locate the most recent Claude Code session UUID for the working
+ * directory of a tmux pane. Mirrors `mcp-server/config.ts`'s
+ * detectClaudeSessionId: CC writes per-session jsonl files at
+ * `~/.claude/projects/<projectHash>/<UUID>.jsonl` where the hash is
+ * the cwd with `/` replaced by `-`. Cached for 60s — see
+ * claudeSessionCache.
+ */
+const detectClaudeSessionId = (cwd) => {
+    const now = Date.now();
+    const cached = claudeSessionCache.get(cwd);
+    if (cached && cached.expiresAt > now)
+        return cached.sessionId;
+    // Cap cache size so a long-lived listener that's seen many cwds
+    // doesn't grow unbounded. 64 is plenty for any realistic setup.
+    if (claudeSessionCache.size >= 64) {
+        // Evict the oldest-expiring entry — Map iteration order is
+        // insertion order, so the first key we hit is the oldest.
+        const firstKey = claudeSessionCache.keys().next().value;
+        if (firstKey !== undefined)
+            claudeSessionCache.delete(firstKey);
+    }
+    const sessionId = doDetectClaudeSessionId(cwd);
+    claudeSessionCache.set(cwd, { sessionId, expiresAt: now + CLAUDE_SESSION_CACHE_TTL_MS });
+    return sessionId;
+};
+exports.detectClaudeSessionId = detectClaudeSessionId;
+// ── The registry ─────────────────────────────────────────────────
+const REMOTE_AGENT_TABLE = [
+    {
+        kind: 'claude',
+        displayName: 'Claude Code',
+        binary: 'claude',
+        subcommands: ['cc', 'claude'],
+        resolveSessionId: exports.detectClaudeSessionId,
+    },
+    {
+        kind: 'codex',
+        displayName: 'Codex CLI',
+        binary: 'codex',
+        subcommands: ['codex'],
+    },
+    {
+        kind: 'gemini',
+        displayName: 'Gemini CLI',
+        binary: 'gemini',
+        subcommands: ['gemini'],
+    },
+];
+exports.REMOTE_AGENTS = REMOTE_AGENT_TABLE;
+const findAgentBySubcommand = (cmd) => exports.REMOTE_AGENTS.find((a) => a.subcommands.includes(cmd));
+exports.findAgentBySubcommand = findAgentBySubcommand;
+const matchAgentByPaneCommand = (base) => {
+    if (!base)
+        return undefined;
+    return exports.REMOTE_AGENTS.find((a) => a.binary === base || (a.paneMatchAliases ?? []).includes(base));
+};
+exports.matchAgentByPaneCommand = matchAgentByPaneCommand;

package/dist/templates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../src/templates.ts"],"names":[],"mappings":"AAgNA,6EAA6E;AAC7E,eAAO,MAAM,WAAW,QAGtB,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,aAAa,QAA4C,CAAC;AAEvE,sDAAsD;AACtD,eAAO,MAAM,WAAW,QAA4C,CAAC;AAErE,oDAAoD;AACpD,eAAO,MAAM,UAAU,QAA4C,CAAC;AAEpE,oFAAoF;AACpF,eAAO,MAAM,YAAY,QAA4C,CAAC;AAEtE,gEAAgE;AAChE,eAAO,MAAM,UAAU,QAAuC,CAAC;AAE/D,4FAA4F;AAC5F,eAAO,MAAM,UAAU,QAAuC,CAAC;AAI/D,eAAO,MAAM,YAAY,QAKd,CAAC;AAEZ,eAAO,MAAM,cAAc,QAOhB,CAAC;AAEZ,eAAO,MAAM,YAAY;;;;;;;;;;;;;;CAYxB,CAAC;AAEF,eAAO,MAAM,WAAW,QAQb,CAAC;AAEZ,eAAO,MAAM,aAAa,QASf,CAAC;AASZ,eAAO,MAAM,eAAe,oFAA+E,CAAC;AAC5G,eAAO,MAAM,aAAa,sBAAsB,CAAC;AAQjD;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,UAAU,MAAM,EAAE,MAAM,MAAM,KAAG,MAWnE,CAAC;AAEF,uEAAuE;AACvE,eAAO,MAAM,kBAAkB,GAAI,UAAU,MAAM,KAAG,MAOrD,CAAC"}
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../src/templates.ts"],"names":[],"mappings":"AAoFA,6EAA6E;AAC7E,eAAO,MAAM,WAAW,QAItB,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,aAAa,QAAyE,CAAC;AAEpG,sDAAsD;AACtD,eAAO,MAAM,WAAW,QAAyE,CAAC;AAElG,oDAAoD;AACpD,eAAO,MAAM,UAAU,QAAyE,CAAC;AAEjG,oFAAoF;AACpF,eAAO,MAAM,YAAY,QAAyE,CAAC;AAEnG,gEAAgE;AAChE,eAAO,MAAM,UAAU,QAAkE,CAAC;AAE1F,4FAA4F;AAC5F,eAAO,MAAM,UAAU,QAAkE,CAAC;AAI1F,eAAO,MAAM,YAAY,QAKd,CAAC;AAEZ,eAAO,MAAM,cAAc,QAOhB,CAAC;AAEZ,eAAO,MAAM,YAAY;;;;;;;;;;;;;;CAYxB,CAAC;AAEF,eAAO,MAAM,WAAW,QAQb,CAAC;AAEZ,eAAO,MAAM,aAAa,QASf,CAAC;AASZ,eAAO,MAAM,eAAe,oFAA+E,CAAC;AAC5G,eAAO,MAAM,aAAa,sBAAsB,CAAC;AAQjD;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,UAAU,MAAM,EAAE,MAAM,MAAM,KAAG,MAWnE,CAAC;AAEF,uEAAuE;AACvE,eAAO,MAAM,kBAAkB,GAAI,UAAU,MAAM,KAAG,MAOrD,CAAC"}