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

package/dist/schemas.js

@@ -1,89 +1 @@
-import { z } from "zod";
-export const ChatTextPartSchema = z.object({
-    type: z.literal("text"),
-    text: z.string(),
-});
-export const ChatFilePartSchema = z.object({
-    type: z.literal("file"),
-    mediaType: z.string(),
-    filename: z.string().optional(),
-    url: z.string(),
-});
-export const ChatStepStartPartSchema = z.object({
-    type: z.literal("step-start"),
-});
-export const ChatToolPartSchema = z.object({
-    type: z.literal("tool"),
-    toolCallId: z.string(),
-    toolName: z.string(),
-    title: z.string().optional(),
-    state: z.string(),
-    input: z.unknown().optional(),
-    output: z.unknown().optional(),
-});
-export const ClaudeAskUserQuestionOutputSchema = z.object({
-    answers: z.record(z.string(), z.string()),
-});
-export const AskUserQuestionToolPartSchema = z.object({
-    type: z.literal("tool"),
-    toolCallId: z.string(),
-    // Accept the camelCase SDK tool names (now passed through downstream) plus the
-    // legacy snake_case aliases for backward compatibility.
-    toolName: z.enum(["AskUserQuestion", "ask_user_question"]),
-    state: z.literal("output-available"),
-    output: ClaudeAskUserQuestionOutputSchema,
-});
-export const ExitPlanModeToolPartSchema = z.object({
-    type: z.literal("tool"),
-    toolCallId: z.string(),
-    toolName: z.enum(["ExitPlanMode", "exit_plan_mode"]),
-    state: z.literal("output-available"),
-    output: z.unknown(),
-});
-export const ToolApprovalSchema = z.object({
-    id: z.string(),
-    approved: z.boolean(),
-    reason: z.string().optional(),
-});
-export const ToolApprovalPartSchema = z.object({
-    type: z.literal("tool"),
-    toolCallId: z.string(),
-    toolName: z.string(),
-    state: z.literal("approval-responded"),
-    input: z.unknown().optional(),
-    approval: ToolApprovalSchema,
-});
-export const AgentAnswerToolPartSchema = z.union([
-    AskUserQuestionToolPartSchema,
-    ExitPlanModeToolPartSchema,
-    ToolApprovalPartSchema,
-]);
-export const ChatCustomPartSchema = z.looseObject({
-    type: z.string(),
-});
-export const CodexChatForkSchema = z.strictObject({
-    threadId: z.string().min(1),
-    turnId: z.string().min(1),
-});
-export const ClaudeChatForkSchema = z.strictObject({
-    sessionId: z.string().min(1),
-    messageId: z.string().min(1),
-});
-export const ChatForkSchema = z.union([CodexChatForkSchema, ClaudeChatForkSchema]);
-export const ChatBodySchema = z.object({
-    conversationId: z.string().optional(),
-    fork: ChatForkSchema.optional(),
-    model: z.string(),
-    message: z.object({
-        id: z.string().optional(),
-        role: z.enum(["user", "assistant"]).optional(),
-        parts: z.array(z.union([
-            ChatTextPartSchema,
-            ChatFilePartSchema,
-            ChatStepStartPartSchema,
-            AgentAnswerToolPartSchema,
-            ChatToolPartSchema,
-            ChatCustomPartSchema,
-        ])),
-    }),
-});
+import{z as t}from"zod";const o=t.object({type:t.literal("text"),text:t.string()}),e=t.object({type:t.literal("file"),mediaType:t.string(),filename:t.string().optional(),url:t.string()}),a=t.object({type:t.literal("step-start")}),n=t.object({type:t.literal("tool"),toolCallId:t.string(),toolName:t.string(),title:t.string().optional(),state:t.string(),input:t.unknown().optional(),output:t.unknown().optional()}),r=t.object({answers:t.record(t.string(),t.string())}),s=t.object({type:t.literal("tool"),toolCallId:t.string(),toolName:t.enum(["AskUserQuestion","ask_user_question"]),state:t.literal("output-available"),output:r}),l=t.object({type:t.literal("tool"),toolCallId:t.string(),toolName:t.enum(["ExitPlanMode","exit_plan_mode"]),state:t.literal("output-available"),output:t.unknown()}),i=t.object({id:t.string(),approved:t.boolean(),reason:t.string().optional()}),p=t.object({type:t.literal("tool"),toolCallId:t.string(),toolName:t.string(),state:t.literal("approval-responded"),input:t.unknown().optional(),approval:i}),c=t.union([s,l,p]),m=t.looseObject({type:t.string()}),u=t.strictObject({threadId:t.string().min(1),turnId:t.string().min(1)}),g=t.strictObject({sessionId:t.string().min(1),messageId:t.string().min(1)}),d=t.union([u,g]),x=t.object({conversationId:t.string().optional(),fork:d.optional(),model:t.string(),message:t.object({id:t.string().optional(),role:t.enum(["user","assistant"]).optional(),parts:t.array(t.union([o,e,a,c,n,m]))})});export{c as AgentAnswerToolPartSchema,s as AskUserQuestionToolPartSchema,x as ChatBodySchema,m as ChatCustomPartSchema,e as ChatFilePartSchema,d as ChatForkSchema,a as ChatStepStartPartSchema,o as ChatTextPartSchema,n as ChatToolPartSchema,r as ClaudeAskUserQuestionOutputSchema,g as ClaudeChatForkSchema,u as CodexChatForkSchema,l as ExitPlanModeToolPartSchema,p as ToolApprovalPartSchema,i as ToolApprovalSchema};

package/dist/session-manager.js

@@ -1,57 +1 @@
-import { LiveSession } from "./live-session.js";
-export class SessionManager {
-    idleTimeoutMs;
-    sessions = new Map();
-    constructor(idleTimeoutMs) {
-        this.idleTimeoutMs = idleTimeoutMs;
-    }
-    get(conversationId) {
-        if (!conversationId)
-            return undefined;
-        const session = this.sessions.get(conversationId);
-        if (session?.isDead) {
-            this.removeByValue(session);
-            return undefined;
-        }
-        return session;
-    }
-    create(params) {
-        const session = new LiveSession({
-            ...params,
-            idleTimeoutMs: this.idleTimeoutMs(),
-            onRecycle: (candidate, generation) => this.recycle(candidate, generation),
-        });
-        this.sessions.set(params.conversationId, session);
-        return session;
-    }
-    bind(session, conversationId) {
-        if (session.isDead)
-            return;
-        const previousId = session.conversationId;
-        session.bindConversation(conversationId);
-        this.sessions.set(conversationId, session);
-        if (previousId !== conversationId && this.sessions.get(previousId) === session)
-            this.sessions.delete(previousId);
-    }
-    cancel(conversationId) {
-        const session = this.get(conversationId);
-        if (!session)
-            return false;
-        session.abort();
-        return true;
-    }
-    get size() {
-        return new Set(this.sessions.values()).size;
-    }
-    recycle(session, generation) {
-        if (!session.isDead || generation !== session.currentGeneration)
-            return;
-        this.removeByValue(session);
-    }
-    removeByValue(session) {
-        for (const [key, candidate] of this.sessions) {
-            if (candidate === session)
-                this.sessions.delete(key);
-        }
-    }
-}
+import{LiveSession as n}from"./live-session.js";class u{idleTimeoutMs;sessions=new Map;constructor(e){this.idleTimeoutMs=e}get(e){if(!e)return;const s=this.sessions.get(e);if(s?.isDead){this.removeByValue(s);return}return s}create(e){const s=new n({...e,idleTimeoutMs:this.idleTimeoutMs(),onRecycle:(t,i)=>this.recycle(t,i)});return this.sessions.set(e.conversationId,s),s}bind(e,s){if(e.isDead)return;const t=e.conversationId;e.bindConversation(s),this.sessions.set(s,e),t!==s&&this.sessions.get(t)===e&&this.sessions.delete(t)}cancel(e){const s=this.get(e);return s?(s.abort(),!0):!1}get size(){return new Set(this.sessions.values()).size}recycle(e,s){!e.isDead||s!==e.currentGeneration||this.removeByValue(e)}removeByValue(e){for(const[s,t]of this.sessions)t===e&&this.sessions.delete(s)}}export{u as SessionManager};

package/dist/task-aggregator.js

@@ -1,143 +1 @@
-/**
- * Aggregates Claude Code's incremental task tools (TaskCreate / TaskUpdate /
- * TaskList / TaskGet / TaskStop / TaskOutput) into a single todo list that is
- * compatible with the legacy `TodoWrite` event shape consumed downstream:
- *
- *   { todos: [{ content, status, activeForm? }] }
- *
- * Claude Code replaced the old all-at-once `TodoWrite` tool with a set of
- * incremental CRUD tools that persist each task as a JSON file under
- * `<claude config dir>/tasks/<session_id>/<N>.json` (N starts at 1):
- *
- *   {
- *     "id": "1",
- *     "subject": "...",
- *     "description": "...",
- *     "activeForm": "...",
- *     "status": "pending" | "in_progress" | "completed",
- *     "blocks": [],
- *     "blockedBy": []
- *   }
- *
- * Rather than replaying tool_use / tool_result payloads (whose shapes are not
- * guaranteed by the minified SDK), this aggregator reads those files directly
- * after each Task* tool call completes, which is the canonical source of truth.
- */
-import { readdirSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-const TASK_TOOL_NAMES = new Set(["TaskCreate", "TaskUpdate", "TaskList", "TaskGet", "TaskStop", "TaskOutput"]);
-function isRecord(value) {
-    return Boolean(value && typeof value === "object");
-}
-function asString(value) {
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function normalizeStatus(value) {
-    if (value === "pending" || value === "in_progress" || value === "completed")
-        return value;
-    return undefined;
-}
-/** Root directory under which per-session task files are persisted. */
-export function defaultTasksRoot() {
-    const base = process.env.CLAUDE_CONFIG_DIR?.trim() || join(homedir(), ".claude");
-    return join(base, "tasks");
-}
-function toTodo(raw) {
-    if (!isRecord(raw))
-        return undefined;
-    const status = normalizeStatus(raw.status);
-    // Files may exist for tasks in states we do not surface; skip unknown ones.
-    if (!status)
-        return undefined;
-    const content = asString(raw.subject) ?? asString(raw.activeForm) ?? asString(raw.description);
-    if (!content)
-        return undefined;
-    const activeForm = asString(raw.activeForm);
-    return { content, status, ...(activeForm ? { activeForm } : null) };
-}
-/** Reads and orders the task files for a single session directory. */
-export function readSessionTasks(tasksRoot, sessionId) {
-    const dir = join(tasksRoot, sessionId);
-    let files;
-    try {
-        files = readdirSync(dir);
-    }
-    catch {
-        return [];
-    }
-    const ordered = files
-        .filter((name) => name.endsWith(".json"))
-        .map((name) => ({ name, n: Number.parseInt(name, 10) }))
-        .filter((entry) => Number.isFinite(entry.n))
-        .sort((a, b) => a.n - b.n);
-    const todos = [];
-    for (const { name } of ordered) {
-        try {
-            const raw = JSON.parse(readFileSync(join(dir, name), "utf-8"));
-            const todo = toTodo(raw);
-            if (todo)
-                todos.push(todo);
-        }
-        catch {
-            // Ignore unreadable / partially-written files; the next refresh recovers.
-        }
-    }
-    return todos;
-}
-export function createTaskAggregator(options = {}) {
-    const tasksRoot = options.tasksRoot ?? defaultTasksRoot();
-    // All tool_use_ids that belonged to Task* tools, so their raw tool input /
-    // result can be suppressed downstream in favor of the aggregated event.
-    const taskToolCallIds = new Set();
-    let sessionId = options.sessionId;
-    let todos = [];
-    let lastSerialized = JSON.stringify(todos);
-    let isDirty = false;
-    const refresh = () => {
-        if (!sessionId)
-            return false;
-        const next = readSessionTasks(tasksRoot, sessionId);
-        const serialized = JSON.stringify(next);
-        if (serialized === lastSerialized)
-            return false;
-        todos = next;
-        lastSerialized = serialized;
-        isDirty = true;
-        return true;
-    };
-    return {
-        setSessionId(next) {
-            if (next && next !== sessionId) {
-                sessionId = next;
-            }
-        },
-        isTaskTool(name) {
-            return TASK_TOOL_NAMES.has(name);
-        },
-        applyToolUse(toolCallId, name) {
-            if (!TASK_TOOL_NAMES.has(name))
-                return false;
-            taskToolCallIds.add(toolCallId);
-            return refresh();
-        },
-        applyToolResult(toolCallId) {
-            if (!taskToolCallIds.has(toolCallId))
-                return false;
-            return refresh();
-        },
-        isTaskToolCall(toolCallId) {
-            return taskToolCallIds.has(toolCallId);
-        },
-        refresh,
-        snapshot() {
-            return { todos: todos.map((todo) => ({ ...todo })) };
-        },
-        dirty() {
-            return isDirty;
-        },
-        clearDirty() {
-            isDirty = false;
-        },
-    };
-}
+import{readdirSync as p,readFileSync as T}from"node:fs";import{homedir as m}from"node:os";import{join as c}from"node:path";const l=new Set(["TaskCreate","TaskUpdate","TaskList","TaskGet","TaskStop","TaskOutput"]);function k(t){return!!(t&&typeof t=="object")}function d(t){return typeof t=="string"&&t.length>0?t:void 0}function S(t){if(t==="pending"||t==="in_progress"||t==="completed")return t}function y(){const t=process.env.CLAUDE_CONFIG_DIR?.trim()||c(m(),".claude");return c(t,"tasks")}function h(t){if(!k(t))return;const i=S(t.status);if(!i)return;const n=d(t.subject)??d(t.activeForm)??d(t.description);if(!n)return;const s=d(t.activeForm);return{content:n,status:i,...s?{activeForm:s}:null}}function g(t,i){const n=c(t,i);let s;try{s=p(n)}catch{return[]}const a=s.filter(r=>r.endsWith(".json")).map(r=>({name:r,n:Number.parseInt(r,10)})).filter(r=>Number.isFinite(r.n)).sort((r,o)=>r.n-o.n),u=[];for(const{name:r}of a)try{const o=JSON.parse(T(c(n,r),"utf-8")),e=h(o);e&&u.push(e)}catch{}return u}function F(t={}){const i=t.tasksRoot??y(),n=new Set;let s=t.sessionId,a=[],u=JSON.stringify(a),r=!1;const o=()=>{if(!s)return!1;const e=g(i,s),f=JSON.stringify(e);return f===u?!1:(a=e,u=f,r=!0,!0)};return{setSessionId(e){e&&e!==s&&(s=e)},isTaskTool(e){return l.has(e)},applyToolUse(e,f){return l.has(f)?(n.add(e),o()):!1},applyToolResult(e){return n.has(e)?o():!1},isTaskToolCall(e){return n.has(e)},refresh:o,snapshot(){return{todos:a.map(e=>({...e}))}},dirty(){return r},clearDirty(){r=!1}}}export{F as createTaskAggregator,y as defaultTasksRoot,g as readSessionTasks};

package/dist/token-usage.js

@@ -1,75 +1 @@
-function sumTokens(...values) {
-    let total = 0;
-    for (const value of values) {
-        if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
-            return undefined;
-        total += value;
-        if (!Number.isSafeInteger(total))
-            return undefined;
-    }
-    return total;
-}
-function resultBreakdown(message) {
-    const modelUsages = Object.values(message.modelUsage ?? {});
-    if (modelUsages.length === 0)
-        return undefined;
-    let result;
-    for (const usage of modelUsages) {
-        const inputTokens = sumTokens(usage.inputTokens, usage.cacheCreationInputTokens, usage.cacheReadInputTokens);
-        const outputTokens = sumTokens(usage.outputTokens);
-        if (inputTokens === undefined || outputTokens === undefined)
-            return undefined;
-        const totalTokens = sumTokens(inputTokens, outputTokens);
-        if (totalTokens === undefined)
-            return undefined;
-        result = addBreakdowns(result, {
-            input_tokens: inputTokens,
-            output_tokens: outputTokens,
-            total_tokens: totalTokens,
-        });
-        if (!result)
-            return undefined;
-    }
-    return result;
-}
-function addBreakdowns(left, right) {
-    const inputTokens = sumTokens(left?.input_tokens ?? 0, right.input_tokens);
-    const outputTokens = sumTokens(left?.output_tokens ?? 0, right.output_tokens);
-    const totalTokens = sumTokens(left?.total_tokens ?? 0, right.total_tokens);
-    if (inputTokens === undefined || outputTokens === undefined || totalTokens === undefined)
-        return undefined;
-    return { input_tokens: inputTokens, output_tokens: outputTokens, total_tokens: totalTokens };
-}
-export function claudeContextSnapshot(message) {
-    const rawUsage = message.usage;
-    if (!rawUsage || typeof rawUsage !== "object")
-        return undefined;
-    const usage = rawUsage;
-    const usedTokens = sumTokens(usage.input_tokens, usage.cache_creation_input_tokens, usage.cache_read_input_tokens, usage.output_tokens);
-    if (usedTokens === undefined)
-        return undefined;
-    return {
-        usedTokens,
-        ...(typeof message.model === "string" && message.model ? { model: message.model } : {}),
-    };
-}
-function modelContextWindow(message, model) {
-    const entries = Object.entries(message.modelUsage ?? {});
-    const selected = entries.length === 1 ? entries[0][1] : model ? entries.find(([name]) => name === model)?.[1] : undefined;
-    const contextWindow = selected?.contextWindow;
-    return typeof contextWindow === "number" && Number.isSafeInteger(contextWindow) && contextWindow > 0
-        ? contextWindow
-        : undefined;
-}
-export function claudeTokenUsage(message, contextSnapshot) {
-    const last = resultBreakdown(message);
-    if (!last)
-        return undefined;
-    const contextWindow = modelContextWindow(message, contextSnapshot?.model);
-    return {
-        last,
-        ...(contextSnapshot && contextWindow !== undefined
-            ? { context: { used_tokens: contextSnapshot.usedTokens, window_tokens: contextWindow } }
-            : {}),
-    };
-}
+function d(...t){let n=0;for(const e of t)if(typeof e!="number"||!Number.isSafeInteger(e)||e<0||(n+=e,!Number.isSafeInteger(n)))return;return n}function r(t){const n=Object.values(t.modelUsage??{});if(n.length===0)return;let e;for(const o of n){const u=d(o.inputTokens,o.cacheCreationInputTokens,o.cacheReadInputTokens),s=d(o.outputTokens);if(u===void 0||s===void 0)return;const i=d(u,s);if(i===void 0||(e=f(e,{input_tokens:u,output_tokens:s,total_tokens:i}),!e))return}return e}function f(t,n){const e=d(t?.input_tokens??0,n.input_tokens),o=d(t?.output_tokens??0,n.output_tokens),u=d(t?.total_tokens??0,n.total_tokens);if(!(e===void 0||o===void 0||u===void 0))return{input_tokens:e,output_tokens:o,total_tokens:u}}function k(t){const n=t.usage;if(!n||typeof n!="object")return;const e=n,o=d(e.input_tokens,e.cache_creation_input_tokens,e.cache_read_input_tokens,e.output_tokens);if(o!==void 0)return{usedTokens:o,...typeof t.model=="string"&&t.model?{model:t.model}:{}}}function c(t,n){const e=Object.entries(t.modelUsage??{}),u=(e.length===1?e[0][1]:n?e.find(([s])=>s===n)?.[1]:void 0)?.contextWindow;return typeof u=="number"&&Number.isSafeInteger(u)&&u>0?u:void 0}function a(t,n){const e=r(t);if(!e)return;const o=c(t,n?.model);return{last:e,...n&&o!==void 0?{context:{used_tokens:n.usedTokens,window_tokens:o}}:{}}}export{k as claudeContextSnapshot,a as claudeTokenUsage};

package/dist/tunnel-client.js

@@ -1,223 +1 @@
-import { createRequire } from "node:module";
-import WebSocket from "ws";
-import { appConfig } from "./config.js";
-import { ChatBodySchema } from "./schemas.js";
-import { cancelClaudeConversation, ChatRequestError, handleClaudeChatStream } from "./routes/chat.js";
-import { logger } from "@messenger-agent/shared/logger";
-import { sendHttpTunnelResponse } from "@messenger-agent/shared/tunnel-http";
-import { CODING_AGENT_TUNNEL_DUPLICATE_CLOSE_CODE, CODING_AGENT_TUNNEL_PROTOCOL_VERSION, } from "@messenger-agent/shared/tunnel-protocol";
-const clientVersion = createRequire(import.meta.url)("../package.json").version;
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function parseServerMessage(raw) {
-    try {
-        const value = JSON.parse(raw.toString());
-        if (!value || typeof value !== "object" || !("type" in value))
-            return undefined;
-        return value;
-    }
-    catch {
-        return undefined;
-    }
-}
-function headersFromRecord(headers) {
-    const result = new Headers();
-    for (const [key, value] of Object.entries(headers ?? {})) {
-        result.set(key, value);
-    }
-    return result;
-}
-function cancelConversationId(message) {
-    if (message.method !== "POST")
-        return undefined;
-    try {
-        const pathname = new URL(message.path, "http://coding-agent-tunnel.local").pathname;
-        const match = /^\/v1\/chat\/([^/]+)\/cancel$/.exec(pathname);
-        return match ? decodeURIComponent(match[1]) : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-export class ClaudeTunnelClient {
-    config;
-    stopped = false;
-    socket;
-    running = new Map();
-    constructor(config) {
-        this.config = config;
-    }
-    async start() {
-        if (!this.config.enabled)
-            return;
-        if (!this.config.serverUrl || !this.config.tunnelId || !this.config.token) {
-            throw new Error("Tunnel config requires server_url, tunnel_id, and token when enabled");
-        }
-        let backoffMs = this.config.reconnectInitialMs;
-        while (!this.stopped) {
-            try {
-                await this.connectOnce();
-                backoffMs = this.config.reconnectInitialMs;
-            }
-            catch (err) {
-                if (this.stopped)
-                    break;
-                logger.warn("[TunnelClient] websocket tunnel connection failed:", err);
-            }
-            if (!this.stopped) {
-                await delay(backoffMs);
-                backoffMs = Math.min(backoffMs * 2, this.config.reconnectMaxMs);
-            }
-        }
-    }
-    stop() {
-        this.stopped = true;
-        for (const request of this.running.values()) {
-            request.abortController.abort();
-        }
-        this.running.clear();
-        this.socket?.close();
-    }
-    connectOnce() {
-        return new Promise((resolve, reject) => {
-            const headers = { Authorization: `Bearer ${this.config.token}` };
-            const ws = new WebSocket(this.config.serverUrl, { headers });
-            this.socket = ws;
-            let heartbeatTimer;
-            let settled = false;
-            const cleanup = () => {
-                if (heartbeatTimer)
-                    clearInterval(heartbeatTimer);
-                if (this.socket === ws)
-                    this.socket = undefined;
-                for (const request of this.running.values()) {
-                    request.abortController.abort(new Error("Tunnel connection closed"));
-                }
-                this.running.clear();
-            };
-            ws.on("open", () => {
-                this.send({
-                    type: "hello",
-                    protocolVersion: CODING_AGENT_TUNNEL_PROTOCOL_VERSION,
-                    tunnelId: this.config.tunnelId,
-                    agentType: "claude",
-                    clientVersion,
-                });
-                heartbeatTimer = setInterval(() => {
-                    this.send({ type: "heartbeat" });
-                }, this.config.heartbeatIntervalMs);
-                logger.info(`[TunnelClient] connected to ${this.config.serverUrl} as ${this.config.tunnelId}`);
-            });
-            ws.on("message", (raw) => {
-                const message = parseServerMessage(raw);
-                if (!message) {
-                    logger.warn("[TunnelClient] received invalid websocket message");
-                    return;
-                }
-                if (message.type === "heartbeat")
-                    return;
-                if (message.type === "cancel") {
-                    this.running.get(message.id)?.abortController.abort();
-                    return;
-                }
-                if (message.type === "request") {
-                    this.handleRequest(message).catch((err) => {
-                        logger.error(`[TunnelClient] request ${message.id} failed:`, err);
-                    });
-                }
-            });
-            ws.once("error", (err) => {
-                if (!settled) {
-                    settled = true;
-                    cleanup();
-                    reject(err);
-                }
-            });
-            ws.once("close", (code, reason) => {
-                cleanup();
-                if (code === CODING_AGENT_TUNNEL_DUPLICATE_CLOSE_CODE) {
-                    this.stopped = true;
-                    logger.warn(`[TunnelClient] duplicate websocket tunnel connection rejected; reconnect disabled: ${reason.toString()}`);
-                }
-                if (!settled) {
-                    settled = true;
-                    resolve();
-                }
-            });
-        });
-    }
-    send(message) {
-        const socket = this.socket;
-        if (!socket || socket.readyState !== WebSocket.OPEN)
-            return;
-        socket.send(JSON.stringify(message));
-    }
-    async handleRequest(message) {
-        const conversationId = cancelConversationId(message);
-        if (conversationId) {
-            const cancelled = cancelClaudeConversation(conversationId);
-            const response = Response.json(cancelled
-                ? { success: true }
-                : {
-                    error: {
-                        type: "not_found_error",
-                        code: "conversation_not_found",
-                        message: `Conversation not found or already completed: ${conversationId}`,
-                        param: "conversation_id",
-                    },
-                }, { status: cancelled ? 200 : 404 });
-            await sendHttpTunnelResponse(message.id, response, (responseMessage) => this.send(responseMessage));
-            return;
-        }
-        if (message.method !== "POST" || message.path !== "/v1/chat/stream") {
-            this.send({
-                type: "response.error",
-                id: message.id,
-                code: "unsupported_request",
-                errorText: `Unsupported tunnel request: ${message.method} ${message.path}`,
-            });
-            return;
-        }
-        const body = ChatBodySchema.safeParse(message.body);
-        if (!body.success) {
-            this.send({
-                type: "response.error",
-                id: message.id,
-                code: "invalid_request",
-                errorText: `Invalid chat request body: ${body.error.message}`,
-            });
-            return;
-        }
-        const abortController = new AbortController();
-        this.running.set(message.id, { abortController });
-        this.send({ type: "response.start", id: message.id, mode: "sse" });
-        try {
-            await handleClaudeChatStream({
-                body: body.data,
-                headers: headersFromRecord(message.headers),
-                signal: abortController.signal,
-            }, {
-                writeData: async (data) => this.send({ type: "response.chunk", id: message.id, data }),
-                writeDone: async () => this.send({ type: "response.end", id: message.id }),
-            });
-        }
-        catch (err) {
-            const errorText = err instanceof Error ? err.message : "Tunnel request failed";
-            const code = err instanceof ChatRequestError ? `http_${err.status}` : "request_failed";
-            this.send({ type: "response.error", id: message.id, code, errorText });
-        }
-        finally {
-            this.running.delete(message.id);
-        }
-    }
-}
-export function startClaudeTunnelClient(config = appConfig.tunnel) {
-    if (!config.enabled)
-        return undefined;
-    const client = new ClaudeTunnelClient(config);
-    client.start().catch((err) => {
-        logger.error("[TunnelClient] stopped unexpectedly:", err);
-    });
-    return client;
-}
+import{createRequire as f}from"node:module";import u from"ws";import{appConfig as p}from"./config.js";import{ChatBodySchema as y}from"./schemas.js";import{cancelClaudeConversation as C,ChatRequestError as b,handleClaudeChatStream as g}from"./routes/chat.js";import{logger as l}from"@messenger-agent/shared/logger";import{sendHttpTunnelResponse as m}from"@messenger-agent/shared/tunnel-http";import{CODING_AGENT_TUNNEL_DUPLICATE_CLOSE_CODE as w,CODING_AGENT_TUNNEL_PROTOCOL_VERSION as T}from"@messenger-agent/shared/tunnel-protocol";const v=f(import.meta.url)("../package.json").version;function _(r){return new Promise(e=>setTimeout(e,r))}function k(r){try{const e=JSON.parse(r.toString());return!e||typeof e!="object"||!("type"in e)?void 0:e}catch{return}}function I(r){const e=new Headers;for(const[t,c]of Object.entries(r??{}))e.set(t,c);return e}function O(r){if(r.method==="POST")try{const e=new URL(r.path,"http://coding-agent-tunnel.local").pathname,t=/^\/v1\/chat\/([^/]+)\/cancel$/.exec(e);return t?decodeURIComponent(t[1]):void 0}catch{return}}class q{config;stopped=!1;socket;running=new Map;constructor(e){this.config=e}async start(){if(!this.config.enabled)return;if(!this.config.serverUrl||!this.config.tunnelId||!this.config.token)throw new Error("Tunnel config requires server_url, tunnel_id, and token when enabled");let e=this.config.reconnectInitialMs;for(;!this.stopped;){try{await this.connectOnce(),e=this.config.reconnectInitialMs}catch(t){if(this.stopped)break;l.warn("[TunnelClient] websocket tunnel connection failed:",t)}this.stopped||(await _(e),e=Math.min(e*2,this.config.reconnectMaxMs))}}stop(){this.stopped=!0;for(const e of this.running.values())e.abortController.abort();this.running.clear(),this.socket?.close()}connectOnce(){return new Promise((e,t)=>{const c={Authorization:`Bearer ${this.config.token}`},o=new u(this.config.serverUrl,{headers:c});this.socket=o;let n,s=!1;const d=()=>{n&&clearInterval(n),this.socket===o&&(this.socket=void 0);for(const a of this.running.values())a.abortController.abort(new Error("Tunnel connection closed"));this.running.clear()};o.on("open",()=>{this.send({type:"hello",protocolVersion:T,tunnelId:this.config.tunnelId,agentType:"claude",clientVersion:v}),n=setInterval(()=>{this.send({type:"heartbeat"})},this.config.heartbeatIntervalMs),l.info(`[TunnelClient] connected to ${this.config.serverUrl} as ${this.config.tunnelId}`)}),o.on("message",a=>{const i=k(a);if(!i){l.warn("[TunnelClient] received invalid websocket message");return}if(i.type!=="heartbeat"){if(i.type==="cancel"){this.running.get(i.id)?.abortController.abort();return}i.type==="request"&&this.handleRequest(i).catch(h=>{l.error(`[TunnelClient] request ${i.id} failed:`,h)})}}),o.once("error",a=>{s||(s=!0,d(),t(a))}),o.once("close",(a,i)=>{d(),a===w&&(this.stopped=!0,l.warn(`[TunnelClient] duplicate websocket tunnel connection rejected; reconnect disabled: ${i.toString()}`)),s||(s=!0,e())})})}send(e){const t=this.socket;!t||t.readyState!==u.OPEN||t.send(JSON.stringify(e))}async handleRequest(e){const t=O(e);if(t){const n=C(t),s=Response.json(n?{success:!0}:{error:{type:"not_found_error",code:"conversation_not_found",message:`Conversation not found or already completed: ${t}`,param:"conversation_id"}},{status:n?200:404});await m(e.id,s,d=>this.send(d));return}if(e.method!=="POST"||e.path!=="/v1/chat/stream"){this.send({type:"response.error",id:e.id,code:"unsupported_request",errorText:`Unsupported tunnel request: ${e.method} ${e.path}`});return}const c=y.safeParse(e.body);if(!c.success){this.send({type:"response.error",id:e.id,code:"invalid_request",errorText:`Invalid chat request body: ${c.error.message}`});return}const o=new AbortController;this.running.set(e.id,{abortController:o}),this.send({type:"response.start",id:e.id,mode:"sse"});try{await g({body:c.data,headers:I(e.headers),signal:o.signal},{writeData:async n=>this.send({type:"response.chunk",id:e.id,data:n}),writeDone:async()=>this.send({type:"response.end",id:e.id})})}catch(n){const s=n instanceof Error?n.message:"Tunnel request failed",d=n instanceof b?`http_${n.status}`:"request_failed";this.send({type:"response.error",id:e.id,code:d,errorText:s})}finally{this.running.delete(e.id)}}}function P(r=p.tunnel){if(!r.enabled)return;const e=new q(r);return e.start().catch(t=>{l.error("[TunnelClient] stopped unexpectedly:",t)}),e}export{q as ClaudeTunnelClient,P as startClaudeTunnelClient};

package/dist/workspace-files.js

@@ -1,56 +1 @@
-import { constants } from "node:fs";
-import { access, realpath, stat } from "node:fs/promises";
-import { isAbsolute, relative, resolve } from "node:path";
-export const WORKSPACES_ROOT = "/workspaces";
-export class WorkspaceFileError extends Error {
-    code;
-    constructor(message, code) {
-        super(message);
-        this.code = code;
-    }
-}
-export function isPathInside(parent, child) {
-    const relativePath = relative(parent, child);
-    return relativePath.length === 0 || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
-}
-export async function resolveWorkspaceFilePath(rawPath, workspaces = new Map()) {
-    if (!isAbsolute(rawPath)) {
-        throw new WorkspaceFileError("Path must be absolute", "INVALID_PATH");
-    }
-    const virtualPath = resolve(rawPath);
-    if (!virtualPath.startsWith(`${WORKSPACES_ROOT}/`)) {
-        throw new WorkspaceFileError("Access denied: path must be under /workspaces/", "OUTSIDE_WORKSPACE");
-    }
-    const relativePath = relative(WORKSPACES_ROOT, virtualPath);
-    const [workspaceId, ...workspacePathParts] = relativePath.split(/[\\/]+/);
-    const configuredWorkspace = workspaces.get(workspaceId);
-    if (!configuredWorkspace) {
-        throw new WorkspaceFileError(`Unknown workspace: ${workspaceId}`, "NOT_FOUND");
-    }
-    const configuredRoot = resolve(configuredWorkspace.path);
-    const actualPath = resolve(configuredRoot, ...workspacePathParts);
-    if (!isPathInside(configuredRoot, actualPath)) {
-        throw new WorkspaceFileError("Access denied: path must stay under workspace root", "OUTSIDE_WORKSPACE");
-    }
-    try {
-        const [realRoot, realFile] = await Promise.all([realpath(configuredRoot), realpath(actualPath)]);
-        if (!isPathInside(realRoot, realFile)) {
-            throw new WorkspaceFileError("Access denied: path must stay under workspace root", "OUTSIDE_WORKSPACE");
-        }
-        const fileStat = await stat(realFile);
-        if (!fileStat.isFile()) {
-            throw new WorkspaceFileError("Path is not a file", "NOT_FILE");
-        }
-        await access(realFile, constants.R_OK);
-        return realFile;
-    }
-    catch (err) {
-        if (err instanceof WorkspaceFileError)
-            throw err;
-        const error = err;
-        if (error.code === "ENOENT") {
-            throw new WorkspaceFileError("File not found", "NOT_FOUND");
-        }
-        throw err;
-    }
-}
+import{constants as E}from"node:fs";import{access as k,realpath as l,stat as m}from"node:fs/promises";import{isAbsolute as p,relative as f,resolve as c}from"node:path";const u="/workspaces";class e extends Error{code;constructor(s,t){super(s),this.code=t}}function d(r,s){const t=f(r,s);return t.length===0||!t.startsWith("..")&&!p(t)}async function _(r,s=new Map){if(!p(r))throw new e("Path must be absolute","INVALID_PATH");const t=c(r);if(!t.startsWith(`${u}/`))throw new e("Access denied: path must be under /workspaces/","OUTSIDE_WORKSPACE");const O=f(u,t),[i,...P]=O.split(/[\\/]+/),h=s.get(i);if(!h)throw new e(`Unknown workspace: ${i}`,"NOT_FOUND");const n=c(h.path),w=c(n,...P);if(!d(n,w))throw new e("Access denied: path must stay under workspace root","OUTSIDE_WORKSPACE");try{const[o,a]=await Promise.all([l(n),l(w)]);if(!d(o,a))throw new e("Access denied: path must stay under workspace root","OUTSIDE_WORKSPACE");if(!(await m(a)).isFile())throw new e("Path is not a file","NOT_FILE");return await k(a,E.R_OK),a}catch(o){throw o instanceof e?o:o.code==="ENOENT"?new e("File not found","NOT_FOUND"):o}}export{u as WORKSPACES_ROOT,e as WorkspaceFileError,d as isPathInside,_ as resolveWorkspaceFilePath};