@getpaseo/server 0.1.95 → 0.1.97-beta.1

package/dist/server/terminal/agent-hooks/agent-hook-installer.d.ts

@@ -0,0 +1,62 @@
+export interface AgentHookEventDefinition {
+    event: string;
+}
+export type AgentHookActivityState = "running" | "idle" | "needs-input";
+export interface AgentHookActivityInput {
+    isTTY?: boolean;
+    read(): Promise<string | null>;
+}
+export interface AgentHookProvider<TConfig = unknown> {
+    id: string;
+    events: AgentHookEventDefinition[];
+    resolveActivity(input: {
+        event: string;
+        input: AgentHookActivityInput;
+    }): Promise<AgentHookActivityState | null>;
+    install: AgentHookInstallStrategy<TConfig>;
+}
+export type AgentHookInstallStrategy<TConfig> = AgentHookConfigFileInstallStrategy<TConfig> | AgentHookPluginFileInstallStrategy;
+interface AgentHookInstallStrategyBase {
+    kind: "config-file" | "plugin-file";
+    configDir: string;
+    configDirBase?: "home" | "xdg-config";
+    configFile: string;
+    configDirEnvOverride?: string;
+    hookMarker: string;
+}
+export interface AgentHookConfigFileInstallStrategy<TConfig> extends AgentHookInstallStrategyBase {
+    kind: "config-file";
+    format: AgentHookConfigFormat<TConfig>;
+}
+export interface AgentHookPluginFileInstallStrategy extends AgentHookInstallStrategyBase {
+    kind: "plugin-file";
+    source: string;
+}
+export interface AgentHookConfigFormat<TConfig> {
+    empty(): TConfig;
+    parse(raw: string): TConfig;
+    stringify(config: TConfig): string;
+    install(config: TConfig, provider: AgentHookProvider<TConfig>): TConfig;
+    uninstall(config: TConfig, provider: AgentHookProvider<TConfig>): TConfig;
+    isInstalled(config: TConfig, provider: AgentHookProvider<TConfig>): boolean;
+}
+export interface AgentHookInstallOptions {
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+    configDir?: string;
+}
+export interface AgentHookInstallLogger {
+    warn(bindings: Record<string, unknown>, message: string): void;
+}
+export interface AgentHookInstallResult {
+    configPath: string;
+    changed: boolean;
+}
+export declare function installAgentHooks<TConfig>(provider: AgentHookProvider<TConfig>, options?: AgentHookInstallOptions): AgentHookInstallResult;
+export declare function uninstallAgentHooks<TConfig>(provider: AgentHookProvider<TConfig>, options?: AgentHookInstallOptions): AgentHookInstallResult;
+export declare function agentHooksAreInstalled<TConfig>(provider: AgentHookProvider<TConfig>, options?: AgentHookInstallOptions): boolean;
+export declare function resolveAgentHookConfigPath<TConfig>(provider: AgentHookProvider<TConfig>, options?: AgentHookInstallOptions): string;
+export declare function buildAgentHookShellCommand<TConfig>(provider: AgentHookProvider<TConfig>, event: AgentHookEventDefinition): string;
+export declare function buildAgentHookWindowsCommand<TConfig>(provider: AgentHookProvider<TConfig>, event: AgentHookEventDefinition): string;
+export {};
+//# sourceMappingURL=agent-hook-installer.d.ts.map

package/dist/server/terminal/agent-hooks/agent-hook-installer.js

@@ -0,0 +1,117 @@
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { writePrivateFileAtomicSync } from "../../server/private-files.js";
+export function installAgentHooks(provider, options = {}) {
+    if (provider.install.kind === "plugin-file") {
+        return installAgentHookPluginFile(provider.install, options);
+    }
+    const format = provider.install.format;
+    return updateAgentHookConfig(provider, options, (config) => format.install(config, provider));
+}
+export function uninstallAgentHooks(provider, options = {}) {
+    if (provider.install.kind === "plugin-file") {
+        return uninstallAgentHookPluginFile(provider.install, options);
+    }
+    const format = provider.install.format;
+    return updateAgentHookConfig(provider, options, (config) => format.uninstall(config, provider));
+}
+export function agentHooksAreInstalled(provider, options = {}) {
+    const configPath = resolveAgentHookConfigPath(provider, options);
+    if (!existsSync(configPath)) {
+        return false;
+    }
+    if (provider.install.kind === "plugin-file") {
+        const currentRaw = readFileSync(configPath, "utf8");
+        return normalizeRawConfig(currentRaw) === normalizeRawConfig(provider.install.source);
+    }
+    const config = provider.install.format.parse(readFileSync(configPath, "utf8"));
+    return provider.install.format.isInstalled(config, provider);
+}
+export function resolveAgentHookConfigPath(provider, options = {}) {
+    return resolveAgentHookInstallPath(provider.install, options);
+}
+function resolveAgentHookInstallPath(install, options) {
+    const configDir = options.configDir ??
+        resolveConfiguredDirectory({
+            install,
+            env: options.env ?? process.env,
+            homeDir: options.homeDir ?? homedir(),
+        });
+    return path.join(configDir, install.configFile);
+}
+export function buildAgentHookShellCommand(provider, event) {
+    const hookCommand = `"\${PASEO_HOOK_CLI:-paseo}" hooks ${shellToken(provider.id)} ${shellToken(event.event)}`;
+    return `[ -n "$PASEO_TERMINAL_ID" ] && ${hookCommand}`;
+}
+export function buildAgentHookWindowsCommand(provider, event) {
+    const hookArgs = `hooks ${windowsToken(provider.id)} ${windowsToken(event.event)}`;
+    return `if defined PASEO_TERMINAL_ID (if defined PASEO_HOOK_CLI ("%PASEO_HOOK_CLI%" ${hookArgs}) else (paseo ${hookArgs}))`;
+}
+function installAgentHookPluginFile(install, options) {
+    const configPath = resolveAgentHookInstallPath(install, options);
+    const currentRaw = existsSync(configPath) ? readFileSync(configPath, "utf8") : null;
+    const nextRaw = normalizeRawConfig(install.source);
+    if (currentRaw === null || normalizeRawConfig(currentRaw) !== nextRaw) {
+        writePrivateFileAtomicSync(configPath, nextRaw);
+        return { configPath, changed: true };
+    }
+    return { configPath, changed: false };
+}
+function uninstallAgentHookPluginFile(install, options) {
+    const configPath = resolveAgentHookInstallPath(install, options);
+    if (!existsSync(configPath)) {
+        return { configPath, changed: false };
+    }
+    rmSync(configPath, { force: true });
+    return { configPath, changed: true };
+}
+function updateAgentHookConfig(provider, options, update) {
+    const install = provider.install;
+    if (install.kind !== "config-file") {
+        throw new Error(`Provider ${provider.id} does not use config-file hooks`);
+    }
+    const configPath = resolveAgentHookConfigPath(provider, options);
+    const currentRaw = existsSync(configPath) ? readFileSync(configPath, "utf8") : null;
+    const currentConfig = currentRaw === null ? install.format.empty() : install.format.parse(currentRaw);
+    const nextConfig = update(currentConfig);
+    const nextRaw = install.format.stringify(nextConfig);
+    if (currentRaw === null || nextRaw !== normalizeRawConfig(currentRaw)) {
+        writePrivateFileAtomicSync(configPath, nextRaw);
+        return { configPath, changed: true };
+    }
+    return { configPath, changed: false };
+}
+function resolveConfiguredDirectory(input) {
+    const overrideName = input.install.configDirEnvOverride;
+    const override = overrideName ? input.env[overrideName] : undefined;
+    if (override) {
+        return override;
+    }
+    if (input.install.configDirBase === "xdg-config") {
+        return path.join(resolveXdgConfigHome(input), input.install.configDir);
+    }
+    return path.join(input.homeDir, input.install.configDir);
+}
+function resolveXdgConfigHome(input) {
+    if (input.env.XDG_CONFIG_HOME) {
+        return input.env.XDG_CONFIG_HOME;
+    }
+    return path.join(input.homeDir, ".config");
+}
+function normalizeRawConfig(raw) {
+    return raw.endsWith("\n") ? raw : `${raw}\n`;
+}
+function shellToken(value) {
+    if (/^[A-Za-z0-9_./:-]+$/.test(value)) {
+        return value;
+    }
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function windowsToken(value) {
+    if (/^[A-Za-z0-9_./:-]+$/.test(value)) {
+        return value;
+    }
+    return `"${value.replaceAll('"', '\\"')}"`;
+}
+//# sourceMappingURL=agent-hook-installer.js.map

package/dist/server/terminal/agent-hooks/claude/claude-settings.d.ts

@@ -0,0 +1,7 @@
+import { type AgentHookConfigFormat } from "../agent-hook-installer.js";
+export interface ClaudeSettings {
+    hooks?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export declare const claudeSettingsFormat: AgentHookConfigFormat<ClaudeSettings>;
+//# sourceMappingURL=claude-settings.d.ts.map

package/dist/server/terminal/agent-hooks/claude/claude-settings.js

@@ -0,0 +1,88 @@
+import { buildAgentHookShellCommand } from "../agent-hook-installer.js";
+export const claudeSettingsFormat = {
+    empty() {
+        return {};
+    },
+    parse(raw) {
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed)) {
+            return {};
+        }
+        return parsed;
+    },
+    stringify(config) {
+        return `${JSON.stringify(config, null, 2)}\n`;
+    },
+    install(config, provider) {
+        const install = provider.install;
+        const hooks = normalizeHooks(config.hooks);
+        for (const event of provider.events) {
+            const userEntries = removePaseoHooks(hooks[event.event], install.hookMarker);
+            hooks[event.event] = [
+                ...userEntries,
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildAgentHookShellCommand(provider, event),
+                            timeout: 10,
+                        },
+                    ],
+                },
+            ];
+        }
+        return { ...config, hooks };
+    },
+    uninstall(config, provider) {
+        const install = provider.install;
+        const hooks = normalizeHooks(config.hooks);
+        for (const event of provider.events) {
+            const entries = removePaseoHooks(hooks[event.event], install.hookMarker);
+            if (entries.length > 0) {
+                hooks[event.event] = entries;
+            }
+            else {
+                delete hooks[event.event];
+            }
+        }
+        return { ...config, hooks };
+    },
+    isInstalled(config, provider) {
+        const install = provider.install;
+        const hooks = normalizeHooks(config.hooks);
+        return provider.events.every((event) => normalizeMatchers(hooks[event.event]).some((entry) => normalizeCommandHooks(entry.hooks).some((hook) => commandContainsMarker(hook, install.hookMarker))));
+    },
+};
+function normalizeHooks(value) {
+    return isRecord(value) ? { ...value } : {};
+}
+function normalizeMatchers(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord);
+}
+function normalizeCommandHooks(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord);
+}
+function removePaseoHooks(value, marker) {
+    const entries = [];
+    for (const entry of normalizeMatchers(value)) {
+        const hooks = normalizeCommandHooks(entry.hooks).filter((hook) => !commandContainsMarker(hook, marker));
+        if (hooks.length > 0) {
+            entries.push(Object.assign({}, entry, { hooks }));
+        }
+    }
+    return entries;
+}
+function commandContainsMarker(hook, marker) {
+    return typeof hook.command === "string" && hook.command.includes(marker);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=claude-settings.js.map

package/dist/server/terminal/agent-hooks/claude/claude.d.ts

@@ -0,0 +1,4 @@
+import type { AgentHookProvider } from "../agent-hook-installer.js";
+import { type ClaudeSettings } from "./claude-settings.js";
+export declare const claudeAgentHookProvider: AgentHookProvider<ClaudeSettings>;
+//# sourceMappingURL=claude.d.ts.map

package/dist/server/terminal/agent-hooks/claude/claude.js

@@ -0,0 +1,47 @@
+import { claudeSettingsFormat } from "./claude-settings.js";
+const CLAUDE_EVENT_STATES = {
+    UserPromptSubmit: "running",
+    Stop: "idle",
+    StopFailure: "idle",
+    SessionEnd: "idle",
+};
+export const claudeAgentHookProvider = {
+    id: "claude",
+    events: [
+        { event: "UserPromptSubmit" },
+        { event: "Stop" },
+        { event: "StopFailure" },
+        { event: "SessionEnd" },
+        { event: "Notification" },
+    ],
+    install: {
+        kind: "config-file",
+        configDir: ".claude",
+        configFile: "settings.json",
+        configDirEnvOverride: "CLAUDE_CONFIG_DIR",
+        hookMarker: "hooks claude",
+        format: claudeSettingsFormat,
+    },
+    async resolveActivity({ event, input }) {
+        if (event === "Notification") {
+            const raw = input.isTTY ? null : await input.read();
+            return isIdlePrompt(raw) ? "needs-input" : null;
+        }
+        return CLAUDE_EVENT_STATES[event] ?? null;
+    },
+};
+function isIdlePrompt(raw) {
+    if (!raw)
+        return false;
+    try {
+        const notification = JSON.parse(raw);
+        if (!notification || typeof notification !== "object")
+            return false;
+        const payload = notification;
+        return payload.matcher === "idle_prompt" || payload.reason === "idle_prompt";
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=claude.js.map

package/dist/server/terminal/agent-hooks/codex/codex-settings.d.ts

@@ -0,0 +1,7 @@
+import { type AgentHookConfigFormat } from "../agent-hook-installer.js";
+export interface CodexHooksFile {
+    hooks?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export declare const codexHooksFormat: AgentHookConfigFormat<CodexHooksFile>;
+//# sourceMappingURL=codex-settings.d.ts.map

package/dist/server/terminal/agent-hooks/codex/codex-settings.js

@@ -0,0 +1,99 @@
+import { buildAgentHookShellCommand, buildAgentHookWindowsCommand, } from "../agent-hook-installer.js";
+export const codexHooksFormat = {
+    empty() {
+        return {};
+    },
+    parse(raw) {
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed)) {
+            return {};
+        }
+        return parsed;
+    },
+    stringify(config) {
+        return `${JSON.stringify(config, null, 2)}\n`;
+    },
+    install(config, provider) {
+        const install = provider.install;
+        const hooks = normalizeHooks(config.hooks);
+        for (const event of provider.events) {
+            const userEntries = removePaseoHooks(hooks[event.event], install.hookMarker);
+            hooks[event.event] = [
+                ...userEntries,
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildAgentHookShellCommand(provider, event),
+                            commandWindows: buildAgentHookWindowsCommand(provider, event),
+                            timeout: 10,
+                        },
+                    ],
+                },
+            ];
+        }
+        return { ...config, hooks };
+    },
+    uninstall(config, provider) {
+        const install = provider.install;
+        const hooks = normalizeHooks(config.hooks);
+        for (const event of provider.events) {
+            const entries = removePaseoHooks(hooks[event.event], install.hookMarker);
+            if (entries.length > 0) {
+                hooks[event.event] = entries;
+            }
+            else {
+                delete hooks[event.event];
+            }
+        }
+        return { ...config, hooks };
+    },
+    isInstalled(config, provider) {
+        const install = provider.install;
+        const hooks = normalizeHooks(config.hooks);
+        return provider.events.every((event) => normalizeMatchers(hooks[event.event]).some((entry) => normalizeCommandHooks(entry.hooks).some((hook) => hasPaseoCommands(hook, install.hookMarker))));
+    },
+};
+function normalizeHooks(value) {
+    return isRecord(value) ? { ...value } : {};
+}
+function normalizeMatchers(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord);
+}
+function normalizeCommandHooks(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord);
+}
+function removePaseoHooks(value, marker) {
+    const entries = [];
+    for (const entry of normalizeMatchers(value)) {
+        const hooks = normalizeCommandHooks(entry.hooks).filter((hook) => !commandContainsMarker(hook, marker));
+        if (hooks.length > 0) {
+            entries.push(Object.assign({}, entry, { hooks }));
+        }
+    }
+    return entries;
+}
+function hasPaseoCommands(hook, marker) {
+    return (commandFieldContainsMarker(hook.command, marker) && windowsCommandContainsMarker(hook, marker));
+}
+function commandContainsMarker(hook, marker) {
+    return (commandFieldContainsMarker(hook.command, marker) || windowsCommandContainsMarker(hook, marker));
+}
+function windowsCommandContainsMarker(hook, marker) {
+    return (commandFieldContainsMarker(hook.commandWindows, marker) ||
+        commandFieldContainsMarker(hook.command_windows, marker));
+}
+function commandFieldContainsMarker(value, marker) {
+    return typeof value === "string" && value.includes(marker);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=codex-settings.js.map

package/dist/server/terminal/agent-hooks/codex/codex.d.ts

@@ -0,0 +1,4 @@
+import type { AgentHookProvider } from "../agent-hook-installer.js";
+import { type CodexHooksFile } from "./codex-settings.js";
+export declare const codexAgentHookProvider: AgentHookProvider<CodexHooksFile>;
+//# sourceMappingURL=codex.d.ts.map

package/dist/server/terminal/agent-hooks/codex/codex.js

@@ -0,0 +1,30 @@
+import { codexHooksFormat } from "./codex-settings.js";
+const CODEX_EVENT_STATES = {
+    UserPromptSubmit: "running",
+    PreToolUse: "running",
+    PostToolUse: "running",
+    PermissionRequest: "needs-input",
+    Stop: "idle",
+};
+export const codexAgentHookProvider = {
+    id: "codex",
+    events: [
+        { event: "UserPromptSubmit" },
+        { event: "PreToolUse" },
+        { event: "PostToolUse" },
+        { event: "PermissionRequest" },
+        { event: "Stop" },
+    ],
+    install: {
+        kind: "config-file",
+        configDir: ".codex",
+        configFile: "hooks.json",
+        configDirEnvOverride: "CODEX_HOME",
+        hookMarker: "hooks codex",
+        format: codexHooksFormat,
+    },
+    async resolveActivity({ event }) {
+        return CODEX_EVENT_STATES[event] ?? null;
+    },
+};
+//# sourceMappingURL=codex.js.map

package/dist/server/terminal/agent-hooks/opencode/opencode-plugin.d.ts

@@ -0,0 +1,4 @@
+import type { AgentHookPluginFileInstallStrategy } from "../agent-hook-installer.js";
+export declare const OPENCODE_PLUGIN_SOURCE: string;
+export declare function createOpenCodePluginInstallStrategy(): AgentHookPluginFileInstallStrategy;
+//# sourceMappingURL=opencode-plugin.d.ts.map

package/dist/server/terminal/agent-hooks/opencode/opencode-plugin.js

@@ -0,0 +1,46 @@
+export const OPENCODE_PLUGIN_SOURCE = [
+    "const STATUS_EVENTS = {",
+    '  busy: "session.status.busy",',
+    '  retry: "session.status.retry",',
+    '  idle: "session.status.idle",',
+    "};",
+    "",
+    "function paseoEventFor(event) {",
+    '  if (event?.type === "permission.asked") return "permission.asked";',
+    '  if (event?.type === "permission.replied") return "permission.replied";',
+    '  if (event?.type !== "session.status") return null;',
+    "  return STATUS_EVENTS[event?.properties?.status?.type] ?? null;",
+    "}",
+    "",
+    "function runPaseoHook(event) {",
+    "  if (!process.env.PASEO_TERMINAL_ID) return;",
+    "  try {",
+    '    const child = Bun.spawn(["paseo", "hooks", "opencode", event], {',
+    '      stdin: "ignore",',
+    '      stdout: "ignore",',
+    '      stderr: "ignore",',
+    "    });",
+    "    void child.exited.catch(() => {});",
+    "  } catch {}",
+    "}",
+    "",
+    "export default async () => ({",
+    "  event: async ({ event }) => {",
+    "    const paseoEvent = paseoEventFor(event);",
+    "    if (paseoEvent) runPaseoHook(paseoEvent);",
+    "  },",
+    "});",
+    "",
+].join("\n");
+export function createOpenCodePluginInstallStrategy() {
+    return {
+        kind: "plugin-file",
+        configDir: "opencode",
+        configDirBase: "xdg-config",
+        configFile: "plugins/paseo-terminal-activity.js",
+        configDirEnvOverride: "OPENCODE_CONFIG_DIR",
+        hookMarker: "paseo hooks opencode",
+        source: OPENCODE_PLUGIN_SOURCE,
+    };
+}
+//# sourceMappingURL=opencode-plugin.js.map

package/dist/server/terminal/agent-hooks/opencode/opencode.d.ts

@@ -0,0 +1,3 @@
+import type { AgentHookProvider } from "../agent-hook-installer.js";
+export declare const opencodeAgentHookProvider: AgentHookProvider;
+//# sourceMappingURL=opencode.d.ts.map

package/dist/server/terminal/agent-hooks/opencode/opencode.js

@@ -0,0 +1,23 @@
+import { createOpenCodePluginInstallStrategy } from "./opencode-plugin.js";
+const OPENCODE_EVENT_STATES = {
+    "session.status.busy": "running",
+    "session.status.retry": "running",
+    "session.status.idle": "idle",
+    "permission.asked": "needs-input",
+    "permission.replied": "running",
+};
+export const opencodeAgentHookProvider = {
+    id: "opencode",
+    events: [
+        { event: "session.status.busy" },
+        { event: "session.status.retry" },
+        { event: "session.status.idle" },
+        { event: "permission.asked" },
+        { event: "permission.replied" },
+    ],
+    install: createOpenCodePluginInstallStrategy(),
+    async resolveActivity({ event }) {
+        return OPENCODE_EVENT_STATES[event] ?? null;
+    },
+};
+//# sourceMappingURL=opencode.js.map

package/dist/server/terminal/agent-hooks/provider-registry.d.ts

@@ -0,0 +1,24 @@
+import { type AgentHookActivityInput, type AgentHookActivityState, type AgentHookInstallLogger, type AgentHookInstallOptions, type AgentHookInstallResult, type AgentHookProvider } from "./agent-hook-installer.js";
+import { claudeAgentHookProvider } from "./claude/claude.js";
+import { codexAgentHookProvider } from "./codex/codex.js";
+import { opencodeAgentHookProvider } from "./opencode/opencode.js";
+export type { AgentHookActivityInput, AgentHookActivityState, AgentHookProvider, } from "./agent-hook-installer.js";
+export declare const AGENT_HOOK_PROVIDERS: {
+    [claudeAgentHookProvider.id]: AgentHookProvider<import("./claude/claude-settings.js").ClaudeSettings>;
+    [codexAgentHookProvider.id]: AgentHookProvider<import("./codex/codex-settings.js").CodexHooksFile>;
+    [opencodeAgentHookProvider.id]: AgentHookProvider<unknown>;
+};
+export type AgentHookProviderId = keyof typeof AGENT_HOOK_PROVIDERS;
+export interface AgentHookActivityRequest {
+    provider: string;
+    event: string;
+    input: AgentHookActivityInput;
+}
+export interface RegisteredAgentHookInstallOptions extends AgentHookInstallOptions {
+    logger?: AgentHookInstallLogger;
+}
+export declare function installRegisteredAgentHooks(options?: RegisteredAgentHookInstallOptions): AgentHookInstallResult[];
+export declare function uninstallRegisteredAgentHooks(options?: AgentHookInstallOptions): void;
+export declare function registeredAgentHooksAreInstalled(options?: AgentHookInstallOptions): boolean;
+export declare function resolveHookActivity(request: AgentHookActivityRequest): Promise<AgentHookActivityState | null>;
+//# sourceMappingURL=provider-registry.d.ts.map

package/dist/server/terminal/agent-hooks/provider-registry.js

@@ -0,0 +1,36 @@
+import { agentHooksAreInstalled, installAgentHooks, uninstallAgentHooks, } from "./agent-hook-installer.js";
+import { claudeAgentHookProvider } from "./claude/claude.js";
+import { codexAgentHookProvider } from "./codex/codex.js";
+import { opencodeAgentHookProvider } from "./opencode/opencode.js";
+export const AGENT_HOOK_PROVIDERS = {
+    [claudeAgentHookProvider.id]: claudeAgentHookProvider,
+    [codexAgentHookProvider.id]: codexAgentHookProvider,
+    [opencodeAgentHookProvider.id]: opencodeAgentHookProvider,
+};
+export function installRegisteredAgentHooks(options = {}) {
+    const results = [];
+    for (const provider of Object.values(AGENT_HOOK_PROVIDERS)) {
+        try {
+            results.push(installAgentHooks(provider, options));
+        }
+        catch (error) {
+            options.logger?.warn({ err: error, provider: provider.id }, "Failed to install terminal activity hook provider");
+        }
+    }
+    return results;
+}
+export function uninstallRegisteredAgentHooks(options = {}) {
+    for (const provider of Object.values(AGENT_HOOK_PROVIDERS)) {
+        uninstallAgentHooks(provider, options);
+    }
+}
+export function registeredAgentHooksAreInstalled(options = {}) {
+    return Object.values(AGENT_HOOK_PROVIDERS).every((provider) => agentHooksAreInstalled(provider, options));
+}
+export async function resolveHookActivity(request) {
+    const provider = AGENT_HOOK_PROVIDERS[request.provider.toLowerCase()];
+    if (!provider)
+        return null;
+    return provider.resolveActivity({ event: request.event, input: request.input });
+}
+//# sourceMappingURL=provider-registry.js.map

package/dist/server/terminal/agent-hooks/terminal-agent-hook-setting.d.ts

@@ -0,0 +1,10 @@
+import type { AgentHookInstallLogger, AgentHookInstallOptions } from "./agent-hook-installer.js";
+import type { DaemonConfigStore } from "../../server/daemon-config-store.js";
+interface ApplyTerminalAgentHookSettingOptions {
+    store: DaemonConfigStore;
+    logger?: AgentHookInstallLogger;
+    install?: AgentHookInstallOptions;
+}
+export declare function applyTerminalAgentHookSetting(options: ApplyTerminalAgentHookSettingOptions): () => void;
+export {};
+//# sourceMappingURL=terminal-agent-hook-setting.d.ts.map

package/dist/server/terminal/agent-hooks/terminal-agent-hook-setting.js

@@ -0,0 +1,26 @@
+import { installRegisteredAgentHooks, uninstallRegisteredAgentHooks, } from "./provider-registry.js";
+// Installing agent hooks edits the user's real agent config files, so it only
+// happens when `enableTerminalAgentHooks` is on. At boot we install when enabled
+// and otherwise leave the configs untouched; toggling the setting live installs
+// on enable and removes our marker-matched hooks on disable so opting out cleans
+// up after itself. Returns an unsubscribe for the field-change listener.
+export function applyTerminalAgentHookSetting(options) {
+    const { store, logger, install } = options;
+    const installOptions = { ...install, logger };
+    if (store.get().enableTerminalAgentHooks) {
+        installRegisteredAgentHooks(installOptions);
+    }
+    return store.onFieldChange("enableTerminalAgentHooks", (value) => {
+        if (value === true) {
+            installRegisteredAgentHooks(installOptions);
+            return;
+        }
+        try {
+            uninstallRegisteredAgentHooks(install);
+        }
+        catch (error) {
+            logger?.warn({ err: error }, "Failed to remove terminal activity hooks");
+        }
+    });
+}
+//# sourceMappingURL=terminal-agent-hook-setting.js.map

package/dist/server/terminal/terminal-manager-factory.d.ts

@@ -1,3 +1,6 @@
 import type { TerminalManager } from "./terminal-manager.js";
-export declare function createConfiguredTerminalManager(): TerminalManager;
+export interface ConfiguredTerminalManagerOptions {
+    getTerminalActivityUrl?: () => string | null;
+}
+export declare function createConfiguredTerminalManager(options?: ConfiguredTerminalManagerOptions): TerminalManager;
 //# sourceMappingURL=terminal-manager-factory.d.ts.map