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

package/dist/app.js

@@ -1,15 +1 @@
-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;
+import{Hono as e}from"hono";import{logger as a}from"hono/logger";import i from"./routes/chat.js";import{logger as m}from"@messenger-agent/shared/logger";import{agentAuthMiddleware as p}from"@messenger-agent/shared/agent-auth";import{appConfig as n}from"./config.js";import{installAgentActivityResponder as f}from"@messenger-agent/shared/agent-activity";import{claudeActivitySnapshot as g}from"./routes/chat.js";const o=new e;f("claude",g),o.use(a((t,...r)=>m.info(t,...r))),o.get("/health",t=>t.json({status:"ok",agent:"claude"})),o.use("/*",p(n.authTokens)),o.route("/",i);var v=o;export{v as default};

package/dist/claude.js

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

package/dist/config.js

@@ -1,147 +1 @@
-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();
+import{existsSync as h,readFileSync as k}from"node:fs";import{tmpdir as g}from"node:os";import{join as r}from"node:path";import{parse as T}from"yaml";import{z as e}from"zod";import{normalizeOptional as o,parseAgentAuthConfig as f,parseAgentWorkspacesConfig as b,parseGitInitConfig as v}from"@messenger-agent/shared/agent-config";import{logger as p,normalizeLogLevel as C,setLogFile as M,setLogLevel as I}from"@messenger-agent/shared/logger";const L="wss://m.elevo.vip/agent-bridge/tunnel",S="https://m.elevo.vip/agent-bridge/llm",U=e.object({log_level:e.string().optional(),port:e.coerce.number().int().positive().optional(),auth_tokens:e.record(e.string(),e.string()).optional(),workspaces:e.array(e.object({id:e.string().optional(),name:e.string().optional(),path:e.string().optional()})).optional(),file_uploads:e.object({temp_dir:e.string().optional()}).optional(),data_dir:e.string().optional(),claude:e.object({port:e.coerce.number().int().positive().optional(),data_dir:e.string().optional(),file_uploads:e.object({temp_dir:e.string().optional()}).optional(),api_key:e.string().optional(),base_url:e.string().optional(),default_model:e.string().optional(),max_turns:e.coerce.number().int().positive().optional(),ask_timeout_ms:e.coerce.number().int().positive().optional(),session_idle_timeout_ms:e.coerce.number().int().positive().optional()}).optional(),gitlab:e.object({ca_cert_path:e.string().optional(),host:e.string().optional()}).optional(),git:e.object({co_authors:e.array(e.string()).optional()}).optional(),tunnel:e.object({enabled:e.boolean().optional(),server_url:e.string().optional(),tunnel_id:e.string().optional(),token:e.string().optional(),reconnect_initial_ms:e.number().int().positive().optional(),reconnect_max_ms:e.number().int().positive().optional(),heartbeat_interval_ms:e.number().int().positive().optional()}).optional()}).loose();function j(){const n=process.env.AGENT_CONFIG_PATH??"./agent-config.yaml";if(!h(n)){const l="/data",m=r(l,"logs","claude-agent.log");return I("info"),M(m),p.warn(`Config file not found at ${n}`),{configPath:n,logLevel:"info",logFile:m,port:3e3,fileUploads:{tempDir:r(g(),"claude-agent-uploads")},dataDir:l,claude:{askTimeoutMs:432e5,sessionIdleTimeoutMs:36e5},tunnel:{enabled:!1,reconnectInitialMs:1e3,reconnectMaxMs:3e4,heartbeatIntervalMs:3e4},...f({}),...b({}),...v({})}}let s;try{s=T(k(n,"utf-8"))}catch(l){p.error(`Failed to parse config file at ${n}:`,l),s={}}const a=U.safeParse(s??{});a.success||p.error(`Invalid config format at ${n}:`,a.error.issues);const t=a.success?a.data:{},c=C(t.log_level),u=o(t.claude?.data_dir)??o(t.data_dir)??"/data",d=r(u,"logs","claude-agent.log"),i=t.tunnel?.enabled??!1,_=o(t.tunnel?.token);return I(c),M(d),{configPath:n,logLevel:c,logFile:d,port:t.claude?.port??t.port??3e3,fileUploads:{tempDir:o(t.claude?.file_uploads?.temp_dir)??o(t.file_uploads?.temp_dir)??r(g(),"claude-agent-uploads")},dataDir:u,claude:{apiKey:o(t.claude?.api_key)??(i?_:void 0),baseUrl:o(t.claude?.base_url)??(i?S:void 0),defaultModel:o(t.claude?.default_model),maxTurns:t.claude?.max_turns,askTimeoutMs:Number.parseInt(process.env.CLAUDE_ASK_TIMEOUT_MS??"",10)||t.claude?.ask_timeout_ms||432e5,sessionIdleTimeoutMs:Number.parseInt(process.env.CLAUDE_SESSION_IDLE_TIMEOUT_MS??"",10)||t.claude?.session_idle_timeout_ms||36e5},tunnel:{enabled:i,serverUrl:o(t.tunnel?.server_url)??(i?L:void 0),tunnelId:o(t.tunnel?.tunnel_id),token:_,reconnectInitialMs:t.tunnel?.reconnect_initial_ms??1e3,reconnectMaxMs:t.tunnel?.reconnect_max_ms??3e4,heartbeatIntervalMs:t.tunnel?.heartbeat_interval_ms??3e4},...f(t),...b(t),...v(t)}}const N=j();export{N as appConfig};

package/dist/index.js

@@ -1,19 +1 @@
-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}`);
-    });
-}
+import{serve as r}from"@hono/node-server";import e from"./app.js";import{appConfig as t}from"./config.js";import{initGit as a}from"@messenger-agent/shared/git-init";import{logger as i}from"@messenger-agent/shared/logger";import{startClaudeTunnelClient as p}from"./tunnel-client.js";const n=t.port;try{await a(t)}catch(o){i.warn("Git initialization failed; continuing agent startup:",o)}const f=p(t.tunnel);f||r({fetch:e.fetch,port:n},()=>{i.info(`claude-agent listening on http://0.0.0.0:${n}`)});

package/dist/input-queue.js

@@ -1,40 +1 @@
-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;
-        },
-    };
-}
+function i(){const r=[];let e=!1,n;const u=()=>{const t=n;n=void 0,t?.()};return{iterable:{async*[Symbol.asyncIterator](){for(;;){for(;r.length>0;)yield r.shift();if(e)return;await new Promise(t=>{n=t})}}},push(t){if(e)throw new Error("Claude input queue is closed");r.push(t),u()},close(){e||(e=!0,u())},get closed(){return e}}}export{i as createInputQueue};

package/dist/live-session.js

@@ -1,225 +1 @@
-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;
-    }
-}
+import{logger as r}from"@messenger-agent/shared/logger";import{query as m}from"./claude.js";import{createInputQueue as T}from"./input-queue.js";function l(i,e){return{type:"user",parent_tool_use_id:null,message:{role:"user",content:i},origin:{kind:"human"},...e?{priority:e}:null}}function f(i){i.type==="stream_event"&&i.event.type==="content_block_delta"||i.type==="system"&&i.subtype==="thinking_tokens"||r.debug("Received chat stream event:",i)}class I{workdir;managedTaskContext;llmProxyBinding;inputQueue=T();abortController=new AbortController;sdkQuery;idleTimeoutMs;onRecycle;currentTurn;transition=Promise.resolve();idleTimer;pumpStarted=!1;dead=!1;cancelIntent=!1;generation=0;_conversationId;_model;_agentMode;constructor(e){this._conversationId=e.conversationId,this.workdir=e.workdir,this._model=e.model,this._agentMode=e.agentMode,this.managedTaskContext=e.managedTaskContext,this.llmProxyBinding=e.llmProxyBinding,this.idleTimeoutMs=e.idleTimeoutMs,this.onRecycle=e.onRecycle;const t=(...s)=>{const n=this.currentTurn;return!n||n.settled||this.cancelIntent?Promise.resolve({behavior:"deny",message:"Claude conversation is no longer active"}):n.permissionHandler(...s)};this.sdkQuery=m({prompt:this.inputQueue.iterable,options:e.buildOptions(this.abortController,t,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!!(this.currentTurn&&!this.currentTurn.settled)}bindConversation(e){this._conversationId=e}updateManagedTaskContext(e){for(const t of Object.keys(this.managedTaskContext))delete this.managedTaskContext[t];Object.assign(this.managedTaskContext,e)}reserveTurn(e,t,s,n){return this.withTransition(async()=>{if(this.dead||this.cancelIntent)throw new Error(`Claude session ${this.conversationId} is closed`);if(this.clearIdleTimer(),this.updateManagedTaskContext(n.managedTaskContext),this.hasActiveOwner())return this.inputQueue.push(l(e,"next")),{kind:"interjection",generation:this.generation};n.model!==this._model&&(await this.sdkQuery.setModel?.(n.model),this._model=n.model),n.agentMode!==this._agentMode&&(await this.sdkQuery.setPermissionMode?.(n.agentMode==="plan"?"plan":"bypassPermissions"),this._agentMode=n.agentMode);const o=++this.generation;let a,d;const h=new Promise((u,c)=>{a=u,d=c});return this.currentTurn={generation:o,handler:t,permissionHandler:s,resolve:a,reject:d,settled:!1},this.pumpStarted||(this.pumpStarted=!0,this.pump()),this.inputQueue.push(l(e)),{kind:"owner",generation:o,done:h}})}async setModel(e){await this.withTransition(async()=>{e===this._model||this.dead||this.cancelIntent||(await this.sdkQuery.setModel?.(e),this._model=e)})}async setPermissionMode(e){await this.withTransition(async()=>{this.dead||this.cancelIntent||(await this.sdkQuery.setPermissionMode?.(e),this._agentMode=e==="plan"?"plan":"default")})}abort(){this.cancelIntent=!0,this.withTransition(async()=>{this.dead||(this.dead=!0,this.clearIdleTimer(),this.inputQueue.close(),this.abortController.abort())})}withTransition(e){const t=this.transition.then(e,e);return this.transition=t.then(()=>{},()=>{}),t}async pump(){try{for await(const t of this.sdkQuery){f(t);const s=this.currentTurn;if(!s||s.settled)continue;await s.handler(t)&&this.settleTurn(s,void 0)}this.dead=!0;const e=this.currentTurn;e&&!e.settled&&this.settleTurn(e,void 0)}catch(e){this.dead=!0;const t=this.currentTurn;t&&!t.settled?this.settleTurn(t,e):this.cancelIntent||r.error(`Claude session ${this.conversationId} pump failed:`,e)}finally{this.clearIdleTimer(),this.onRecycle(this,this.generation)}}settleTurn(e,t){e.settled||(e.settled=!0,this.currentTurn===e&&(this.currentTurn=void 0),!this.dead&&!this.cancelIntent&&this.resetIdleTimer(),t===void 0?e.resolve():e.reject(t))}resetIdleTimer(){this.clearIdleTimer(),!(this.dead||this.cancelIntent)&&(this.idleTimer=setTimeout(()=>{this.withTransition(async()=>{if(this.dead||this.cancelIntent||this.hasActiveOwner()){!this.dead&&!this.cancelIntent&&this.resetIdleTimer();return}r.info(`Recycling idle Claude session ${this.conversationId}`),this.dead=!0,this.inputQueue.close(),this.sdkQuery.close?.(),this.onRecycle(this,this.generation)})},this.idleTimeoutMs),this.idleTimer.unref?.())}clearIdleTimer(){this.idleTimer&&(clearTimeout(this.idleTimer),this.idleTimer=void 0)}}export{I as LiveSession};

package/dist/llm-proxy-bindings.js

@@ -1,45 +1,11 @@
-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(`
+import{DatabaseSync as a}from"node:sqlite";import{mkdirSync as E}from"node:fs";import{join as p}from"node:path";import{appConfig as i}from"./config.js";E(i.dataDir,{recursive:!0});const e=new a(p(i.dataDir,"llm-proxy-bindings.sqlite"));e.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)
+`);const _=e.prepare("SELECT binding_handle FROM llm_proxy_bindings WHERE conversation_id = ?"),o=e.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;
-    }
-}
+     updated_at = excluded.updated_at`),c=e.prepare("DELETE FROM llm_proxy_bindings WHERE conversation_id = ?");function x(n){return n?_.get(n)?.binding_handle:void 0}function g(n,t){t&&o.run(n,t,Date.now())}function s(n,t,r){if(!(!r||n===t)){e.exec("BEGIN IMMEDIATE");try{o.run(t,r,Date.now()),c.run(n),e.exec("COMMIT")}catch(d){throw e.exec("ROLLBACK"),d}}}export{x as getLlmProxyBinding,s as moveLlmProxyBinding,g as setLlmProxyBinding};

package/dist/managed-task-mcp.js

@@ -1,41 +1 @@
-import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
-import { executeManagedTaskTool, MANAGED_TASK_TOOL_DEFINITIONS, } from "@messenger-agent/shared/managed-task-tools";
-import { WorkspaceFileError } from "@messenger-agent/shared/workspace-files";
-export const MANAGED_TASK_MCP_SERVER_NAME = "managed_tasks";
-function jsonResult(data) {
-    const structuredContent = data && typeof data === "object" && !Array.isArray(data) ? data : undefined;
-    return {
-        content: [{ type: "text", text: JSON.stringify(data) }],
-        ...(structuredContent ? { structuredContent } : null),
-    };
-}
-function errorResult(err) {
-    const message = err instanceof WorkspaceFileError && err.code === "INVALID_PATH"
-        ? err.message
-        : err instanceof Error
-            ? err.message
-            : String(err);
-    return {
-        content: [{ type: "text", text: message }],
-        isError: true,
-    };
-}
-export function createManagedTaskMcpServer(options) {
-    return createSdkMcpServer({
-        name: MANAGED_TASK_MCP_SERVER_NAME,
-        version: "0.1.0",
-        instructions: "Use these tools for managed task records in the current workspace. Do not read or write task storage files directly.",
-        alwaysLoad: true,
-        tools: MANAGED_TASK_TOOL_DEFINITIONS.map((definition) => tool(definition.name, definition.description, definition.schema.shape, async (args) => {
-            try {
-                return jsonResult(await executeManagedTaskTool(options.workspaceRoot, definition.name, args, options.context));
-            }
-            catch (err) {
-                return errorResult(err);
-            }
-        }, {
-            alwaysLoad: true,
-            searchHint: definition.name,
-        })),
-    });
-}
+import{createSdkMcpServer as s,tool as n}from"@anthropic-ai/claude-agent-sdk";import{executeManagedTaskTool as a,MANAGED_TASK_TOOL_DEFINITIONS as c}from"@messenger-agent/shared/managed-task-tools";import{WorkspaceFileError as u}from"@messenger-agent/shared/workspace-files";const m="managed_tasks";function p(e){const t=e&&typeof e=="object"&&!Array.isArray(e)?e:void 0;return{content:[{type:"text",text:JSON.stringify(e)}],...t?{structuredContent:t}:null}}function i(e){return{content:[{type:"text",text:e instanceof u&&e.code==="INVALID_PATH"||e instanceof Error?e.message:String(e)}],isError:!0}}function A(e){return s({name:m,version:"0.1.0",instructions:"Use these tools for managed task records in the current workspace. Do not read or write task storage files directly.",alwaysLoad:!0,tools:c.map(t=>n(t.name,t.description,t.schema.shape,async r=>{try{return p(await a(e.workspaceRoot,t.name,r,e.context))}catch(o){return i(o)}},{alwaysLoad:!0,searchHint:t.name}))})}export{m as MANAGED_TASK_MCP_SERVER_NAME,A as createManagedTaskMcpServer};