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

package/dist/tunnel-client.js

@@ -0,0 +1,223 @@
+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;
+}

package/dist/workspace-files.d.ts

@@ -0,0 +1,8 @@
+import type { AgentWorkspaceConfig } from "@messenger-agent/shared/agent-config";
+export declare const WORKSPACES_ROOT = "/workspaces";
+export declare class WorkspaceFileError extends Error {
+    readonly code: "INVALID_PATH" | "OUTSIDE_WORKSPACE" | "NOT_FOUND" | "NOT_FILE";
+    constructor(message: string, code: "INVALID_PATH" | "OUTSIDE_WORKSPACE" | "NOT_FOUND" | "NOT_FILE");
+}
+export declare function isPathInside(parent: string, child: string): boolean;
+export declare function resolveWorkspaceFilePath(rawPath: string, workspaces?: Map<string, AgentWorkspaceConfig>): Promise<string>;

package/dist/workspace-files.js

@@ -0,0 +1,56 @@
+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;
+    }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@messenger-agent/claude-agent",
+  "version": "0.24.0-alpha.2",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "0.3.215",
+    "@hono/node-server": "^2.0.2",
+    "@hono/zod-validator": "^0.7.6",
+    "hono": "^4.12.18",
+    "ws": "^8.21.0",
+    "yaml": "^2.9.0",
+    "zod": "^4.4.3",
+    "@messenger-agent/shared": "0.24.0-alpha.2"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.18.1"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json && node ../../scripts/copy-assets.mjs claude-agent",
+    "build:sourcemap": "rm -rf dist && tsc -p tsconfig.json --sourceMap && node ../../scripts/copy-assets.mjs claude-agent",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  }
+}