npm - aegis-bridge - Versions diffs - 2.2.2 - Mend

aegis-bridge 2.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (71) hide show

package/LICENSE +21 -0
package/README.md +244 -0
package/dashboard/dist/assets/index-CijFoeRu.css +32 -0
package/dashboard/dist/assets/index-QtT4j0ht.js +262 -0
package/dashboard/dist/index.html +14 -0
package/dist/auth.d.ts +76 -0
package/dist/auth.js +219 -0
package/dist/channels/index.d.ts +8 -0
package/dist/channels/index.js +9 -0
package/dist/channels/manager.d.ts +39 -0
package/dist/channels/manager.js +101 -0
package/dist/channels/telegram-style.d.ts +118 -0
package/dist/channels/telegram-style.js +203 -0
package/dist/channels/telegram.d.ts +76 -0
package/dist/channels/telegram.js +1396 -0
package/dist/channels/types.d.ts +77 -0
package/dist/channels/types.js +9 -0
package/dist/channels/webhook.d.ts +58 -0
package/dist/channels/webhook.js +162 -0
package/dist/cli.d.ts +8 -0
package/dist/cli.js +223 -0
package/dist/config.d.ts +60 -0
package/dist/config.js +188 -0
package/dist/dashboard/assets/index-CijFoeRu.css +32 -0
package/dist/dashboard/assets/index-QtT4j0ht.js +262 -0
package/dist/dashboard/index.html +14 -0
package/dist/events.d.ts +86 -0
package/dist/events.js +258 -0
package/dist/hook-settings.d.ts +67 -0
package/dist/hook-settings.js +138 -0
package/dist/hook.d.ts +18 -0
package/dist/hook.js +199 -0
package/dist/hooks.d.ts +32 -0
package/dist/hooks.js +279 -0
package/dist/jsonl-watcher.d.ts +57 -0
package/dist/jsonl-watcher.js +159 -0
package/dist/mcp-server.d.ts +60 -0
package/dist/mcp-server.js +788 -0
package/dist/metrics.d.ts +104 -0
package/dist/metrics.js +226 -0
package/dist/monitor.d.ts +84 -0
package/dist/monitor.js +553 -0
package/dist/permission-guard.d.ts +51 -0
package/dist/permission-guard.js +197 -0
package/dist/pipeline.d.ts +84 -0
package/dist/pipeline.js +218 -0
package/dist/screenshot.d.ts +26 -0
package/dist/screenshot.js +57 -0
package/dist/server.d.ts +10 -0
package/dist/server.js +1577 -0
package/dist/session.d.ts +297 -0
package/dist/session.js +1275 -0
package/dist/sse-limiter.d.ts +47 -0
package/dist/sse-limiter.js +62 -0
package/dist/sse-writer.d.ts +31 -0
package/dist/sse-writer.js +95 -0
package/dist/ssrf.d.ts +57 -0
package/dist/ssrf.js +169 -0
package/dist/swarm-monitor.d.ts +114 -0
package/dist/swarm-monitor.js +267 -0
package/dist/terminal-parser.d.ts +16 -0
package/dist/terminal-parser.js +343 -0
package/dist/tmux.d.ts +161 -0
package/dist/tmux.js +725 -0
package/dist/transcript.d.ts +47 -0
package/dist/transcript.js +244 -0
package/dist/validation.d.ts +222 -0
package/dist/validation.js +268 -0
package/dist/ws-terminal.d.ts +32 -0
package/dist/ws-terminal.js +297 -0
package/package.json +71 -0

package/dist/dashboard/index.html ADDED Viewed

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="en" class="dark">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Aegis Dashboard</title>
+    <link rel="icon" type="image/svg+xml" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>🛡️</text></svg>" />
+    <script type="module" crossorigin src="/dashboard/assets/index-QtT4j0ht.js"></script>
+    <link rel="stylesheet" crossorigin href="/dashboard/assets/index-CijFoeRu.css">
+  </head>
+  <body class="bg-[#0a0a0f] text-gray-200 antialiased">
+    <div id="root"></div>
+  </body>
+</html>

package/dist/events.d.ts ADDED Viewed

@@ -0,0 +1,86 @@
+/**
+ * events.ts — SSE event emitter for session monitoring.
+ *
+ * Issue #32: Real-time Server-Sent Events for session lifecycle.
+ * Subscribers receive events via an EventEmitter pattern.
+ * The monitor pushes events; the SSE route consumes them.
+ */
+export interface SessionSSEEvent {
+    event: 'status' | 'message' | 'system' | 'approval' | 'ended' | 'heartbeat' | 'stall' | 'dead' | 'hook' | 'subagent_start' | 'subagent_stop';
+    sessionId: string;
+    timestamp: string;
+    data: Record<string, unknown>;
+    /** Issue #87: Unix timestamp (ms) when the event was emitted by Aegis. */
+    emittedAt?: number;
+    /** Issue #308: Incrementing event ID for Last-Event-ID replay. */
+    id?: number;
+}
+export interface GlobalSSEEvent {
+    event: 'session_status_change' | 'session_message' | 'session_approval' | 'session_ended' | 'session_created' | 'session_stall' | 'session_dead' | 'session_subagent_start' | 'session_subagent_stop';
+    sessionId: string;
+    timestamp: string;
+    data: Record<string, unknown>;
+    /** Issue #301: Incrementing event ID for Last-Event-ID replay. */
+    id?: number;
+}
+/**
+ * Per-session event bus. Subscribers (SSE connections) register here.
+ * The monitor calls emit() when events happen.
+ */
+export declare class SessionEventBus {
+    private emitters;
+    /** #224: Track emitters that are ending so new subscribers get fresh emitters. */
+    private readonly endingEmitters;
+    /** Global incrementing event ID counter. */
+    private nextEventId;
+    /** Maximum events to buffer per session for Last-Event-ID replay. */
+    private static readonly BUFFER_SIZE;
+    /** Per-session ring buffer for event replay. */
+    private eventBuffers;
+    /** Global ring buffer for event replay across all sessions (Issue #301). */
+    private globalEventBuffer;
+    /** Get or create the emitter for a session. */
+    private getEmitter;
+    /** Subscribe to events for a session. Returns unsubscribe function. */
+    subscribe(sessionId: string, handler: (event: SessionSSEEvent) => void): () => void;
+    /** Emit an event to all subscribers for a session (and global subscribers). */
+    emit(sessionId: string, event: SessionSSEEvent): void;
+    /** Get events emitted after the given event ID for a session. */
+    getEventsSince(sessionId: string, lastEventId: number): SessionSSEEvent[];
+    /** Emit a status change event. */
+    emitStatus(sessionId: string, status: string, detail: string): void;
+    /** Emit a message event. */
+    emitMessage(sessionId: string, role: string, text: string, contentType?: string, toolMeta?: {
+        tool_name?: string;
+        tool_id?: string;
+    }): void;
+    /** Issue #89 L33: Emit a system message event (differentiated from user/assistant messages). */
+    emitSystem(sessionId: string, text: string, contentType?: string): void;
+    /** Emit an approval request event. */
+    emitApproval(sessionId: string, prompt: string): void;
+    /** Emit a session ended event. */
+    emitEnded(sessionId: string, reason: string): void;
+    /** Emit a stall event. */
+    emitStall(sessionId: string, stallType: string, detail: string): void;
+    /** Emit a dead session event. */
+    emitDead(sessionId: string, detail: string): void;
+    /** Emit a Claude Code hook event (e.g. Stop, PreToolUse, etc.). */
+    emitHook(sessionId: string, hookEvent: string, hookData: Record<string, unknown>): void;
+    /** Check if a session has any subscribers. */
+    hasSubscribers(sessionId: string): boolean;
+    /** Get the number of subscribers for a session. */
+    subscriberCount(sessionId: string): number;
+    /** Global emitter for aggregating events across all sessions. */
+    private globalEmitter;
+    /** Subscribe to events from ALL sessions (new and existing). Returns unsubscribe function. */
+    subscribeGlobal(handler: (event: GlobalSSEEvent) => void): () => void;
+    /** Emit a session created event to global subscribers. */
+    emitCreated(sessionId: string, name: string, workDir: string): void;
+    /** Get global events emitted after the given event ID (Issue #301). */
+    getGlobalEventsSince(lastEventId: number): Array<{
+        id: number;
+        event: GlobalSSEEvent;
+    }>;
+    /** Clean up all emitters. */
+    destroy(): void;
+}

package/dist/events.js ADDED Viewed

@@ -0,0 +1,258 @@
+/**
+ * events.ts — SSE event emitter for session monitoring.
+ *
+ * Issue #32: Real-time Server-Sent Events for session lifecycle.
+ * Subscribers receive events via an EventEmitter pattern.
+ * The monitor pushes events; the SSE route consumes them.
+ */
+import { EventEmitter } from 'node:events';
+/** Map per-session event types to global event types. */
+function toGlobalEvent(event) {
+    const typeMap = {
+        status: 'session_status_change',
+        message: 'session_message',
+        system: 'session_message',
+        approval: 'session_approval',
+        ended: 'session_ended',
+        heartbeat: 'session_status_change',
+        stall: 'session_stall',
+        dead: 'session_dead',
+        subagent_start: 'session_subagent_start',
+        subagent_stop: 'session_subagent_stop',
+        hook: 'session_message',
+    };
+    return {
+        event: typeMap[event.event] || 'session_status_change',
+        sessionId: event.sessionId,
+        timestamp: event.timestamp,
+        data: event.data,
+        id: event.id,
+    };
+}
+/**
+ * Per-session event bus. Subscribers (SSE connections) register here.
+ * The monitor calls emit() when events happen.
+ */
+export class SessionEventBus {
+    emitters = new Map();
+    /** #224: Track emitters that are ending so new subscribers get fresh emitters. */
+    endingEmitters = new WeakSet();
+    /** Global incrementing event ID counter. */
+    nextEventId = 1;
+    /** Maximum events to buffer per session for Last-Event-ID replay. */
+    static BUFFER_SIZE = 50;
+    /** Per-session ring buffer for event replay. */
+    eventBuffers = new Map();
+    /** Global ring buffer for event replay across all sessions (Issue #301). */
+    globalEventBuffer = [];
+    /** Get or create the emitter for a session. */
+    getEmitter(sessionId) {
+        let emitter = this.emitters.get(sessionId);
+        // #224: If emitter is ending (session ended), create a fresh one
+        if (emitter && this.endingEmitters.has(emitter)) {
+            this.emitters.delete(sessionId);
+            emitter = undefined;
+        }
+        if (!emitter) {
+            emitter = new EventEmitter();
+            emitter.setMaxListeners(50); // Allow many concurrent SSE clients
+            this.emitters.set(sessionId, emitter);
+        }
+        return emitter;
+    }
+    /** Subscribe to events for a session. Returns unsubscribe function. */
+    subscribe(sessionId, handler) {
+        const emitter = this.getEmitter(sessionId);
+        emitter.on('event', handler);
+        return () => {
+            emitter.off('event', handler);
+            // Clean up emitter if no more listeners and not ending
+            if (emitter.listenerCount('event') === 0 && !this.endingEmitters.has(emitter)) {
+                this.emitters.delete(sessionId);
+            }
+        };
+    }
+    /** Emit an event to all subscribers for a session (and global subscribers). */
+    emit(sessionId, event) {
+        // Issue #87: Stamp emittedAt for latency measurement
+        event.emittedAt = Date.now();
+        // Issue #308: Assign incrementing ID for Last-Event-ID replay
+        event.id = this.nextEventId++;
+        // Push to ring buffer
+        let buffer = this.eventBuffers.get(sessionId);
+        if (!buffer) {
+            buffer = [];
+            this.eventBuffers.set(sessionId, buffer);
+        }
+        buffer.push({ id: event.id, event });
+        if (buffer.length > SessionEventBus.BUFFER_SIZE) {
+            buffer.splice(0, buffer.length - SessionEventBus.BUFFER_SIZE);
+        }
+        const emitter = this.emitters.get(sessionId);
+        if (emitter) {
+            setImmediate(() => emitter.emit('event', event));
+        }
+        // Forward to global subscribers
+        if (this.globalEmitter) {
+            const globalEvent = toGlobalEvent(event);
+            // Issue #301: push to global ring buffer
+            this.globalEventBuffer.push({ id: event.id, event: globalEvent });
+            if (this.globalEventBuffer.length > SessionEventBus.BUFFER_SIZE) {
+                this.globalEventBuffer.splice(0, this.globalEventBuffer.length - SessionEventBus.BUFFER_SIZE);
+            }
+            setImmediate(() => this.globalEmitter.emit('event', globalEvent));
+        }
+    }
+    /** Get events emitted after the given event ID for a session. */
+    getEventsSince(sessionId, lastEventId) {
+        const buffer = this.eventBuffers.get(sessionId);
+        if (!buffer)
+            return [];
+        return buffer.filter(e => e.id > lastEventId).map(e => e.event);
+    }
+    /** Emit a status change event. */
+    emitStatus(sessionId, status, detail) {
+        this.emit(sessionId, {
+            event: 'status',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { status, detail },
+        });
+    }
+    /** Emit a message event. */
+    emitMessage(sessionId, role, text, contentType, toolMeta) {
+        this.emit(sessionId, {
+            event: 'message',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { role, text, contentType, ...toolMeta },
+        });
+    }
+    /** Issue #89 L33: Emit a system message event (differentiated from user/assistant messages). */
+    emitSystem(sessionId, text, contentType) {
+        this.emit(sessionId, {
+            event: 'system',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { role: 'system', text, contentType, isSystem: true },
+        });
+    }
+    /** Emit an approval request event. */
+    emitApproval(sessionId, prompt) {
+        this.emit(sessionId, {
+            event: 'approval',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { prompt },
+        });
+    }
+    /** Emit a session ended event. */
+    emitEnded(sessionId, reason) {
+        this.emit(sessionId, {
+            event: 'ended',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { reason },
+        });
+        // #224: Mark emitter as ending so new subscribers don't get silently deleted
+        const emitter = this.emitters.get(sessionId);
+        if (emitter) {
+            this.endingEmitters.add(emitter);
+        }
+        // Clean up after a short delay (let clients receive the event)
+        // Capture reference — only delete if it's still the same emitter
+        // #357: Also delete the per-session event buffer to prevent unbounded map growth
+        setTimeout(() => {
+            if (this.emitters.get(sessionId) === emitter) {
+                this.emitters.delete(sessionId);
+            }
+            this.eventBuffers.delete(sessionId);
+        }, 1000);
+    }
+    /** Emit a stall event. */
+    emitStall(sessionId, stallType, detail) {
+        this.emit(sessionId, {
+            event: 'stall',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { stallType, detail },
+        });
+    }
+    /** Emit a dead session event. */
+    emitDead(sessionId, detail) {
+        this.emit(sessionId, {
+            event: 'dead',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { reason: detail },
+        });
+    }
+    /** Emit a Claude Code hook event (e.g. Stop, PreToolUse, etc.). */
+    emitHook(sessionId, hookEvent, hookData) {
+        this.emit(sessionId, {
+            event: 'hook',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { hookEvent, ...hookData },
+        });
+    }
+    /** Check if a session has any subscribers. */
+    hasSubscribers(sessionId) {
+        const emitter = this.emitters.get(sessionId);
+        return !!emitter && emitter.listenerCount('event') > 0;
+    }
+    /** Get the number of subscribers for a session. */
+    subscriberCount(sessionId) {
+        const emitter = this.emitters.get(sessionId);
+        return emitter ? emitter.listenerCount('event') : 0;
+    }
+    // ── Global (all-session) SSE ──────────────────────────────────────
+    /** Global emitter for aggregating events across all sessions. */
+    globalEmitter = null;
+    /** Subscribe to events from ALL sessions (new and existing). Returns unsubscribe function. */
+    subscribeGlobal(handler) {
+        if (!this.globalEmitter) {
+            this.globalEmitter = new EventEmitter();
+            this.globalEmitter.setMaxListeners(50);
+        }
+        this.globalEmitter.on('event', handler);
+        return () => {
+            this.globalEmitter?.off('event', handler);
+        };
+    }
+    /** Emit a session created event to global subscribers. */
+    emitCreated(sessionId, name, workDir) {
+        if (!this.globalEmitter)
+            return;
+        const id = this.nextEventId++;
+        const globalEvent = {
+            event: 'session_created',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { name, workDir },
+            id,
+        };
+        // Issue #301: buffer global-only events
+        this.globalEventBuffer.push({ id, event: globalEvent });
+        if (this.globalEventBuffer.length > SessionEventBus.BUFFER_SIZE) {
+            this.globalEventBuffer.splice(0, this.globalEventBuffer.length - SessionEventBus.BUFFER_SIZE);
+        }
+        this.globalEmitter.emit('event', globalEvent);
+    }
+    /** Get global events emitted after the given event ID (Issue #301). */
+    getGlobalEventsSince(lastEventId) {
+        return this.globalEventBuffer.filter(e => e.id > lastEventId);
+    }
+    /** Clean up all emitters. */
+    destroy() {
+        for (const emitter of this.emitters.values()) {
+            emitter.removeAllListeners();
+        }
+        this.emitters.clear();
+        this.eventBuffers.clear();
+        this.globalEventBuffer = [];
+        this.globalEmitter?.removeAllListeners();
+        this.globalEmitter = null;
+    }
+}
+//# sourceMappingURL=events.js.map

package/dist/hook-settings.d.ts ADDED Viewed

@@ -0,0 +1,67 @@
+/**
+ * hook-settings.ts — Generate CC settings.json with HTTP hooks for Aegis.
+ *
+ * When Aegis creates a CC session, it writes a per-session settings file
+ * that configures HTTP hooks pointing to Aegis's hook receiver endpoint.
+ * The file is passed to CC via the `--settings` CLI flag.
+ *
+ * Only events that support `type: "http"` hooks are included:
+ *   Stop, PreToolUse, PostToolUse, PermissionRequest, TaskCompleted
+ *
+ * Events like Notification, SessionEnd, etc. only support `type: "command"`
+ * and are excluded.
+ *
+ * Issue #169: Phase 2 — Inject CC settings.json with HTTP hooks.
+ */
+/** CC hook events that support `type: "http"`.
+ *
+ * All CC hook events support HTTP hooks. We register the most useful ones
+ * for Aegis status detection and event forwarding.
+ *
+ * Excluded (low value for Aegis):
+ *   - InstructionsLoaded, ConfigChange, CwdChanged, FileChanged (informational)
+ *   - WorktreeCreate, WorktreeRemove (worktree management)
+ *   - Elicitation, ElicitationResult (MCP-specific)
+ *   - PreCompact, PostCompact (internal optimization)
+ */
+declare const HTTP_HOOK_EVENTS: readonly ["Stop", "StopFailure", "PreToolUse", "PostToolUse", "PostToolUseFailure", "PermissionRequest", "TaskCompleted", "SessionStart", "SessionEnd", "UserPromptSubmit", "SubagentStart", "SubagentStop", "Notification", "TeammateIdle"];
+export { HTTP_HOOK_EVENTS };
+export type HttpHookEvent = typeof HTTP_HOOK_EVENTS[number];
+/** Shape of a single HTTP hook entry in CC settings.json. */
+interface HttpHookConfig {
+    type: 'http';
+    url: string;
+}
+/** Shape of the `hooks` section in CC settings.json. */
+export interface HookSettings {
+    hooks: Record<string, Array<{
+        matcher?: string;
+        hooks: HttpHookConfig[];
+    }>>;
+}
+/**
+ * Generate the hooks section of a CC settings.json for a given session.
+ *
+ * @param baseUrl - Aegis base URL (e.g. "http://localhost:9100")
+ * @param sessionId - Aegis session ID (used as query param for routing)
+ */
+export declare function generateHookSettings(baseUrl: string, sessionId: string): HookSettings;
+/**
+ * Write hook settings to a temporary file and return its path.
+ *
+ * Issue #339: Reads .claude/settings.local.json from workDir and deep-merges
+ * hook settings into it, so CC gets both project settings (env vars, permissions,
+ * bypassPermissions) AND Aegis hooks in a single --settings file.
+ *
+ * @param baseUrl - Aegis base URL
+ * @param sessionId - Aegis session ID
+ * @param workDir - Project working directory (to read settings.local.json from)
+ * @returns Path to the temporary settings file
+ */
+export declare function writeHookSettingsFile(baseUrl: string, sessionId: string, workDir?: string): Promise<string>;
+/**
+ * Clean up a hook settings temp file.
+ *
+ * @param filePath - Path to the temporary settings file
+ */
+export declare function cleanupHookSettingsFile(filePath: string): Promise<void>;

package/dist/hook-settings.js ADDED Viewed

@@ -0,0 +1,138 @@
+/**
+ * hook-settings.ts — Generate CC settings.json with HTTP hooks for Aegis.
+ *
+ * When Aegis creates a CC session, it writes a per-session settings file
+ * that configures HTTP hooks pointing to Aegis's hook receiver endpoint.
+ * The file is passed to CC via the `--settings` CLI flag.
+ *
+ * Only events that support `type: "http"` hooks are included:
+ *   Stop, PreToolUse, PostToolUse, PermissionRequest, TaskCompleted
+ *
+ * Events like Notification, SessionEnd, etc. only support `type: "command"`
+ * and are excluded.
+ *
+ * Issue #169: Phase 2 — Inject CC settings.json with HTTP hooks.
+ */
+import { readFile, writeFile, unlink, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { ccSettingsSchema } from './validation.js';
+/** CC hook events that support `type: "http"`.
+ *
+ * All CC hook events support HTTP hooks. We register the most useful ones
+ * for Aegis status detection and event forwarding.
+ *
+ * Excluded (low value for Aegis):
+ *   - InstructionsLoaded, ConfigChange, CwdChanged, FileChanged (informational)
+ *   - WorktreeCreate, WorktreeRemove (worktree management)
+ *   - Elicitation, ElicitationResult (MCP-specific)
+ *   - PreCompact, PostCompact (internal optimization)
+ */
+const HTTP_HOOK_EVENTS = [
+    // Status detection (highest value)
+    'Stop',
+    'StopFailure',
+    'PreToolUse',
+    'PostToolUse',
+    'PostToolUseFailure',
+    'PermissionRequest',
+    'TaskCompleted',
+    // Session lifecycle
+    'SessionStart',
+    'SessionEnd',
+    'UserPromptSubmit',
+    // Subagent tracking
+    'SubagentStart',
+    'SubagentStop',
+    // Notifications
+    'Notification',
+    'TeammateIdle',
+];
+export { HTTP_HOOK_EVENTS };
+/**
+ * Generate the hooks section of a CC settings.json for a given session.
+ *
+ * @param baseUrl - Aegis base URL (e.g. "http://localhost:9100")
+ * @param sessionId - Aegis session ID (used as query param for routing)
+ */
+export function generateHookSettings(baseUrl, sessionId) {
+    const hooks = {};
+    for (const event of HTTP_HOOK_EVENTS) {
+        hooks[event] = [
+            {
+                hooks: [
+                    {
+                        type: 'http',
+                        url: `${baseUrl}/v1/hooks/${event}?sessionId=${sessionId}`,
+                    },
+                ],
+            },
+        ];
+    }
+    return { hooks };
+}
+/**
+ * Write hook settings to a temporary file and return its path.
+ *
+ * Issue #339: Reads .claude/settings.local.json from workDir and deep-merges
+ * hook settings into it, so CC gets both project settings (env vars, permissions,
+ * bypassPermissions) AND Aegis hooks in a single --settings file.
+ *
+ * @param baseUrl - Aegis base URL
+ * @param sessionId - Aegis session ID
+ * @param workDir - Project working directory (to read settings.local.json from)
+ * @returns Path to the temporary settings file
+ */
+export async function writeHookSettingsFile(baseUrl, sessionId, workDir) {
+    const hookSettings = generateHookSettings(baseUrl, sessionId);
+    // Issue #339: Read project's settings.local.json and merge hooks into it.
+    // This ensures CC gets env vars, permissions, and bypassPermissions alongside hooks.
+    let merged = {};
+    if (workDir) {
+        const projectSettingsPath = join(workDir, '.claude', 'settings.local.json');
+        if (existsSync(projectSettingsPath)) {
+            try {
+                const raw = await readFile(projectSettingsPath, 'utf-8');
+                const parsed = ccSettingsSchema.safeParse(JSON.parse(raw));
+                if (parsed.success) {
+                    merged = parsed.data;
+                }
+            }
+            catch {
+                // Malformed settings file — use empty base, hooks will still work
+            }
+        }
+    }
+    // Deep-merge: project settings as base, hook settings override
+    const combined = {
+        ...merged,
+        hooks: {
+            ...(merged.hooks ?? {}),
+            ...hookSettings.hooks,
+        },
+    };
+    const settingsDir = join(tmpdir(), 'aegis-hooks');
+    if (!existsSync(settingsDir)) {
+        await mkdir(settingsDir, { recursive: true });
+    }
+    const filePath = join(settingsDir, `hooks-${sessionId}.json`);
+    await writeFile(filePath, JSON.stringify(combined, null, 2) + '\n', 'utf-8');
+    return filePath;
+}
+/**
+ * Clean up a hook settings temp file.
+ *
+ * @param filePath - Path to the temporary settings file
+ */
+export async function cleanupHookSettingsFile(filePath) {
+    try {
+        if (existsSync(filePath)) {
+            await unlink(filePath);
+        }
+    }
+    catch {
+        // Non-fatal: temp file cleanup failed
+    }
+}
+//# sourceMappingURL=hook-settings.js.map

package/dist/hook.d.ts ADDED Viewed

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * hook.ts — Claude Code SessionStart hook for Aegis.
+ *
+ * Writes session_id → window_id mapping to ~/.aegis/session_map.json.
+ * Falls back to ~/.manus/ for backward compatibility.
+ * Called by CC's hook system, reads payload from stdin.
+ *
+ * Install: add to ~/.claude/settings.json:
+ * {
+ *   "hooks": {
+ *     "SessionStart": [{
+ *       "hooks": [{ "type": "command", "command": "node /path/to/dist/hook.js", "timeout": 5 }]
+ *     }]
+ *   }
+ * }
+ */
+export {};