@alan-ai-hq/agent-manager 0.1.113 → 0.1.115

package/dist/native-hook-config.d.ts

@@ -0,0 +1,43 @@
+import type { NativeSessionProviderKind } from "./native-session.js";
+export interface NativeHookRuntime {
+    configPath?: string;
+    homeDir?: string;
+    nodeExecutable?: string;
+    cliEntry?: string;
+    environment?: Record<string, string>;
+    platform?: NodeJS.Platform;
+}
+export interface ClaudeNativeCommandHook {
+    type: "command";
+    command: string;
+    args?: string[];
+    shell?: "bash" | "powershell";
+    timeout: number;
+}
+export declare function nativeHookCommand(input: {
+    configPath: string;
+    nodeExecutable: string;
+    cliEntry: string;
+    environment?: Record<string, string>;
+    platform?: NodeJS.Platform;
+    provider: string;
+    event: string;
+}): ClaudeNativeCommandHook;
+export declare function reconcileClaudeNativeHooks(input?: NativeHookRuntime): boolean;
+export declare function removeClaudeNativeHooks(homeDir?: string): boolean;
+export declare function reconcileCodexNativeHooks(input?: NativeHookRuntime): boolean;
+export declare function removeCodexNativeHooks(homeDir?: string): boolean;
+export declare function reconcileCopilotNativeHooks(input?: NativeHookRuntime): boolean;
+export declare function removeCopilotNativeHooks(homeDir?: string): boolean;
+export declare function reconcileCursorNativeHooks(input?: NativeHookRuntime): boolean;
+export declare function removeCursorNativeHooks(homeDir?: string): boolean;
+export declare function reconcileKimiNativeHooks(input?: NativeHookRuntime): boolean;
+export declare function removeKimiNativeHooks(homeDir?: string): boolean;
+export declare function reconcileGrokNativeHooks(input?: NativeHookRuntime): boolean;
+export declare function removeGrokNativeHooks(homeDir?: string): boolean;
+export declare function reconcileOpencodeNativePlugin(input?: NativeHookRuntime): boolean;
+export declare function removeOpencodeNativePlugin(homeDir?: string): boolean;
+export declare function inspectNativeHooksConfigured(providerKind: NativeSessionProviderKind, homeDir?: string, expectedConfigPath?: string): boolean;
+export declare function extractNativeHookConfigPath(text: string): string | null;
+export declare function readInstalledNativeHookConfigPath(homeDir?: string): string | null;
+//# sourceMappingURL=native-hook-config.d.ts.map

package/dist/native-hook-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-hook-config.d.ts","sourceRoot":"","sources":["../src/native-hook-config.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAqErE,MAAM,WAAW,iBAAiB;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;CAC5B;AAWD,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,GAAG,YAAY,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;CACjB;AAuCD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,uBAAuB,CA8B1B;AAkID,wBAAgB,0BAA0B,CAAC,KAAK,GAAE,iBAAsB,GAAG,OAAO,CAcjF;AAED,wBAAgB,uBAAuB,CAAC,OAAO,SAAY,GAAG,OAAO,CAEpE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,GAAE,iBAAsB,GAAG,OAAO,CAahF;AAED,wBAAgB,sBAAsB,CAAC,OAAO,SAAY,GAAG,OAAO,CAEnE;AAED,wBAAgB,2BAA2B,CAAC,KAAK,GAAE,iBAAsB,GAAG,OAAO,CAoBlF;AAED,wBAAgB,wBAAwB,CAAC,OAAO,SAAY,GAAG,OAAO,CAMrE;AAED,wBAAgB,0BAA0B,CAAC,KAAK,GAAE,iBAAsB,GAAG,OAAO,CAoBjF;AAED,wBAAgB,uBAAuB,CAAC,OAAO,SAAY,GAAG,OAAO,CAepE;AAcD,wBAAgB,wBAAwB,CAAC,KAAK,GAAE,iBAAsB,GAAG,OAAO,CAO/E;AAED,wBAAgB,qBAAqB,CAAC,OAAO,SAAY,GAAG,OAAO,CAOlE;AAED,wBAAgB,wBAAwB,CAAC,KAAK,GAAE,iBAAsB,GAAG,OAAO,CAgB/E;AAED,wBAAgB,qBAAqB,CAAC,OAAO,SAAY,GAAG,OAAO,CAMlE;AAsFD,wBAAgB,6BAA6B,CAAC,KAAK,GAAE,iBAAsB,GAAG,OAAO,CAapF;AAED,wBAAgB,0BAA0B,CAAC,OAAO,SAAY,GAAG,OAAO,CAMvE;AAWD,wBAAgB,4BAA4B,CAC1C,YAAY,EAAE,yBAAyB,EACvC,OAAO,SAAY,EACnB,kBAAkB,CAAC,EAAE,MAAM,GAC1B,OAAO,CAwCT;AA0BD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAiBvE;AAED,wBAAgB,iCAAiC,CAAC,OAAO,SAAY,GAAG,MAAM,GAAG,IAAI,CAoBpF"}

package/dist/native-hook-config.js

@@ -0,0 +1,601 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { homedir, platform as hostPlatform } from "node:os";
+import { dirname, join } from "node:path";
+const ALAN_HOOK_MARKER = "# alan-native-session-hook";
+const ALAN_KIMI_HOOKS_START = "# alan-native-session-hooks:start";
+const ALAN_KIMI_HOOKS_END = "# alan-native-session-hooks:end";
+const ALAN_OPENCODE_PLUGIN_MARKER = "// alan-native-session-plugin";
+const CLAUDE_HOOK_EVENTS = [
+    "SessionStart",
+    "UserPromptSubmit",
+    "PostToolUse",
+    "Stop",
+    "SubagentStart",
+    "SubagentStop",
+    "SessionEnd",
+];
+const CODEX_HOOK_EVENTS = [
+    "SessionStart",
+    "UserPromptSubmit",
+    "PostToolUse",
+    "Stop",
+    "SubagentStart",
+    "SubagentStop",
+    "SessionEnd",
+];
+const COPILOT_HOOK_EVENTS = [
+    "SessionStart",
+    "UserPromptSubmit",
+    "PostToolUse",
+    "Stop",
+    "SubagentStop",
+    "SessionEnd",
+];
+const CURSOR_HOOK_EVENTS = [
+    "sessionStart",
+    "beforeSubmitPrompt",
+    "afterAgentResponse",
+    "stop",
+    "sessionEnd",
+];
+const KIMI_HOOK_EVENTS = [
+    "SessionStart",
+    "UserPromptSubmit",
+    "PostToolUse",
+    "Stop",
+    "Interrupt",
+    "SubagentStart",
+    "SubagentStop",
+    "SessionEnd",
+];
+const GROK_HOOK_EVENTS = [
+    "SessionStart",
+    "UserPromptSubmit",
+    "PostToolUse",
+    "Stop",
+    "StopFailure",
+    "StopCancelled",
+    "SubagentStart",
+    "SubagentStop",
+    "SessionEnd",
+];
+function shellQuote(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function powershellQuote(value) {
+    return `'${value.replaceAll("'", "''")}'`;
+}
+function hookArgs(input) {
+    return [
+        input.cliEntry,
+        "hook",
+        "--config-path",
+        input.configPath,
+        "--provider",
+        input.provider,
+        "--event",
+        input.event,
+        ALAN_HOOK_MARKER,
+    ];
+}
+function checkedEnvironment(environment) {
+    const entries = Object.entries(environment ?? {});
+    for (const [key] of entries) {
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+            throw new Error(`Invalid native hook environment variable: ${key}`);
+        }
+    }
+    return entries;
+}
+export function nativeHookCommand(input) {
+    const args = hookArgs(input);
+    const environment = checkedEnvironment(input.environment);
+    if (environment.length === 0) {
+        return { type: "command", command: input.nodeExecutable, args, timeout: 5 };
+    }
+    if ((input.platform ?? hostPlatform()) === "win32") {
+        const environmentPrefix = environment
+            .map(([key, value]) => `$env:${key}=${powershellQuote(value)}`)
+            .join("; ");
+        const command = [input.nodeExecutable, ...args].map(powershellQuote).join(" ");
+        return {
+            type: "command",
+            shell: "powershell",
+            command: `${environmentPrefix}; & ${command}`,
+            timeout: 5,
+        };
+    }
+    const environmentPrefix = environment
+        .map(([key, value]) => `${key}=${shellQuote(value)}`)
+        .join(" ");
+    const command = [input.nodeExecutable, ...args].map(shellQuote).join(" ");
+    return {
+        type: "command",
+        shell: "bash",
+        command: `${environmentPrefix} ${command}`,
+        timeout: 5,
+    };
+}
+function nativeShellCommand(runtime, provider, event, platform = runtime.platform) {
+    const args = hookArgs({
+        configPath: runtime.configPath,
+        cliEntry: runtime.cliEntry,
+        provider,
+        event,
+    });
+    const environment = checkedEnvironment(runtime.environment);
+    if (platform === "win32") {
+        const prefix = environment
+            .map(([key, value]) => `$env:${key}=${powershellQuote(value)}`)
+            .join("; ");
+        const command = `& ${[runtime.nodeExecutable, ...args].map(powershellQuote).join(" ")}`;
+        return prefix ? `${prefix}; ${command}` : command;
+    }
+    const prefix = environment.map(([key, value]) => `${key}=${shellQuote(value)}`).join(" ");
+    const command = [runtime.nodeExecutable, ...args].map(shellQuote).join(" ");
+    return prefix ? `${prefix} ${command}` : command;
+}
+function resolveRuntime(input = {}) {
+    const cliEntry = input.cliEntry ?? process.argv[1];
+    const configPath = input.configPath ?? process.env.ALAN_AGENT_CONFIG_PATH;
+    if (!cliEntry)
+        throw new Error("Cannot resolve the alan-agent CLI entrypoint");
+    if (!configPath?.trim()) {
+        throw new Error("Cannot install native hooks without an exact Alan agent config path");
+    }
+    return {
+        configPath,
+        homeDir: input.homeDir ?? homedir(),
+        nodeExecutable: input.nodeExecutable ?? process.execPath,
+        cliEntry,
+        environment: input.environment,
+        platform: input.platform ?? hostPlatform(),
+    };
+}
+function readSettings(path, providerLabel) {
+    if (!existsSync(path))
+        return {};
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            throw new Error("settings root must be an object");
+        }
+        return value;
+    }
+    catch (error) {
+        const backup = `${path}.malformed-${Date.now()}.bak`;
+        copyFileSync(path, backup);
+        throw new Error(`${providerLabel} settings were malformed and copied to ${backup}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function withoutAlanEntries(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((entry) => !JSON.stringify(entry).includes(ALAN_HOOK_MARKER));
+}
+function writeSettings(path, settings) {
+    const serialized = `${JSON.stringify(settings, null, 2)}\n`;
+    if (existsSync(path) && readFileSync(path, "utf8") === serialized)
+        return false;
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporary, serialized, { mode: 0o600 });
+    renameSync(temporary, path);
+    return true;
+}
+function writeTextFile(path, content) {
+    if (existsSync(path) && readFileSync(path, "utf8") === content)
+        return false;
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporary, content, { mode: 0o600 });
+    renameSync(temporary, path);
+    return true;
+}
+function withoutMarkedSection(content, start, end) {
+    const startIndex = content.indexOf(start);
+    const endIndex = content.indexOf(end);
+    if (startIndex < 0 && endIndex < 0)
+        return content;
+    if (startIndex < 0 || endIndex < startIndex) {
+        throw new Error(`Malformed Alan-owned configuration section: ${start}`);
+    }
+    const afterEnd = endIndex + end.length;
+    return `${content.slice(0, startIndex).trimEnd()}\n${content.slice(afterEnd).trimStart()}`.trim();
+}
+function reconcileNestedCommandHooks(input) {
+    const settings = readSettings(input.path, input.providerLabel);
+    const currentHooks = settings.hooks && typeof settings.hooks === "object" && !Array.isArray(settings.hooks)
+        ? settings.hooks
+        : {};
+    const hooks = { ...currentHooks };
+    for (const event of input.events) {
+        hooks[event] = [...withoutAlanEntries(currentHooks[event]), { hooks: [input.command(event)] }];
+    }
+    return writeSettings(input.path, { ...settings, hooks });
+}
+function removeNestedCommandHooks(path, providerLabel) {
+    if (!existsSync(path))
+        return false;
+    const settings = readSettings(path, providerLabel);
+    if (!settings.hooks || typeof settings.hooks !== "object" || Array.isArray(settings.hooks)) {
+        return false;
+    }
+    const hooks = {};
+    let removed = false;
+    for (const [event, groups] of Object.entries(settings.hooks)) {
+        const retained = withoutAlanEntries(groups);
+        if (Array.isArray(groups) && retained.length !== groups.length)
+            removed = true;
+        if (retained.length > 0)
+            hooks[event] = retained;
+    }
+    return removed ? writeSettings(path, { ...settings, hooks }) : false;
+}
+export function reconcileClaudeNativeHooks(input = {}) {
+    const runtime = resolveRuntime(input);
+    return reconcileNestedCommandHooks({
+        path: join(runtime.homeDir, ".claude", "settings.json"),
+        providerLabel: "Claude",
+        events: CLAUDE_HOOK_EVENTS,
+        command: (event) => ({
+            ...nativeHookCommand({
+                ...runtime,
+                provider: "claude_cli",
+                event,
+            }),
+        }),
+    });
+}
+export function removeClaudeNativeHooks(homeDir = homedir()) {
+    return removeNestedCommandHooks(join(homeDir, ".claude", "settings.json"), "Claude");
+}
+export function reconcileCodexNativeHooks(input = {}) {
+    const runtime = resolveRuntime(input);
+    return reconcileNestedCommandHooks({
+        path: join(runtime.homeDir, ".codex", "hooks.json"),
+        providerLabel: "Codex",
+        events: CODEX_HOOK_EVENTS,
+        command: (event) => ({
+            type: "command",
+            command: nativeShellCommand(runtime, "codex_app_server", event, "darwin"),
+            commandWindows: nativeShellCommand(runtime, "codex_app_server", event, "win32"),
+            timeout: event === "SessionEnd" ? 3 : 5,
+        }),
+    });
+}
+export function removeCodexNativeHooks(homeDir = homedir()) {
+    return removeNestedCommandHooks(join(homeDir, ".codex", "hooks.json"), "Codex");
+}
+export function reconcileCopilotNativeHooks(input = {}) {
+    const runtime = resolveRuntime(input);
+    const path = join(runtime.homeDir, ".copilot", "hooks", "alan-native-session.json");
+    if (existsSync(path) && !readFileSync(path, "utf8").includes(ALAN_HOOK_MARKER)) {
+        throw new Error(`Refusing to overwrite non-Alan Copilot hook configuration at ${path}`);
+    }
+    const hooks = Object.fromEntries(COPILOT_HOOK_EVENTS.map((event) => [
+        event,
+        [
+            {
+                type: "command",
+                bash: nativeShellCommand(runtime, "copilot_cli", event, "darwin"),
+                powershell: nativeShellCommand(runtime, "copilot_cli", event, "win32"),
+                timeoutSec: event === "SessionEnd" ? 3 : 5,
+            },
+        ],
+    ]));
+    return writeSettings(path, { version: 1, hooks });
+}
+export function removeCopilotNativeHooks(homeDir = homedir()) {
+    const path = join(homeDir, ".copilot", "hooks", "alan-native-session.json");
+    if (!existsSync(path))
+        return false;
+    if (!readFileSync(path, "utf8").includes(ALAN_HOOK_MARKER))
+        return false;
+    rmSync(path);
+    return true;
+}
+export function reconcileCursorNativeHooks(input = {}) {
+    const runtime = resolveRuntime(input);
+    const path = join(runtime.homeDir, ".cursor", "hooks.json");
+    const settings = readSettings(path, "Cursor");
+    const currentHooks = settings.hooks && typeof settings.hooks === "object" && !Array.isArray(settings.hooks)
+        ? settings.hooks
+        : {};
+    const hooks = { ...currentHooks };
+    for (const event of CURSOR_HOOK_EVENTS) {
+        hooks[event] = [
+            ...withoutAlanEntries(currentHooks[event]),
+            {
+                type: "command",
+                command: nativeShellCommand(runtime, "cursor_agent_cli", event),
+                timeout: 5,
+            },
+        ];
+    }
+    return writeSettings(path, { ...settings, version: settings.version ?? 1, hooks });
+}
+export function removeCursorNativeHooks(homeDir = homedir()) {
+    const path = join(homeDir, ".cursor", "hooks.json");
+    if (!existsSync(path))
+        return false;
+    const settings = readSettings(path, "Cursor");
+    if (!settings.hooks || typeof settings.hooks !== "object" || Array.isArray(settings.hooks)) {
+        return false;
+    }
+    const hooks = {};
+    let removed = false;
+    for (const [event, entries] of Object.entries(settings.hooks)) {
+        const retained = withoutAlanEntries(entries);
+        if (Array.isArray(entries) && retained.length !== entries.length)
+            removed = true;
+        if (retained.length > 0)
+            hooks[event] = retained;
+    }
+    return removed ? writeSettings(path, { ...settings, hooks }) : false;
+}
+function kimiHookSection(runtime) {
+    const hooks = KIMI_HOOK_EVENTS.map((event) => [
+        "[[hooks]]",
+        `event = ${JSON.stringify(event)}`,
+        `command = ${JSON.stringify(nativeShellCommand(runtime, "kimi_cli", event))}`,
+        `timeout = ${event === "SessionEnd" ? 3 : 5}`,
+    ].join("\n")).join("\n\n");
+    return `${ALAN_KIMI_HOOKS_START}\n${hooks}\n${ALAN_KIMI_HOOKS_END}`;
+}
+export function reconcileKimiNativeHooks(input = {}) {
+    const runtime = resolveRuntime(input);
+    const path = join(runtime.homeDir, ".kimi-code", "config.toml");
+    const current = existsSync(path) ? readFileSync(path, "utf8") : "";
+    const userContent = withoutMarkedSection(current, ALAN_KIMI_HOOKS_START, ALAN_KIMI_HOOKS_END);
+    const content = `${userContent.trimEnd()}${userContent.trim() ? "\n\n" : ""}${kimiHookSection(runtime)}\n`;
+    return writeTextFile(path, content);
+}
+export function removeKimiNativeHooks(homeDir = homedir()) {
+    const path = join(homeDir, ".kimi-code", "config.toml");
+    if (!existsSync(path))
+        return false;
+    const current = readFileSync(path, "utf8");
+    const content = withoutMarkedSection(current, ALAN_KIMI_HOOKS_START, ALAN_KIMI_HOOKS_END);
+    if (content === current)
+        return false;
+    return writeTextFile(path, content ? `${content.trimEnd()}\n` : "");
+}
+export function reconcileGrokNativeHooks(input = {}) {
+    const runtime = resolveRuntime(input);
+    const path = join(runtime.homeDir, ".grok", "hooks", "alan-native-session.json");
+    if (existsSync(path) && !readFileSync(path, "utf8").includes(ALAN_HOOK_MARKER)) {
+        throw new Error(`Refusing to overwrite non-Alan Grok hook configuration at ${path}`);
+    }
+    return reconcileNestedCommandHooks({
+        path,
+        providerLabel: "Grok",
+        events: GROK_HOOK_EVENTS,
+        command: (event) => ({
+            type: "command",
+            command: nativeShellCommand(runtime, "grok_cli", event),
+            timeout: event === "SessionEnd" ? 3 : 5,
+        }),
+    });
+}
+export function removeGrokNativeHooks(homeDir = homedir()) {
+    const path = join(homeDir, ".grok", "hooks", "alan-native-session.json");
+    if (!existsSync(path))
+        return false;
+    if (!readFileSync(path, "utf8").includes(ALAN_HOOK_MARKER))
+        return false;
+    rmSync(path);
+    return true;
+}
+function opencodePluginSource(runtime) {
+    const command = [
+        runtime.nodeExecutable,
+        runtime.cliEntry,
+        "hook",
+        "--config-path",
+        runtime.configPath,
+        "--provider",
+        "opencode_cli",
+    ];
+    const environment = runtime.environment ?? {};
+    return `${ALAN_OPENCODE_PLUGIN_MARKER}
+const command = ${JSON.stringify(command)}
+const environment = ${JSON.stringify(environment)}
+
+export const AlanNativeSessionPlugin = async ({ directory }) => {
+  const textByPart = new Map()
+  const userPartIdsBySession = new Map()
+  const send = async (event, payload) => {
+    const proc = Bun.spawn({
+      cmd: [...command, "--event", event, ${JSON.stringify(ALAN_HOOK_MARKER)}],
+      env: { ...process.env, ...environment },
+      stdin: "pipe",
+      stdout: "ignore",
+      stderr: "ignore",
+    })
+    proc.stdin.write(JSON.stringify({ ...payload, cwd: payload.cwd ?? directory }))
+    proc.stdin.end()
+    await proc.exited
+  }
+
+  return {
+    "chat.message": async (input, output) => {
+      userPartIdsBySession.set(
+        input.sessionID,
+        new Set(output.parts.map((part) => part.id).filter(Boolean)),
+      )
+      const prompt = output.parts
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("\\n")
+      await send("user_prompt", { session_id: input.sessionID, prompt })
+    },
+    event: async ({ event }) => {
+      if (event.type === "session.created") {
+        await send("session_start", { session_id: event.properties.info.id })
+        return
+      }
+      if (event.type === "session.idle") {
+        await send("stop", { session_id: event.properties.sessionID })
+        return
+      }
+      if (event.type === "session.deleted") {
+        userPartIdsBySession.delete(event.properties.info.id)
+        await send("session_end", { session_id: event.properties.info.id })
+        return
+      }
+      if (event.type === "session.error" && event.properties.sessionID) {
+        await send("stop", {
+          session_id: event.properties.sessionID,
+          error: event.properties.error,
+        })
+        return
+      }
+      if (event.type !== "message.part.updated") return
+      const part = event.properties.part
+      if (part.type !== "text" && part.type !== "reasoning") return
+      if (userPartIdsBySession.get(part.sessionID)?.has(part.id)) return
+      const previous = textByPart.get(part.id) ?? ""
+      const complete = typeof part.text === "string" ? part.text : ""
+      const text = event.properties.delta ?? (complete.startsWith(previous) ? complete.slice(previous.length) : complete)
+      textByPart.set(part.id, complete)
+      if (!text) return
+      await send("transcript_update", {
+        session_id: part.sessionID,
+        source_cursor: part.id + ":" + complete.length,
+        ...(part.type === "reasoning" ? { thinking: text } : { transcript_delta: text }),
+      })
+    },
+  }
+}
+`;
+}
+export function reconcileOpencodeNativePlugin(input = {}) {
+    const runtime = resolveRuntime(input);
+    const path = join(runtime.homeDir, ".config", "opencode", "plugins", "alan-native-session.js");
+    if (existsSync(path) && !readFileSync(path, "utf8").includes(ALAN_OPENCODE_PLUGIN_MARKER)) {
+        throw new Error(`Refusing to overwrite non-Alan OpenCode plugin at ${path}`);
+    }
+    const source = opencodePluginSource(runtime);
+    if (existsSync(path) && readFileSync(path, "utf8") === source)
+        return false;
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporary, source, { mode: 0o600 });
+    renameSync(temporary, path);
+    return true;
+}
+export function removeOpencodeNativePlugin(homeDir = homedir()) {
+    const path = join(homeDir, ".config", "opencode", "plugins", "alan-native-session.js");
+    if (!existsSync(path))
+        return false;
+    if (!readFileSync(path, "utf8").includes(ALAN_OPENCODE_PLUGIN_MARKER))
+        return false;
+    rmSync(path);
+    return true;
+}
+function configFileContainsMarker(path, marker) {
+    if (!existsSync(path))
+        return false;
+    try {
+        return readFileSync(path, "utf8").includes(marker);
+    }
+    catch {
+        return false;
+    }
+}
+export function inspectNativeHooksConfigured(providerKind, homeDir = homedir(), expectedConfigPath) {
+    const matchesActiveProfile = (path, marker) => {
+        if (!configFileContainsMarker(path, marker))
+            return false;
+        if (!expectedConfigPath)
+            return true;
+        try {
+            return extractNativeHookConfigPath(readFileSync(path, "utf8")) === expectedConfigPath;
+        }
+        catch {
+            return false;
+        }
+    };
+    switch (providerKind) {
+        case "claude_cli":
+            return matchesActiveProfile(join(homeDir, ".claude", "settings.json"), ALAN_HOOK_MARKER);
+        case "codex_app_server":
+            return matchesActiveProfile(join(homeDir, ".codex", "hooks.json"), ALAN_HOOK_MARKER);
+        case "copilot_cli":
+            return matchesActiveProfile(join(homeDir, ".copilot", "hooks", "alan-native-session.json"), ALAN_HOOK_MARKER);
+        case "cursor_agent_cli":
+            return matchesActiveProfile(join(homeDir, ".cursor", "hooks.json"), ALAN_HOOK_MARKER);
+        case "kimi_cli":
+            return matchesActiveProfile(join(homeDir, ".kimi-code", "config.toml"), ALAN_KIMI_HOOKS_START);
+        case "grok_cli":
+            return matchesActiveProfile(join(homeDir, ".grok", "hooks", "alan-native-session.json"), ALAN_HOOK_MARKER);
+        case "opencode_cli":
+            return matchesActiveProfile(join(homeDir, ".config", "opencode", "plugins", "alan-native-session.js"), ALAN_OPENCODE_PLUGIN_MARKER);
+        default:
+            return false;
+    }
+}
+function nativeHookConfigFilePath(providerKind, homeDir) {
+    switch (providerKind) {
+        case "claude_cli":
+            return join(homeDir, ".claude", "settings.json");
+        case "codex_app_server":
+            return join(homeDir, ".codex", "hooks.json");
+        case "copilot_cli":
+            return join(homeDir, ".copilot", "hooks", "alan-native-session.json");
+        case "cursor_agent_cli":
+            return join(homeDir, ".cursor", "hooks.json");
+        case "kimi_cli":
+            return join(homeDir, ".kimi-code", "config.toml");
+        case "grok_cli":
+            return join(homeDir, ".grok", "hooks", "alan-native-session.json");
+        case "opencode_cli":
+            return join(homeDir, ".config", "opencode", "plugins", "alan-native-session.js");
+        default:
+            return null;
+    }
+}
+export function extractNativeHookConfigPath(text) {
+    const jsonMatch = text.match(/"--config-path"\s*,\s*"((?:\\"|[^"])*)"/);
+    if (jsonMatch?.[1]) {
+        try {
+            return JSON.parse(`"${jsonMatch[1]}"`);
+        }
+        catch { }
+    }
+    const match = text.match(/(?:['"])?--config-path(?:['"])?(?:=|\s+)('(?:\\'|[^'])*'|"(?:\\"|[^"])*"|[^\s#]+)/);
+    if (!match?.[1])
+        return null;
+    const raw = match[1];
+    if (raw.startsWith("'") || raw.startsWith('"')) {
+        return raw.slice(1, -1).replaceAll(String.raw `\'`, "'").replaceAll(String.raw `\"`, '"');
+    }
+    return raw;
+}
+export function readInstalledNativeHookConfigPath(homeDir = homedir()) {
+    const providerKinds = [
+        "claude_cli",
+        "cursor_agent_cli",
+        "codex_app_server",
+        "copilot_cli",
+        "kimi_cli",
+        "grok_cli",
+        "opencode_cli",
+    ];
+    for (const providerKind of providerKinds) {
+        if (!inspectNativeHooksConfigured(providerKind, homeDir))
+            continue;
+        const path = nativeHookConfigFilePath(providerKind, homeDir);
+        if (!path || !existsSync(path))
+            continue;
+        try {
+            const configPath = extractNativeHookConfigPath(readFileSync(path, "utf8"));
+            if (configPath)
+                return configPath;
+        }
+        catch { }
+    }
+    return null;
+}
+//# sourceMappingURL=native-hook-config.js.map