@messenger-agent/claude-agent 0.24.0-alpha.2

package/dist/app.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from "hono";
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default app;

package/dist/app.js

@@ -0,0 +1,15 @@
+import { Hono } from "hono";
+import { logger as honoLogger } from "hono/logger";
+import chat from "./routes/chat.js";
+import { logger } from "@messenger-agent/shared/logger";
+import { agentAuthMiddleware } from "@messenger-agent/shared/agent-auth";
+import { appConfig } from "./config.js";
+import { installAgentActivityResponder } from "@messenger-agent/shared/agent-activity";
+import { claudeActivitySnapshot } from "./routes/chat.js";
+const app = new Hono();
+installAgentActivityResponder("claude", claudeActivitySnapshot);
+app.use(honoLogger((str, ...rest) => logger.info(str, ...rest)));
+app.get("/health", (c) => c.json({ status: "ok", agent: "claude" }));
+app.use("/*", agentAuthMiddleware(appConfig.authTokens));
+app.route("/", chat);
+export default app;

package/dist/assets/codex-home/AGENTS.md

@@ -0,0 +1,50 @@
+## Merge Request and Pull Request Workflow
+
+- When code changes are complete, commit the changes, push a `feat/*` or `fix/*` branch, and create the corresponding merge request or pull request by default.
+- After creating a merge request or pull request, include the created MR/PR link in the response.
+- For GitLab merge request titles and descriptions, use the user's original language.
+- For GitHub pull request titles and descriptions, always use English.
+
+## Response Style
+
+- Reply in the same language the user used in their message. If the user writes in Chinese, answer in Chinese; if in English, answer in English.
+- When referencing workspace files or directories in a response, you may use Markdown links whose targets are absolute paths. The Matrix client opens these links in the current room workspace.
+
+## Hosting Tools
+
+- Repositories hosted on `git.easyops.local` are internal GitLab projects. Use `glab` for merge requests and other GitLab operations.
+- Repositories hosted on `github.com` are GitHub projects. Use `gh` for pull requests and other GitHub operations.
+- When creating or updating merge requests or pull requests with multiline Markdown bodies, do not pass the body directly inside a shell double-quoted argument. Markdown backticks and `$...` can be interpreted by the shell and corrupt the description. Write the body to a temporary file with a single-quoted heredoc first. For `gh`, pass the file with `--body-file <file>`. For the currently installed `glab`, which does not support `--description-file`, pass the file contents through a variable or command substitution, for example `body=$(cat "$file"); glab mr create --description "$body"`; command substitution output is not re-parsed for Markdown backticks. When a temporary file is used for a merge request or pull request description, delete it after the create or update operation completes successfully.
+
+## Git Conventions
+
+- Use English Conventional Commits for commit messages.
+- When making a git commit for a Matrix chat request, set the commit author to the last user who asked for the commit-triggering work. If there is no known mapping from that Matrix user ID to a git author name and email, ask the user for the author identity before committing.
+- Unless the user explicitly asks for it, do not proactively run code formatting; commit hooks handle formatting automatically. If related files are formatted after a commit, that is expected behavior.
+
+### Matrix Git Authors
+
+By default, map git author from the Matrix user localpart, and always use `@easyops.cn` as the email domain suffix.
+
+Example: `@tom:m.elevo.vip` -> `tom <tom@easyops.cn>`.
+
+## Task Management
+
+- Managed task operations require explicit task-management capabilities from the agent runtime.
+- Unless the user explicitly requests another tracking method, use managed task tools by default to track and manage problems and requirements.
+- Prefer existing task records over assumptions before updating or continuing a managed task.
+- Do not invent missing requirements, plans, decisions, or completion status. Ask the user when task intent or state is ambiguous.
+- When creating or updating managed tasks, write the task title and task documents in the user's original language.
+- When the user asks an Agent assistant to plan or implement a managed task, set that task's `assignee` to the Agent assistant itself.
+- When starting execution for a managed task, update the task's `workdir` to the workspace directory where the implementation is being performed.
+- When continuing a managed task that already has `workdir`, work in that directory by default.
+- Keep task titles concise; put detailed requirements, plans, notes, and results in task documents when the runtime supports them.
+
+Supported task statuses:
+
+- `backlog`
+- `planned`
+- `in_progress`
+- `completed`
+
+Only mark a task as `completed` after the related merge request or pull request has been merged. Completing code changes and opening an MR/PR is not enough to mark the task as completed.

package/dist/claude.d.ts

@@ -0,0 +1 @@
+export { query, type Options, type PermissionMode, type Query, type SDKMessage, type SDKResultMessage, type SDKUserMessage, } from "@anthropic-ai/claude-agent-sdk";

package/dist/claude.js

@@ -0,0 +1 @@
+export { query, } from "@anthropic-ai/claude-agent-sdk";

package/dist/config.d.ts

@@ -0,0 +1,30 @@
+import { type AgentAuthConfig, type AgentWorkspacesConfig, type GitInitConfig } from "@messenger-agent/shared/agent-config";
+import { type LogLevel } from "@messenger-agent/shared/logger";
+export type AppConfig = {
+    configPath: string;
+    logLevel: LogLevel;
+    logFile?: string;
+    port: number;
+    fileUploads: {
+        tempDir: string;
+    };
+    dataDir: string;
+    claude: {
+        apiKey?: string;
+        baseUrl?: string;
+        defaultModel?: string;
+        maxTurns?: number;
+        askTimeoutMs: number;
+        sessionIdleTimeoutMs: number;
+    };
+    tunnel: {
+        enabled: boolean;
+        serverUrl?: string;
+        tunnelId?: string;
+        token?: string;
+        reconnectInitialMs: number;
+        reconnectMaxMs: number;
+        heartbeatIntervalMs: number;
+    };
+} & GitInitConfig & AgentAuthConfig & AgentWorkspacesConfig;
+export declare const appConfig: AppConfig;

package/dist/config.js

@@ -0,0 +1,147 @@
+import { existsSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { parse } from "yaml";
+import { z } from "zod";
+import { normalizeOptional, parseAgentAuthConfig, parseAgentWorkspacesConfig, parseGitInitConfig, } from "@messenger-agent/shared/agent-config";
+import { logger, normalizeLogLevel, setLogFile, setLogLevel } from "@messenger-agent/shared/logger";
+const defaultTunnelServerUrl = "wss://m.elevo.vip/agent-bridge/tunnel";
+const defaultClaudeBaseUrl = "https://m.elevo.vip/agent-bridge/llm";
+const RawConfigSchema = z
+    .object({
+    log_level: z.string().optional(),
+    port: z.coerce.number().int().positive().optional(),
+    auth_tokens: z.record(z.string(), z.string()).optional(),
+    workspaces: z
+        .array(z.object({
+        id: z.string().optional(),
+        name: z.string().optional(),
+        path: z.string().optional(),
+    }))
+        .optional(),
+    file_uploads: z
+        .object({
+        temp_dir: z.string().optional(),
+    })
+        .optional(),
+    data_dir: z.string().optional(),
+    claude: z
+        .object({
+        port: z.coerce.number().int().positive().optional(),
+        data_dir: z.string().optional(),
+        file_uploads: z.object({ temp_dir: z.string().optional() }).optional(),
+        api_key: z.string().optional(),
+        base_url: z.string().optional(),
+        default_model: z.string().optional(),
+        max_turns: z.coerce.number().int().positive().optional(),
+        ask_timeout_ms: z.coerce.number().int().positive().optional(),
+        session_idle_timeout_ms: z.coerce.number().int().positive().optional(),
+    })
+        .optional(),
+    gitlab: z
+        .object({
+        ca_cert_path: z.string().optional(),
+        host: z.string().optional(),
+    })
+        .optional(),
+    git: z
+        .object({
+        co_authors: z.array(z.string()).optional(),
+    })
+        .optional(),
+    tunnel: z
+        .object({
+        enabled: z.boolean().optional(),
+        server_url: z.string().optional(),
+        tunnel_id: z.string().optional(),
+        token: z.string().optional(),
+        reconnect_initial_ms: z.number().int().positive().optional(),
+        reconnect_max_ms: z.number().int().positive().optional(),
+        heartbeat_interval_ms: z.number().int().positive().optional(),
+    })
+        .optional(),
+})
+    .loose();
+function loadConfig() {
+    const configPath = process.env.AGENT_CONFIG_PATH ?? "./agent-config.yaml";
+    if (!existsSync(configPath)) {
+        const dataDir = "/data";
+        const logFile = join(dataDir, "logs", "claude-agent.log");
+        setLogLevel("info");
+        setLogFile(logFile);
+        logger.warn(`Config file not found at ${configPath}`);
+        return {
+            configPath,
+            logLevel: "info",
+            logFile,
+            port: 3000,
+            fileUploads: { tempDir: join(tmpdir(), "claude-agent-uploads") },
+            dataDir,
+            claude: { askTimeoutMs: 43_200_000, sessionIdleTimeoutMs: 3_600_000 },
+            tunnel: {
+                enabled: false,
+                reconnectInitialMs: 1000,
+                reconnectMaxMs: 30000,
+                heartbeatIntervalMs: 30000,
+            },
+            ...parseAgentAuthConfig({}),
+            ...parseAgentWorkspacesConfig({}),
+            ...parseGitInitConfig({}),
+        };
+    }
+    let parsedYaml;
+    try {
+        parsedYaml = parse(readFileSync(configPath, "utf-8"));
+    }
+    catch (err) {
+        logger.error(`Failed to parse config file at ${configPath}:`, err);
+        parsedYaml = {};
+    }
+    const raw = RawConfigSchema.safeParse(parsedYaml ?? {});
+    if (!raw.success) {
+        logger.error(`Invalid config format at ${configPath}:`, raw.error.issues);
+    }
+    const data = raw.success ? raw.data : {};
+    const logLevel = normalizeLogLevel(data.log_level);
+    const dataDir = normalizeOptional(data.claude?.data_dir) ?? normalizeOptional(data.data_dir) ?? "/data";
+    const logFile = join(dataDir, "logs", "claude-agent.log");
+    const tunnelEnabled = data.tunnel?.enabled ?? false;
+    const tunnelToken = normalizeOptional(data.tunnel?.token);
+    setLogLevel(logLevel);
+    setLogFile(logFile);
+    return {
+        configPath,
+        logLevel,
+        logFile,
+        port: data.claude?.port ?? data.port ?? 3000,
+        fileUploads: {
+            tempDir: normalizeOptional(data.claude?.file_uploads?.temp_dir) ??
+                normalizeOptional(data.file_uploads?.temp_dir) ??
+                join(tmpdir(), "claude-agent-uploads"),
+        },
+        dataDir,
+        claude: {
+            apiKey: normalizeOptional(data.claude?.api_key) ?? (tunnelEnabled ? tunnelToken : undefined),
+            baseUrl: normalizeOptional(data.claude?.base_url) ?? (tunnelEnabled ? defaultClaudeBaseUrl : undefined),
+            defaultModel: normalizeOptional(data.claude?.default_model),
+            maxTurns: data.claude?.max_turns,
+            askTimeoutMs: Number.parseInt(process.env.CLAUDE_ASK_TIMEOUT_MS ?? "", 10) || data.claude?.ask_timeout_ms || 43_200_000,
+            sessionIdleTimeoutMs: Number.parseInt(process.env.CLAUDE_SESSION_IDLE_TIMEOUT_MS ?? "", 10) ||
+                data.claude?.session_idle_timeout_ms ||
+                3_600_000,
+        },
+        tunnel: {
+            enabled: tunnelEnabled,
+            serverUrl: normalizeOptional(data.tunnel?.server_url) ?? (tunnelEnabled ? defaultTunnelServerUrl : undefined),
+            tunnelId: normalizeOptional(data.tunnel?.tunnel_id),
+            token: tunnelToken,
+            reconnectInitialMs: data.tunnel?.reconnect_initial_ms ?? 1000,
+            reconnectMaxMs: data.tunnel?.reconnect_max_ms ?? 30000,
+            heartbeatIntervalMs: data.tunnel?.heartbeat_interval_ms ?? 30000,
+        },
+        ...parseAgentAuthConfig(data),
+        ...parseAgentWorkspacesConfig(data),
+        ...parseGitInitConfig(data),
+    };
+}
+export const appConfig = loadConfig();

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,19 @@
+import { serve } from "@hono/node-server";
+import app from "./app.js";
+import { appConfig } from "./config.js";
+import { initGit } from "@messenger-agent/shared/git-init";
+import { logger } from "@messenger-agent/shared/logger";
+import { startClaudeTunnelClient } from "./tunnel-client.js";
+const port = appConfig.port;
+try {
+    await initGit(appConfig);
+}
+catch (err) {
+    logger.warn("Git initialization failed; continuing agent startup:", err);
+}
+const tunnelClient = startClaudeTunnelClient(appConfig.tunnel);
+if (!tunnelClient) {
+    serve({ fetch: app.fetch, port }, () => {
+        logger.info(`claude-agent listening on http://0.0.0.0:${port}`);
+    });
+}

package/dist/input-queue.d.ts

@@ -0,0 +1,8 @@
+import type { SDKUserMessage } from "./claude.js";
+export type InputQueue = {
+    iterable: AsyncIterable<SDKUserMessage>;
+    push(message: SDKUserMessage): void;
+    close(): void;
+    readonly closed: boolean;
+};
+export declare function createInputQueue(): InputQueue;

package/dist/input-queue.js

@@ -0,0 +1,40 @@
+export function createInputQueue() {
+    const pending = [];
+    let closed = false;
+    let wake;
+    const wakeUp = () => {
+        const current = wake;
+        wake = undefined;
+        current?.();
+    };
+    return {
+        iterable: {
+            async *[Symbol.asyncIterator]() {
+                while (true) {
+                    while (pending.length > 0)
+                        yield pending.shift();
+                    if (closed)
+                        return;
+                    await new Promise((resolve) => {
+                        wake = resolve;
+                    });
+                }
+            },
+        },
+        push(message) {
+            if (closed)
+                throw new Error("Claude input queue is closed");
+            pending.push(message);
+            wakeUp();
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            wakeUp();
+        },
+        get closed() {
+            return closed;
+        },
+    };
+}

package/dist/live-session.d.ts

@@ -0,0 +1,69 @@
+import type { ManagedTaskExecutionContext } from "@messenger-agent/shared/managed-task-tools";
+import { type Options, type PermissionMode, type SDKMessage } from "./claude.js";
+type CanUseTool = NonNullable<Options["canUseTool"]>;
+type PermissionHandler = (...args: Parameters<CanUseTool>) => ReturnType<CanUseTool>;
+export type TurnMessageHandler = (message: SDKMessage) => Promise<boolean> | boolean;
+export type TurnReservation = {
+    kind: "owner";
+    generation: number;
+    done: Promise<void>;
+} | {
+    kind: "interjection";
+    generation: number;
+};
+export type TurnSettings = {
+    model?: string;
+    agentMode: "default" | "plan";
+    managedTaskContext: ManagedTaskExecutionContext;
+};
+export type LiveSessionInit = {
+    conversationId: string;
+    workdir: string;
+    model?: string;
+    agentMode: "default" | "plan";
+    managedTaskContext: ManagedTaskExecutionContext;
+    llmProxyBinding?: string;
+    idleTimeoutMs: number;
+    buildOptions(abortController: AbortController, canUseTool: CanUseTool, managedTaskContext: ManagedTaskExecutionContext): Options;
+    onRecycle(session: LiveSession, generation: number): void;
+};
+export declare class LiveSession {
+    readonly workdir: string;
+    readonly managedTaskContext: ManagedTaskExecutionContext;
+    readonly llmProxyBinding?: string;
+    private readonly inputQueue;
+    private readonly abortController;
+    private readonly sdkQuery;
+    private readonly idleTimeoutMs;
+    private readonly onRecycle;
+    private currentTurn;
+    private transition;
+    private idleTimer;
+    private pumpStarted;
+    private dead;
+    private cancelIntent;
+    private generation;
+    private _conversationId;
+    private _model?;
+    private _agentMode;
+    constructor(init: LiveSessionInit);
+    get conversationId(): string;
+    get model(): string | undefined;
+    get agentMode(): "default" | "plan";
+    get isDead(): boolean;
+    get wasCancelled(): boolean;
+    get currentGeneration(): number;
+    hasActiveOwner(): boolean;
+    bindConversation(id: string): void;
+    updateManagedTaskContext(context: ManagedTaskExecutionContext): void;
+    reserveTurn(prompt: string, handler: TurnMessageHandler, permissionHandler: PermissionHandler, settings: TurnSettings): Promise<TurnReservation>;
+    setModel(model?: string): Promise<void>;
+    setPermissionMode(mode: PermissionMode): Promise<void>;
+    abort(): void;
+    private withTransition;
+    private pump;
+    private settleTurn;
+    private resetIdleTimer;
+    private clearIdleTimer;
+}
+export {};

package/dist/live-session.js

@@ -0,0 +1,225 @@
+import { logger } from "@messenger-agent/shared/logger";
+import { query } from "./claude.js";
+import { createInputQueue } from "./input-queue.js";
+function userMessage(prompt, priority) {
+    return {
+        type: "user",
+        parent_tool_use_id: null,
+        message: { role: "user", content: prompt },
+        origin: { kind: "human" },
+        ...(priority ? { priority } : null),
+    };
+}
+function logStreamMessage(message) {
+    if (message.type === "stream_event" && message.event.type === "content_block_delta")
+        return;
+    if (message.type === "system" && message.subtype === "thinking_tokens")
+        return;
+    logger.debug("Received chat stream event:", message);
+}
+export class LiveSession {
+    workdir;
+    managedTaskContext;
+    llmProxyBinding;
+    inputQueue = createInputQueue();
+    abortController = new AbortController();
+    sdkQuery;
+    idleTimeoutMs;
+    onRecycle;
+    currentTurn;
+    transition = Promise.resolve();
+    idleTimer;
+    pumpStarted = false;
+    dead = false;
+    cancelIntent = false;
+    generation = 0;
+    _conversationId;
+    _model;
+    _agentMode;
+    constructor(init) {
+        this._conversationId = init.conversationId;
+        this.workdir = init.workdir;
+        this._model = init.model;
+        this._agentMode = init.agentMode;
+        this.managedTaskContext = init.managedTaskContext;
+        this.llmProxyBinding = init.llmProxyBinding;
+        this.idleTimeoutMs = init.idleTimeoutMs;
+        this.onRecycle = init.onRecycle;
+        const canUseTool = (...args) => {
+            const turn = this.currentTurn;
+            if (!turn || turn.settled || this.cancelIntent) {
+                return Promise.resolve({ behavior: "deny", message: "Claude conversation is no longer active" });
+            }
+            return turn.permissionHandler(...args);
+        };
+        this.sdkQuery = query({
+            prompt: this.inputQueue.iterable,
+            options: init.buildOptions(this.abortController, canUseTool, this.managedTaskContext),
+        });
+        this.resetIdleTimer();
+    }
+    get conversationId() {
+        return this._conversationId;
+    }
+    get model() {
+        return this._model;
+    }
+    get agentMode() {
+        return this._agentMode;
+    }
+    get isDead() {
+        return this.dead;
+    }
+    get wasCancelled() {
+        return this.cancelIntent;
+    }
+    get currentGeneration() {
+        return this.generation;
+    }
+    hasActiveOwner() {
+        return Boolean(this.currentTurn && !this.currentTurn.settled);
+    }
+    bindConversation(id) {
+        this._conversationId = id;
+    }
+    updateManagedTaskContext(context) {
+        for (const key of Object.keys(this.managedTaskContext)) {
+            delete this.managedTaskContext[key];
+        }
+        Object.assign(this.managedTaskContext, context);
+    }
+    reserveTurn(prompt, handler, permissionHandler, settings) {
+        return this.withTransition(async () => {
+            if (this.dead || this.cancelIntent)
+                throw new Error(`Claude session ${this.conversationId} is closed`);
+            this.clearIdleTimer();
+            this.updateManagedTaskContext(settings.managedTaskContext);
+            if (this.hasActiveOwner()) {
+                this.inputQueue.push(userMessage(prompt, "next"));
+                return { kind: "interjection", generation: this.generation };
+            }
+            if (settings.model !== this._model) {
+                await this.sdkQuery.setModel?.(settings.model);
+                this._model = settings.model;
+            }
+            if (settings.agentMode !== this._agentMode) {
+                await this.sdkQuery.setPermissionMode?.(settings.agentMode === "plan" ? "plan" : "bypassPermissions");
+                this._agentMode = settings.agentMode;
+            }
+            const generation = ++this.generation;
+            let resolve;
+            let reject;
+            const done = new Promise((res, rej) => {
+                resolve = res;
+                reject = rej;
+            });
+            this.currentTurn = { generation, handler, permissionHandler, resolve, reject, settled: false };
+            if (!this.pumpStarted) {
+                this.pumpStarted = true;
+                void this.pump();
+            }
+            this.inputQueue.push(userMessage(prompt));
+            return { kind: "owner", generation, done };
+        });
+    }
+    async setModel(model) {
+        await this.withTransition(async () => {
+            if (model === this._model || this.dead || this.cancelIntent)
+                return;
+            await this.sdkQuery.setModel?.(model);
+            this._model = model;
+        });
+    }
+    async setPermissionMode(mode) {
+        await this.withTransition(async () => {
+            if (this.dead || this.cancelIntent)
+                return;
+            await this.sdkQuery.setPermissionMode?.(mode);
+            this._agentMode = mode === "plan" ? "plan" : "default";
+        });
+    }
+    abort() {
+        this.cancelIntent = true;
+        void this.withTransition(async () => {
+            if (this.dead)
+                return;
+            this.dead = true;
+            this.clearIdleTimer();
+            this.inputQueue.close();
+            this.abortController.abort();
+        });
+    }
+    withTransition(operation) {
+        const result = this.transition.then(operation, operation);
+        this.transition = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async pump() {
+        try {
+            for await (const message of this.sdkQuery) {
+                logStreamMessage(message);
+                const turn = this.currentTurn;
+                if (!turn || turn.settled)
+                    continue;
+                const ended = await turn.handler(message);
+                if (ended)
+                    this.settleTurn(turn, undefined);
+            }
+            this.dead = true;
+            const turn = this.currentTurn;
+            if (turn && !turn.settled)
+                this.settleTurn(turn, undefined);
+        }
+        catch (error) {
+            this.dead = true;
+            const turn = this.currentTurn;
+            if (turn && !turn.settled)
+                this.settleTurn(turn, error);
+            else if (!this.cancelIntent)
+                logger.error(`Claude session ${this.conversationId} pump failed:`, error);
+        }
+        finally {
+            this.clearIdleTimer();
+            this.onRecycle(this, this.generation);
+        }
+    }
+    settleTurn(turn, error) {
+        if (turn.settled)
+            return;
+        turn.settled = true;
+        if (this.currentTurn === turn)
+            this.currentTurn = undefined;
+        if (!this.dead && !this.cancelIntent)
+            this.resetIdleTimer();
+        if (error === undefined)
+            turn.resolve();
+        else
+            turn.reject(error);
+    }
+    resetIdleTimer() {
+        this.clearIdleTimer();
+        if (this.dead || this.cancelIntent)
+            return;
+        this.idleTimer = setTimeout(() => {
+            void this.withTransition(async () => {
+                if (this.dead || this.cancelIntent || this.hasActiveOwner()) {
+                    if (!this.dead && !this.cancelIntent)
+                        this.resetIdleTimer();
+                    return;
+                }
+                logger.info(`Recycling idle Claude session ${this.conversationId}`);
+                this.dead = true;
+                this.inputQueue.close();
+                this.sdkQuery.close?.();
+                this.onRecycle(this, this.generation);
+            });
+        }, this.idleTimeoutMs);
+        this.idleTimer.unref?.();
+    }
+    clearIdleTimer() {
+        if (!this.idleTimer)
+            return;
+        clearTimeout(this.idleTimer);
+        this.idleTimer = undefined;
+    }
+}

package/dist/llm-proxy-bindings.d.ts

@@ -0,0 +1,3 @@
+export declare function getLlmProxyBinding(conversationId: string | undefined): string | undefined;
+export declare function setLlmProxyBinding(conversationId: string, bindingHandle: string | undefined): void;
+export declare function moveLlmProxyBinding(previousConversationId: string, conversationId: string, bindingHandle: string | undefined): void;

package/dist/llm-proxy-bindings.js

@@ -0,0 +1,45 @@
+import { DatabaseSync } from "node:sqlite";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { appConfig } from "./config.js";
+mkdirSync(appConfig.dataDir, { recursive: true });
+const db = new DatabaseSync(join(appConfig.dataDir, "llm-proxy-bindings.sqlite"));
+db.exec(`
+  CREATE TABLE IF NOT EXISTS llm_proxy_bindings (
+    conversation_id TEXT PRIMARY KEY,
+    binding_handle TEXT NOT NULL,
+    updated_at INTEGER NOT NULL
+  )
+`);
+const getStatement = db.prepare("SELECT binding_handle FROM llm_proxy_bindings WHERE conversation_id = ?");
+const setStatement = db.prepare(`INSERT INTO llm_proxy_bindings (conversation_id, binding_handle, updated_at)
+   VALUES (?, ?, ?)
+   ON CONFLICT(conversation_id) DO UPDATE SET
+     binding_handle = excluded.binding_handle,
+     updated_at = excluded.updated_at`);
+const deleteStatement = db.prepare("DELETE FROM llm_proxy_bindings WHERE conversation_id = ?");
+export function getLlmProxyBinding(conversationId) {
+    if (!conversationId)
+        return undefined;
+    const row = getStatement.get(conversationId);
+    return row?.binding_handle;
+}
+export function setLlmProxyBinding(conversationId, bindingHandle) {
+    if (!bindingHandle)
+        return;
+    setStatement.run(conversationId, bindingHandle, Date.now());
+}
+export function moveLlmProxyBinding(previousConversationId, conversationId, bindingHandle) {
+    if (!bindingHandle || previousConversationId === conversationId)
+        return;
+    db.exec("BEGIN IMMEDIATE");
+    try {
+        setStatement.run(conversationId, bindingHandle, Date.now());
+        deleteStatement.run(previousConversationId);
+        db.exec("COMMIT");
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+}