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

package/dist/app.d.ts

@@ -0,0 +1,5 @@
+import { Hono } from "hono";
+import { type MessengerAgentConfig } from "./config.js";
+export declare function createApp(config?: MessengerAgentConfig): Hono;
+declare const _default: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default _default;

package/dist/app.js

@@ -0,0 +1,17 @@
+import { Hono } from "hono";
+import { logger as honoLogger } from "hono/logger";
+import { agentAuthMiddleware } from "@messenger-agent/shared/agent-auth";
+import { createAgentFileRoutes } from "@messenger-agent/shared/agent-files";
+import { logger } from "@messenger-agent/shared/logger";
+import { createAgentWorkspaceRoutes } from "@messenger-agent/shared/workspace-routes";
+import { appConfig } from "./config.js";
+export function createApp(config = appConfig) {
+    const app = new Hono();
+    app.use(honoLogger((message, ...rest) => logger.info(message, ...rest)));
+    app.get("/health", (c) => c.json({ status: "ok", role: "messenger-agent" }));
+    app.use("/*", agentAuthMiddleware(config.authTokens));
+    app.route("/v1/files", createAgentFileRoutes());
+    app.route("/v1/workspaces", createAgentWorkspaceRoutes({ config, textMaxBytes: config.textMaxBytes }));
+    return app;
+}
+export default createApp();

package/dist/config.d.ts

@@ -0,0 +1,20 @@
+import { type AgentAuthConfig, type AgentWorkspacesConfig } from "@messenger-agent/shared/agent-config";
+import { type LogLevel } from "@messenger-agent/shared/logger";
+export type MessengerAgentConfig = {
+    configPath: string;
+    logLevel: LogLevel;
+    logFile?: string;
+    port: number;
+    textMaxBytes: number;
+    tunnel: {
+        enabled: boolean;
+        serverUrl?: string;
+        tunnelId?: string;
+        token?: string;
+        reconnectInitialMs: number;
+        reconnectMaxMs: number;
+        heartbeatIntervalMs: number;
+    };
+} & AgentAuthConfig & AgentWorkspacesConfig;
+export declare function loadMessengerAgentConfig(configPath?: string): MessengerAgentConfig;
+export declare const appConfig: MessengerAgentConfig;

package/dist/config.js

@@ -0,0 +1,78 @@
+import { existsSync, readFileSync } from "node:fs";
+import { parse } from "yaml";
+import { z } from "zod";
+import { normalizeOptional, parseAgentAuthConfig, parseAgentWorkspacesConfig, } from "@messenger-agent/shared/agent-config";
+import { DEFAULT_TEXT_MAX_BYTES } from "@messenger-agent/shared/workspace-files";
+import { logger, normalizeLogLevel, setLogFile, setLogLevel } from "@messenger-agent/shared/logger";
+const DEFAULT_TUNNEL_SERVER_URL = "wss://m.elevo.vip/agent-bridge/tunnel";
+const RawConfigSchema = z
+    .object({
+    log_level: z.string().optional(),
+    log_file: z.string().optional(),
+    port: z.coerce.number().int().positive().optional(),
+    messenger: z
+        .object({
+        port: z.coerce.number().int().positive().optional(),
+        log_file: z.string().optional(),
+    })
+        .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(),
+    workspace_file_text_max_bytes: z.coerce.number().int().positive().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();
+export function loadMessengerAgentConfig(configPath = process.env.MESSENGER_AGENT_CONFIG_PATH ?? process.env.AGENT_CONFIG_PATH ?? "./agent-config.yaml") {
+    let parsedYaml = {};
+    if (existsSync(configPath)) {
+        try {
+            parsedYaml = parse(readFileSync(configPath, "utf8"));
+        }
+        catch (err) {
+            logger.error(`Failed to parse messenger-agent config at ${configPath}:`, err);
+        }
+    }
+    else {
+        logger.warn(`Messenger-agent config file not found at ${configPath}`);
+    }
+    const parsed = RawConfigSchema.safeParse(parsedYaml ?? {});
+    if (!parsed.success)
+        logger.error(`Invalid messenger-agent config at ${configPath}:`, parsed.error.issues);
+    const data = parsed.success ? parsed.data : {};
+    const logLevel = normalizeLogLevel(data.log_level);
+    const logFile = normalizeOptional(data.messenger?.log_file) ?? normalizeOptional(data.log_file);
+    const enabled = data.tunnel?.enabled ?? false;
+    setLogLevel(logLevel);
+    setLogFile(logFile);
+    return {
+        configPath,
+        logLevel,
+        logFile,
+        port: data.messenger?.port ?? data.port ?? 8301,
+        textMaxBytes: data.workspace_file_text_max_bytes ?? DEFAULT_TEXT_MAX_BYTES,
+        tunnel: {
+            enabled,
+            serverUrl: normalizeOptional(data.tunnel?.server_url) ?? (enabled ? DEFAULT_TUNNEL_SERVER_URL : undefined),
+            tunnelId: normalizeOptional(data.tunnel?.tunnel_id),
+            token: normalizeOptional(data.tunnel?.token),
+            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),
+    };
+}
+export const appConfig = loadMessengerAgentConfig();

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { serve } from "@hono/node-server";
+import app from "./app.js";
+import { appConfig } from "./config.js";
+import { WorkspaceTunnelClient } from "./tunnel-client.js";
+import { logger } from "@messenger-agent/shared/logger";
+const tunnelClient = appConfig.tunnel.enabled ? new WorkspaceTunnelClient(appConfig) : undefined;
+if (tunnelClient) {
+    tunnelClient.start().catch((err) => logger.error("[WorkspaceTunnel] stopped unexpectedly:", err));
+}
+else {
+    serve({ fetch: app.fetch, port: appConfig.port }, () => {
+        logger.info(`messenger-agent listening on http://0.0.0.0:${appConfig.port}`);
+    });
+}
+const stop = () => tunnelClient?.stop();
+process.once("SIGINT", stop);
+process.once("SIGTERM", stop);

package/dist/tunnel-client.d.ts

@@ -0,0 +1,15 @@
+import { type MessengerAgentConfig } from "./config.js";
+export declare class WorkspaceTunnelClient {
+    private readonly config;
+    private stopped;
+    private socket?;
+    private readonly running;
+    private readonly workspaceRoutes;
+    private readonly fileRoutes;
+    constructor(config?: MessengerAgentConfig);
+    start(): Promise<void>;
+    stop(): void;
+    private connectOnce;
+    private send;
+    private handleRequest;
+}

package/dist/tunnel-client.js

@@ -0,0 +1,159 @@
+import { createRequire } from "node:module";
+import WebSocket from "ws";
+import { logger } from "@messenger-agent/shared/logger";
+import { createAgentFileRoutes } from "@messenger-agent/shared/agent-files";
+import { createPrefixedRouteRequest, createWorkspaceRouteRequest, isAgentFileHttpTunnelRequest, isWorkspaceHttpTunnelRequest, 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";
+import { createAgentWorkspaceRoutes } from "@messenger-agent/shared/workspace-routes";
+import { appConfig } from "./config.js";
+const clientVersion = createRequire(import.meta.url)("../package.json").version;
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function parseServerMessage(raw) {
+    try {
+        const value = JSON.parse(raw.toString());
+        return value && typeof value === "object" && "type" in value ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export class WorkspaceTunnelClient {
+    config;
+    stopped = false;
+    socket;
+    running = new Map();
+    workspaceRoutes;
+    fileRoutes = createAgentFileRoutes();
+    constructor(config = appConfig) {
+        this.config = config;
+        this.workspaceRoutes = createAgentWorkspaceRoutes({ config, textMaxBytes: config.textMaxBytes });
+    }
+    async start() {
+        if (!this.config.tunnel.enabled)
+            return;
+        if (!this.config.tunnel.serverUrl || !this.config.tunnel.tunnelId || !this.config.tunnel.token) {
+            throw new Error("Workspace tunnel requires server_url, tunnel_id, and token when enabled");
+        }
+        let backoffMs = this.config.tunnel.reconnectInitialMs;
+        while (!this.stopped) {
+            try {
+                await this.connectOnce();
+                backoffMs = this.config.tunnel.reconnectInitialMs;
+            }
+            catch (err) {
+                if (!this.stopped)
+                    logger.warn("[WorkspaceTunnel] connection failed:", err);
+            }
+            if (!this.stopped) {
+                await delay(backoffMs);
+                backoffMs = Math.min(backoffMs * 2, this.config.tunnel.reconnectMaxMs);
+            }
+        }
+    }
+    stop() {
+        this.stopped = true;
+        for (const controller of this.running.values())
+            controller.abort();
+        this.running.clear();
+        this.socket?.close();
+    }
+    connectOnce() {
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(this.config.tunnel.serverUrl, {
+                headers: { Authorization: `Bearer ${this.config.tunnel.token}` },
+            });
+            this.socket = ws;
+            let heartbeatTimer;
+            let settled = false;
+            const cleanup = () => {
+                if (heartbeatTimer)
+                    clearInterval(heartbeatTimer);
+                if (this.socket === ws)
+                    this.socket = undefined;
+                for (const controller of this.running.values())
+                    controller.abort(new Error("Workspace tunnel closed"));
+                this.running.clear();
+            };
+            ws.on("open", () => {
+                this.send({
+                    type: "hello",
+                    protocolVersion: CODING_AGENT_TUNNEL_PROTOCOL_VERSION,
+                    tunnelId: this.config.tunnel.tunnelId,
+                    agentType: "workspace",
+                    capabilities: ["workspace.files", "workspace.git", "workspace.tasks"],
+                    clientVersion,
+                    workspaces: [...this.config.workspaces.values()]
+                        .map(({ id, name }) => ({ id, name }))
+                        .sort((left, right) => left.id.localeCompare(right.id)),
+                });
+                heartbeatTimer = setInterval(() => this.send({ type: "heartbeat" }), this.config.tunnel.heartbeatIntervalMs);
+                logger.info(`[WorkspaceTunnel] connected to ${this.config.tunnel.serverUrl} as ${this.config.tunnel.tunnelId}`);
+            });
+            ws.on("message", (raw) => {
+                const message = parseServerMessage(raw);
+                if (!message || message.type === "heartbeat")
+                    return;
+                if (message.type === "cancel") {
+                    this.running.get(message.id)?.abort();
+                }
+                else if (message.type === "request") {
+                    void this.handleRequest(message);
+                }
+            });
+            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 || code === 1008) {
+                    this.stopped = true;
+                    logger.warn(`[WorkspaceTunnel] connection rejected with code ${code}; reconnect disabled until service restart: ${reason.toString()}`);
+                }
+                if (!settled) {
+                    settled = true;
+                    resolve();
+                }
+            });
+        });
+    }
+    send(message) {
+        if (this.socket?.readyState === WebSocket.OPEN)
+            this.socket.send(JSON.stringify(message));
+    }
+    async handleRequest(message) {
+        const isFileRequest = isAgentFileHttpTunnelRequest(message);
+        if (!isFileRequest && !isWorkspaceHttpTunnelRequest(message)) {
+            this.send({
+                type: "response.error",
+                id: message.id,
+                code: "unsupported_request",
+                errorText: `Unsupported workspace tunnel request: ${message.method} ${message.path}`,
+            });
+            return;
+        }
+        const controller = new AbortController();
+        this.running.set(message.id, controller);
+        try {
+            const request = isFileRequest
+                ? createPrefixedRouteRequest(message, "/v1/files", controller.signal)
+                : createWorkspaceRouteRequest(message, controller.signal);
+            const response = await (isFileRequest ? this.fileRoutes : this.workspaceRoutes).fetch(request);
+            await sendHttpTunnelResponse(message.id, response, (responseMessage) => this.send(responseMessage));
+        }
+        catch (err) {
+            this.send({
+                type: "response.error",
+                id: message.id,
+                code: "request_failed",
+                errorText: err instanceof Error ? err.message : "Workspace tunnel request failed",
+            });
+        }
+        finally {
+            this.running.delete(message.id);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@messenger-agent/messenger-agent",
+  "version": "0.24.0-alpha.2",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "messenger-agent": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "@hono/node-server": "^2.0.2",
+    "hono": "^4.12.18",
+    "ws": "^8.18.3",
+    "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",
+    "build:sourcemap": "rm -rf dist && tsc -p tsconfig.json --sourceMap",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  }
+}