agentvigil 1.0.0

package/dist/index.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { logger } from './utils/logger.js';
+const program = new Command();
+program
+    .name('agentvigil')
+    .description('Fleet watchdog for AI coding agent sessions')
+    .version('1.0.0');
+program
+    .command('setup')
+    .description('First-time setup: register hooks and pair with mobile app')
+    .option('--dry-run', 'Show what would happen without making changes')
+    .action(async (opts) => {
+    const { runSetup } = await import('./commands/setup.js');
+    await runSetup(opts);
+});
+program
+    .command('start')
+    .description('Start the AgentVigil daemon')
+    .action(async () => {
+    const { runStart } = await import('./commands/start.js');
+    await runStart();
+});
+program
+    .command('hook <type>')
+    .description('Handle a Claude Code hook event (called by hooks, not by user)')
+    .action(async (type) => {
+    const { handleHook } = await import('./hooks/hook-handler.js');
+    await handleHook(type);
+});
+program
+    .command('status')
+    .description('Show all active agent sessions')
+    .action(async () => {
+    logger.info('TODO: implement status command');
+});
+program
+    .command('unpair')
+    .description('Revoke mobile app pairing')
+    .action(async () => {
+    logger.info('TODO: implement unpair command');
+});
+program
+    .command('logs')
+    .description('Tail the AgentVigil log file')
+    .action(async () => {
+    logger.info('TODO: implement logs command');
+});
+program
+    .command('uninstall')
+    .description('Remove AgentVigil hooks from Claude Code and Codex')
+    .action(async () => {
+    const { runUninstall } = await import('./commands/uninstall.js');
+    await runUninstall();
+});
+program
+    .command('install-autostart')
+    .description('Start AgentVigil automatically on login')
+    .action(async () => {
+    const { runInstallAutostart } = await import('./commands/autostart.js');
+    await runInstallAutostart();
+});
+program
+    .command('uninstall-autostart')
+    .description('Remove autostart')
+    .action(async () => {
+    const { runUninstallAutostart } = await import('./commands/autostart.js');
+    await runUninstallAutostart();
+});
+// `npx agentvigil` with no arguments — show a welcome message pointing at
+// `setup`/`start` instead of commander's default help-and-exit-1 behavior.
+program.action(() => {
+    console.log('');
+    console.log('  AgentVigil v1.0.0');
+    console.log('  Fleet watchdog for AI coding agent sessions');
+    console.log('');
+    console.log('  Getting started:');
+    console.log('    npx agentvigil setup    ← run this first');
+    console.log('    npx agentvigil start    ← then run this');
+    console.log('');
+    console.log('  Supported agents: Claude Code, Codex CLI');
+    console.log('  Requires: Node.js 18+, macOS');
+    console.log('  Docs: https://agentvigil.app');
+    console.log('');
+    program.help();
+});
+program.parse();
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/notifications/fcm-client.d.ts

@@ -0,0 +1,15 @@
+import type { AgentEvent } from '../types.js';
+export declare const SERVICE_ACCOUNT_PATH: string;
+/**
+ * Sends an AgentEvent to the phone as an FCM data message, encrypted with the
+ * pairing shared secret exactly like a WebSocket-delivered event — the phone's
+ * existing `NotificationService.handleFcmMessage` decrypts and renders it the
+ * same way regardless of transport. High-priority data messages are delivered
+ * by FCM even when the app has been force-stopped (killed).
+ *
+ * Returns true if the message was handed to FCM, false if FCM isn't
+ * configured or the send failed — the caller should fall back to ntfy.
+ */
+export declare function sendFcmEvent(fcmToken: string, event: AgentEvent, sharedSecret: string): Promise<boolean>;
+export declare function printFcmSetupInstructions(): void;
+//# sourceMappingURL=fcm-client.d.ts.map

package/dist/notifications/fcm-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fcm-client.d.ts","sourceRoot":"","sources":["../../src/notifications/fcm-client.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,oBAAoB,QAA0E,CAAC;AAuB5G;;;;;;;;;GASG;AACH,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAuB9G;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAWhD"}

package/dist/notifications/fcm-client.js

@@ -0,0 +1,72 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { logger } from '../utils/logger.js';
+import { encrypt } from '../crypto/encryption.js';
+export const SERVICE_ACCOUNT_PATH = path.join(os.homedir(), '.agentvigil', 'firebase-service-account.json');
+let app;
+let warnedMissing = false;
+async function getMessagingApp() {
+    if (app)
+        return app;
+    if (!fs.existsSync(SERVICE_ACCOUNT_PATH)) {
+        if (!warnedMissing) {
+            logger.warn('Firebase service account not found — falling back to ntfy');
+            printFcmSetupInstructions();
+            warnedMissing = true;
+        }
+        return undefined;
+    }
+    const { initializeApp, cert } = await import('firebase-admin/app');
+    const serviceAccount = JSON.parse(fs.readFileSync(SERVICE_ACCOUNT_PATH, 'utf-8'));
+    app = initializeApp({ credential: cert(serviceAccount) }, 'agentvigil-fcm');
+    return app;
+}
+/**
+ * Sends an AgentEvent to the phone as an FCM data message, encrypted with the
+ * pairing shared secret exactly like a WebSocket-delivered event — the phone's
+ * existing `NotificationService.handleFcmMessage` decrypts and renders it the
+ * same way regardless of transport. High-priority data messages are delivered
+ * by FCM even when the app has been force-stopped (killed).
+ *
+ * Returns true if the message was handed to FCM, false if FCM isn't
+ * configured or the send failed — the caller should fall back to ntfy.
+ */
+export async function sendFcmEvent(fcmToken, event, sharedSecret) {
+    const fcmApp = await getMessagingApp();
+    if (!fcmApp)
+        return false;
+    try {
+        const { getMessaging } = await import('firebase-admin/messaging');
+        await getMessaging(fcmApp).send({
+            token: fcmToken,
+            data: {
+                event_type: event.type,
+                payload: encrypt(JSON.stringify(event), sharedSecret),
+            },
+            android: {
+                priority: 'high',
+                ttl: 300_000, // 5 minutes — long enough for a permission prompt to still be relevant
+            },
+        });
+        logger.success(`FCM push sent: ${event.type} (${event.project_name})`);
+        return true;
+    }
+    catch (err) {
+        logger.warn('FCM push failed — falling back to ntfy', err);
+        return false;
+    }
+}
+export function printFcmSetupInstructions() {
+    logger.info('');
+    logger.info('To enable killed-app notifications:');
+    logger.info('1. Go to Firebase Console → Project Settings');
+    logger.info('2. Service Accounts → Generate new private key');
+    logger.info('3. Save the JSON file to:');
+    logger.info(`   ${SERVICE_ACCOUNT_PATH}`);
+    logger.info('4. Restart AgentVigil: node dist/index.js start');
+    logger.info('');
+    logger.info('Without this step notifications only work when');
+    logger.info('the app is open or backgrounded (not killed).');
+}
+//# sourceMappingURL=fcm-client.js.map

package/dist/notifications/fcm-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fcm-client.js","sourceRoot":"","sources":["../../src/notifications/fcm-client.ts"],"names":[],"mappings":"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"}

package/dist/notifications/ntfy-client.d.ts

@@ -0,0 +1,6 @@
+export declare function sendPermissionNotification(topic: string, projectName: string, command: string, sessionId: string): Promise<void>;
+export declare function sendTaskCompleteNotification(topic: string, projectName: string, duration: string): Promise<void>;
+export declare function sendErrorNotification(topic: string, projectName: string, error: string): Promise<void>;
+export declare function sendIdleNotification(topic: string, projectName: string, sessionId: string): Promise<void>;
+export declare function sendSessionEndedNotification(topic: string, projectName: string): Promise<void>;
+//# sourceMappingURL=ntfy-client.d.ts.map

package/dist/notifications/ntfy-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ntfy-client.d.ts","sourceRoot":"","sources":["../../src/notifications/ntfy-client.ts"],"names":[],"mappings":"AAaA,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAaf;AAED,wBAAsB,4BAA4B,CAChD,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CAUf;AAED,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAUf;AAED,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAWf;AAED,wBAAsB,4BAA4B,CAChD,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAUf"}

package/dist/notifications/ntfy-client.js

@@ -0,0 +1,51 @@
+import fetch from 'node-fetch';
+import { logger } from '../utils/logger.js';
+const NTFY_BASE = 'https://ntfy.sh';
+async function publish(topic, headers, body) {
+    try {
+        await fetch(`${NTFY_BASE}/${topic}`, { method: 'POST', headers, body });
+    }
+    catch (err) {
+        logger.warn('ntfy push failed (offline?)', err);
+    }
+}
+export async function sendPermissionNotification(topic, projectName, command, sessionId) {
+    await publish(topic, {
+        // HTTP header values must be Latin-1 — emoji render from `Tags` instead (see NOTIFICATIONS.md).
+        'Title': `[${projectName}] Permission Required`,
+        'Priority': 'urgent',
+        'Tags': 'warning,rotating_light',
+        'Click': `agentvigil://session/${sessionId}`,
+        'Actions': `http, APPROVE, https://ntfy.sh/${topic}/approve/${sessionId}; http, DENY, https://ntfy.sh/${topic}/deny/${sessionId}`,
+    }, command);
+}
+export async function sendTaskCompleteNotification(topic, projectName, duration) {
+    await publish(topic, {
+        'Title': `[${projectName}] Task Complete`,
+        'Priority': 'default',
+        'Tags': 'white_check_mark',
+    }, `Completed in ${duration}`);
+}
+export async function sendErrorNotification(topic, projectName, error) {
+    await publish(topic, {
+        'Title': `[${projectName}] Session Error`,
+        'Priority': 'high',
+        'Tags': 'x,red_circle',
+    }, error);
+}
+export async function sendIdleNotification(topic, projectName, sessionId) {
+    await publish(topic, {
+        'Title': `[${projectName}] Waiting for Input`,
+        'Priority': 'default',
+        'Tags': 'information_source',
+        'Click': `agentvigil://session/${sessionId}`,
+    }, 'Claude is waiting for your input');
+}
+export async function sendSessionEndedNotification(topic, projectName) {
+    await publish(topic, {
+        'Title': `[${projectName}] Session closed`,
+        'Priority': 'low',
+        'Tags': 'white_check_mark',
+    }, 'Claude Code session ended');
+}
+//# sourceMappingURL=ntfy-client.js.map

package/dist/notifications/ntfy-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ntfy-client.js","sourceRoot":"","sources":["../../src/notifications/ntfy-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,YAAY,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,MAAM,SAAS,GAAG,iBAAiB,CAAC;AAEpC,KAAK,UAAU,OAAO,CAAC,KAAa,EAAE,OAA+B,EAAE,IAAY;IACjF,IAAI,CAAC;QACH,MAAM,KAAK,CAAC,GAAG,SAAS,IAAI,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1E,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,6BAA6B,EAAE,GAAG,CAAC,CAAC;IAClD,CAAC;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAC9C,KAAa,EACb,WAAmB,EACnB,OAAe,EACf,SAAiB;IAEjB,MAAM,OAAO,CACX,KAAK,EACL;QACE,gGAAgG;QAChG,OAAO,EAAE,IAAI,WAAW,uBAAuB;QAC/C,UAAU,EAAE,QAAQ;QACpB,MAAM,EAAE,wBAAwB;QAChC,OAAO,EAAE,wBAAwB,SAAS,EAAE;QAC5C,SAAS,EAAE,kCAAkC,KAAK,YAAY,SAAS,iCAAiC,KAAK,SAAS,SAAS,EAAE;KAClI,EACD,OAAO,CACR,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAChD,KAAa,EACb,WAAmB,EACnB,QAAgB;IAEhB,MAAM,OAAO,CACX,KAAK,EACL;QACE,OAAO,EAAE,IAAI,WAAW,iBAAiB;QACzC,UAAU,EAAE,SAAS;QACrB,MAAM,EAAE,kBAAkB;KAC3B,EACD,gBAAgB,QAAQ,EAAE,CAC3B,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,KAAa,EACb,WAAmB,EACnB,KAAa;IAEb,MAAM,OAAO,CACX,KAAK,EACL;QACE,OAAO,EAAE,IAAI,WAAW,iBAAiB;QACzC,UAAU,EAAE,MAAM;QAClB,MAAM,EAAE,cAAc;KACvB,EACD,KAAK,CACN,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,KAAa,EACb,WAAmB,EACnB,SAAiB;IAEjB,MAAM,OAAO,CACX,KAAK,EACL;QACE,OAAO,EAAE,IAAI,WAAW,qBAAqB;QAC7C,UAAU,EAAE,SAAS;QACrB,MAAM,EAAE,oBAAoB;QAC5B,OAAO,EAAE,wBAAwB,SAAS,EAAE;KAC7C,EACD,kCAAkC,CACnC,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAChD,KAAa,EACb,WAAmB;IAEnB,MAAM,OAAO,CACX,KAAK,EACL;QACE,OAAO,EAAE,IAAI,WAAW,kBAAkB;QAC1C,UAAU,EAAE,KAAK;QACjB,MAAM,EAAE,kBAAkB;KAC3B,EACD,2BAA2B,CAC5B,CAAC;AACJ,CAAC"}

package/dist/relay/relay-handler.d.ts

@@ -0,0 +1,51 @@
+import type { SessionUpdate } from '../sessions/session-watcher.js';
+import type { AgentEvent, PhoneCommand } from '../types.js';
+export interface RelayWsServer {
+    sendEvent(event: AgentEvent): void;
+    readonly isPhoneConnected: boolean;
+    /** The NaCl shared secret for the paired phone, or undefined if not yet paired — used to encrypt FCM payloads identically to WS events. */
+    getSharedSecret(): string | undefined;
+}
+export declare class RelayHandler {
+    private readonly wsServer;
+    private readonly ntfyTopic;
+    private readonly recentTaskCompleteNotifications;
+    constructor(wsServer: RelayWsServer, ntfyTopic: string);
+    handleAgentEvent(event: AgentEvent): Promise<void>;
+    handlePhoneCommand(command: PhoneCommand): Promise<void>;
+    private broadcastSessionUpdated;
+    /**
+     * Called by the transcript watcher whenever a session's JSONL file is
+     * appended to. Approving/denying a permission prompt directly in the Mac
+     * terminal fires no hook AgentVigil listens for, so this transcript write
+     * is the only signal that a `blocked` session has resumed. Resolve it back
+     * to 'working' and broadcast `session_updated` so the fleet card leaves
+     * PERM and the phone clears the standing permission notification — the
+     * same effect as the phone's own approve/deny buttons.
+     */
+    handleTranscriptActivity(update: SessionUpdate): Promise<void>;
+    /**
+     * The session-poller can create an entry for a terminal's cwd before its
+     * transcript file (and thus its real session_id) exists, keying it off a
+     * stale/different session_id. When a hook event later arrives with the
+     * terminal's real session_id, that would otherwise create a SECOND entry
+     * for the same cwd — a duplicate fleet card, and one with no `pid`, so
+     * approve/deny can't inject keystrokes. Merge the stale entry's pid/tmux
+     * info into the new id, drop the stale entry, and tell the phone to remove
+     * its (now-orphaned) card.
+     */
+    private reconcileDuplicateSession;
+    private applyToSessionStore;
+    private pushNtfy;
+    /**
+     * Sends `event` directly via FCM (works even when the app is killed) when a
+     * phone FCM token is registered and a pairing shared secret is known.
+     * Returns true if FCM handled it — the caller should skip the ntfy push to
+     * avoid a duplicate notification. Returns false (no FCM token configured,
+     * not yet paired, or the send failed) so the caller falls back to ntfy.
+     */
+    private tryFcm;
+    /** Records a notification for `sessionId` and returns whether one was already sent within the dedup window. */
+    private wasRecentlyNotified;
+}
+//# sourceMappingURL=relay-handler.d.ts.map

package/dist/relay/relay-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-handler.d.ts","sourceRoot":"","sources":["../../src/relay/relay-handler.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,KAAK,EAAE,UAAU,EAAkB,YAAY,EAAE,MAAM,aAAa,CAAC;AAa5E,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,2IAA2I;IAC3I,eAAe,IAAI,MAAM,GAAG,SAAS,CAAC;CACvC;AAoBD,qBAAa,YAAY;IAIrB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAJ5B,OAAO,CAAC,QAAQ,CAAC,+BAA+B,CAA6B;gBAG1D,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,MAAM;IAG9B,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IA8ClD,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAwD9D,OAAO,CAAC,uBAAuB;IA0B/B;;;;;;;;OAQG;IACG,wBAAwB,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IA4CpE;;;;;;;;;OASG;IACH,OAAO,CAAC,yBAAyB;IAyBjC,OAAO,CAAC,mBAAmB;YAmBb,QAAQ;IAsCtB;;;;;;OAMG;YACW,MAAM;IAapB,+GAA+G;IAC/G,OAAO,CAAC,mBAAmB;CAS5B"}

package/dist/relay/relay-handler.js

@@ -0,0 +1,325 @@
+import { logger } from '../utils/logger.js';
+import { getConfig, saveConfig } from '../utils/config.js';
+import { deleteSession, getSession, getSessionByCwd, updateSession } from '../sessions/session-manager.js';
+import { approvePermission, denyPermission, sendPromptToSession } from '../sessions/keystroke-injector.js';
+import { sendErrorNotification, sendIdleNotification, sendPermissionNotification, sendTaskCompleteNotification, } from '../notifications/ntfy-client.js';
+import { sendFcmEvent } from '../notifications/fcm-client.js';
+// heartbeat/full_sync are outbound-only summaries — they don't represent a
+// change in a session's own state, so they're intentionally absent here.
+const SESSION_STATE_FOR_EVENT = {
+    permission_prompt: 'blocked',
+    task_complete: 'done',
+    session_error: 'error',
+    idle_waiting: 'idle',
+    session_started: 'working',
+    session_ended: 'done',
+};
+/**
+ * Routes AgentEvents from hook-handler.ts to the session store, the phone
+ * (over WebSocket when connected, and always via ntfy as a safety net), and
+ * routes phone commands (approve/deny/send_prompt) back to tmux-bridge.
+ */
+// A session ending fires both a `task_complete`-mapped event and (depending
+// on the hook) a `session_ended`-mapped one in quick succession. Both now
+// resolve to the same "Task Complete" push, so this guards against sending
+// it twice for the same session within a short window.
+const TASK_COMPLETE_DEDUP_WINDOW_MS = 10_000;
+// Claude Code can fire Stop and a permission_prompt Notification within
+// milliseconds of each other while merely pausing for approval — only that
+// near-simultaneous Stop is spurious. A Stop arriving well after the prompt
+// means the user actually responded (in the Mac terminal) and the turn ran
+// to completion, so it must be processed to clear the blocked state.
+const SPURIOUS_STOP_WINDOW_MS = 3_000;
+export class RelayHandler {
+    wsServer;
+    ntfyTopic;
+    recentTaskCompleteNotifications = new Map();
+    constructor(wsServer, ntfyTopic) {
+        this.wsServer = wsServer;
+        this.ntfyTopic = ntfyTopic;
+    }
+    async handleAgentEvent(event) {
+        try {
+            const previous = getSession(event.session_id);
+            // Claude Code fires a spurious Stop hook (session_ended) immediately
+            // before and/or after a permission_prompt Notification while the agent
+            // is merely paused waiting for approval — not actually finished. Only
+            // treat it as spurious within SPURIOUS_STOP_WINDOW_MS of the prompt; a
+            // later Stop means the user responded (e.g. in the Mac terminal) and
+            // the turn genuinely completed, so let it clear the blocked state.
+            if (event.type === 'session_ended' &&
+                previous?.state === 'blocked' &&
+                Date.now() - previous.last_activity.getTime() < SPURIOUS_STOP_WINDOW_MS) {
+                logger.dim(`Ignoring spurious Stop for ${event.project_name} — session is blocked on a permission prompt`);
+                return;
+            }
+            this.applyToSessionStore(event);
+            if (this.wsServer.isPhoneConnected) {
+                this.wsServer.sendEvent(event);
+            }
+            // ntfy is the safety net — send it even when the phone is live on WS,
+            // since the socket can drop without us knowing (see NOTIFICATIONS.md).
+            await this.pushNtfy(event, previous);
+            if (event.type === 'session_ended') {
+                // A permission_prompt for this session may have landed while the ntfy
+                // push above was in flight, putting it back into 'blocked'. Don't
+                // delete a session that's now awaiting approval again.
+                if (getSession(event.session_id)?.state === 'blocked') {
+                    logger.dim(`Skipping deleteSession for ${event.project_name} — now blocked on a permission prompt`);
+                    return;
+                }
+                deleteSession(event.session_id);
+                logger.info(`Session ended: ${event.project_name} — removed from fleet`);
+            }
+        }
+        catch (err) {
+            logger.warn('Failed to relay agent event', err);
+        }
+    }
+    async handlePhoneCommand(command) {
+        try {
+            switch (command.type) {
+                case 'approve': {
+                    logger.info(`[ApproveDeny] approve command received for session: ${command.session_id}`);
+                    logger.info(`[ApproveDeny] session ${command.session_id} ${getSession(command.session_id) ? 'found' : 'not found'}`);
+                    const approved = await approvePermission(command.session_id);
+                    logger.info(`[ApproveDeny] keystroke result (approve → '1'): ${approved ? 'SUCCESS' : 'FAILED'}`);
+                    this.broadcastSessionUpdated(command.session_id);
+                    return;
+                }
+                case 'deny': {
+                    logger.info(`[ApproveDeny] deny command received for session: ${command.session_id}`);
+                    logger.info(`[ApproveDeny] session ${command.session_id} ${getSession(command.session_id) ? 'found' : 'not found'}`);
+                    const denied = await denyPermission(command.session_id);
+                    logger.info(`[ApproveDeny] keystroke result (deny → '3'): ${denied ? 'SUCCESS' : 'FAILED'}`);
+                    this.broadcastSessionUpdated(command.session_id);
+                    return;
+                }
+                case 'send_prompt':
+                    if (command.payload) {
+                        logger.info(`Sending prompt to session ${command.session_id}: "${command.payload}"`);
+                        await sendPromptToSession(command.session_id, command.payload);
+                    }
+                    return;
+                case 'register_fcm_token': {
+                    if (!command.token)
+                        return;
+                    const config = await getConfig();
+                    config.fcm_token = command.token;
+                    await saveConfig(config);
+                    logger.success(`FCM token registered${command.device_name ? ` for ${command.device_name}` : ''}`);
+                    return;
+                }
+                case 'heartbeat':
+                    logger.dim('Heartbeat received from phone');
+                    this.wsServer.sendEvent({
+                        type: 'heartbeat',
+                        session_id: '',
+                        project_name: '',
+                        cwd: '',
+                        agent: 'claude-code',
+                        message: 'pong',
+                        timestamp: new Date().toISOString(),
+                    });
+                    return;
+                default:
+                    logger.warn(`Unknown phone command type: ${command.type}`);
+            }
+        }
+        catch (err) {
+            logger.warn('Failed to relay phone command', err);
+        }
+    }
+    // Resolves a blocked session back to 'working' after the phone approves or
+    // denies its permission prompt, and pushes the new state back to the phone
+    // so the fleet card and session detail screen update without a reload.
+    broadcastSessionUpdated(sessionId) {
+        if (!getSession(sessionId)) {
+            logger.warn(`[ApproveDeny] cannot broadcast session_updated — session ${sessionId} not found`);
+            return;
+        }
+        const session = updateSession(sessionId, { state: 'working' });
+        if (!this.wsServer.isPhoneConnected) {
+            logger.info(`[ApproveDeny] session ${sessionId} set to working — phone not connected, skipping broadcast`);
+            return;
+        }
+        this.wsServer.sendEvent({
+            type: 'session_updated',
+            session_id: session.session_id,
+            project_name: session.project_name,
+            cwd: session.cwd,
+            agent: session.agent,
+            message: session.last_message ?? 'working',
+            timestamp: session.last_activity.toISOString(),
+            pid: session.pid,
+        });
+        logger.info(`[ApproveDeny] session_updated broadcast sent for ${sessionId} (state: working)`);
+    }
+    /**
+     * Called by the transcript watcher whenever a session's JSONL file is
+     * appended to. Approving/denying a permission prompt directly in the Mac
+     * terminal fires no hook AgentVigil listens for, so this transcript write
+     * is the only signal that a `blocked` session has resumed. Resolve it back
+     * to 'working' and broadcast `session_updated` so the fleet card leaves
+     * PERM and the phone clears the standing permission notification — the
+     * same effect as the phone's own approve/deny buttons.
+     */
+    async handleTranscriptActivity(update) {
+        const session = getSession(update.session_id);
+        if (!session)
+            return;
+        if (session.state !== 'blocked') {
+            updateSession(update.session_id, {
+                last_message: update.last_message,
+                last_activity: update.last_activity,
+            });
+            return;
+        }
+        const resolved = updateSession(update.session_id, {
+            state: 'working',
+            last_message: update.last_message,
+            last_activity: update.last_activity,
+        });
+        const resolvedEvent = {
+            type: 'session_updated',
+            session_id: resolved.session_id,
+            project_name: resolved.project_name,
+            cwd: resolved.cwd,
+            agent: resolved.agent,
+            message: resolved.last_message ?? 'working',
+            timestamp: resolved.last_activity.toISOString(),
+            pid: resolved.pid,
+        };
+        if (this.wsServer.isPhoneConnected) {
+            this.wsServer.sendEvent(resolvedEvent);
+            logger.info(`[Transcript] session_updated broadcast sent for ${update.session_id} (resolved from blocked via terminal activity)`);
+            return;
+        }
+        // Phone not connected (e.g. app killed) — FCM is the only way to clear
+        // the standing permission notification.
+        if (await this.tryFcm(resolvedEvent)) {
+            logger.info(`[Transcript] session_updated sent via FCM for ${update.session_id} (resolved from blocked via terminal activity)`);
+        }
+        else {
+            logger.info(`[Transcript] session ${update.session_id} resolved to working — phone not reachable, skipping broadcast`);
+        }
+    }
+    /**
+     * The session-poller can create an entry for a terminal's cwd before its
+     * transcript file (and thus its real session_id) exists, keying it off a
+     * stale/different session_id. When a hook event later arrives with the
+     * terminal's real session_id, that would otherwise create a SECOND entry
+     * for the same cwd — a duplicate fleet card, and one with no `pid`, so
+     * approve/deny can't inject keystrokes. Merge the stale entry's pid/tmux
+     * info into the new id, drop the stale entry, and tell the phone to remove
+     * its (now-orphaned) card.
+     */
+    reconcileDuplicateSession(event) {
+        if (getSession(event.session_id))
+            return;
+        const stale = getSessionByCwd(event.cwd);
+        if (!stale || stale.session_id === event.session_id)
+            return;
+        updateSession(event.session_id, {
+            pid: stale.pid,
+            tmux_pane_id: stale.tmux_pane_id,
+        });
+        deleteSession(stale.session_id);
+        if (this.wsServer.isPhoneConnected) {
+            this.wsServer.sendEvent({
+                type: 'session_ended',
+                session_id: stale.session_id,
+                project_name: stale.project_name,
+                cwd: stale.cwd,
+                agent: stale.agent,
+                message: 'Replaced by a newer session for this terminal',
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
+    applyToSessionStore(event) {
+        const state = SESSION_STATE_FOR_EVENT[event.type];
+        if (!state)
+            return;
+        this.reconcileDuplicateSession(event);
+        updateSession(event.session_id, {
+            cwd: event.cwd,
+            project_name: event.project_name,
+            agent: event.agent,
+            state,
+            last_activity: new Date(event.timestamp),
+            last_message: event.message,
+            pid: event.pid,
+            permission_command: event.permission_command,
+            tool_name: event.tool_name,
+        });
+    }
+    async pushNtfy(event, previous) {
+        switch (event.type) {
+            case 'permission_prompt':
+                if (await this.tryFcm(event))
+                    return;
+                await sendPermissionNotification(this.ntfyTopic, event.project_name, event.permission_command ?? event.message, event.session_id);
+                return;
+            case 'task_complete':
+            case 'session_ended':
+                // Session-end notifications never fire more than once per session
+                // within the dedup window — see TASK_COMPLETE_DEDUP_WINDOW_MS.
+                if (this.wasRecentlyNotified(event.session_id))
+                    return;
+                if (await this.tryFcm(event))
+                    return;
+                await sendTaskCompleteNotification(this.ntfyTopic, event.project_name, formatDuration(previous ? Date.now() - previous.last_activity.getTime() : 0));
+                return;
+            case 'session_error':
+                if (await this.tryFcm(event))
+                    return;
+                await sendErrorNotification(this.ntfyTopic, event.project_name, event.message);
+                return;
+            case 'idle_waiting':
+                if (await this.tryFcm(event))
+                    return;
+                await sendIdleNotification(this.ntfyTopic, event.project_name, event.session_id);
+                return;
+            default:
+                // session_started / heartbeat / full_sync have no dedicated push —
+                // the WebSocket event is enough for those.
+                return;
+        }
+    }
+    /**
+     * Sends `event` directly via FCM (works even when the app is killed) when a
+     * phone FCM token is registered and a pairing shared secret is known.
+     * Returns true if FCM handled it — the caller should skip the ntfy push to
+     * avoid a duplicate notification. Returns false (no FCM token configured,
+     * not yet paired, or the send failed) so the caller falls back to ntfy.
+     */
+    async tryFcm(event) {
+        const sharedSecret = this.wsServer.getSharedSecret();
+        if (!sharedSecret)
+            return false;
+        const config = await getConfig();
+        if (!config.fcm_token) {
+            logger.warn('No FCM token — using ntfy fallback (killed state will not work)');
+            return false;
+        }
+        return sendFcmEvent(config.fcm_token, event, sharedSecret);
+    }
+    /** Records a notification for `sessionId` and returns whether one was already sent within the dedup window. */
+    wasRecentlyNotified(sessionId) {
+        const now = Date.now();
+        const last = this.recentTaskCompleteNotifications.get(sessionId);
+        if (last !== undefined && now - last < TASK_COMPLETE_DEDUP_WINDOW_MS) {
+            return true;
+        }
+        this.recentTaskCompleteNotifications.set(sessionId, now);
+        return false;
+    }
+}
+function formatDuration(ms) {
+    const totalSeconds = Math.max(0, Math.round(ms / 1000));
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    return minutes > 0 ? `${minutes}m${seconds}s` : `${seconds}s`;
+}
+//# sourceMappingURL=relay-handler.js.map