taskmeld 0.1.1

package/dist/src/cli/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/gateway/frame-sanitizer.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeDiagnosticPayload = exports.sanitizeGatewayFrame = void 0;
+const guards_1 = require("../utils/guards");
+const TARGET_FIELDS = new Set([
+    "args",
+    "body",
+    "content",
+    "delta",
+    "html",
+    "input",
+    "markdown",
+    "message",
+    "output",
+    "pagecontent",
+    "prompt",
+    "result",
+    "stderr",
+    "stdout",
+    "summary",
+    "text",
+]);
+const resolveOptions = (options) => ({
+    maxTextHeadChars: options?.maxTextHeadChars ?? 256,
+    maxTextTailChars: options?.maxTextTailChars ?? 2048,
+    maxObjectDepth: options?.maxObjectDepth ?? 8,
+    maxArrayItems: options?.maxArrayItems ?? 20,
+    maxTextLength: options?.maxTextLength ?? 2048,
+});
+const maybeTruncateString = (value, key, opts) => {
+    if (!TARGET_FIELDS.has(key.toLowerCase()))
+        return value;
+    if (value.length <= opts.maxTextLength)
+        return value;
+    return {
+        __truncated: true,
+        length: value.length,
+        head: value.slice(0, opts.maxTextHeadChars),
+        tail: value.slice(-opts.maxTextTailChars),
+    };
+};
+const sanitizeAny = (value, parentKey, depth, opts) => {
+    if (depth > opts.maxObjectDepth) {
+        return { __depthLimitReached: true };
+    }
+    if (typeof value === "string") {
+        if (parentKey !== null) {
+            return maybeTruncateString(value, parentKey, opts);
+        }
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const kept = value.slice(0, opts.maxArrayItems);
+        const result = kept.map((item) => sanitizeAny(item, parentKey, depth, opts));
+        if (value.length > opts.maxArrayItems) {
+            result.push({ __omittedItems: value.length - opts.maxArrayItems });
+        }
+        return result;
+    }
+    if ((0, guards_1.isRecord)(value)) {
+        const result = {};
+        for (const [k, v] of Object.entries(value)) {
+            result[k] = sanitizeAny(v, k, depth + 1, opts);
+        }
+        return result;
+    }
+    return value;
+};
+const sanitizeGatewayFrame = (frame, options) => {
+    const opts = resolveOptions(options);
+    return sanitizeAny(frame, null, 0, opts);
+};
+exports.sanitizeGatewayFrame = sanitizeGatewayFrame;
+const sanitizeDiagnosticPayload = (value, options) => {
+    const opts = resolveOptions(options);
+    return sanitizeAny(value, null, 0, opts);
+};
+exports.sanitizeDiagnosticPayload = sanitizeDiagnosticPayload;

package/dist/src/gateway/gateway-client.js

@@ -0,0 +1,462 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGatewayClient = void 0;
+const ws_1 = require("ws");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const frame_sanitizer_1 = require("./frame-sanitizer");
+const data_dir_1 = require("../app/data-dir");
+const STORAGE_DIR = (0, data_dir_1.resolveTaskMeldDataPath)();
+const STORAGE_FILE = (0, data_dir_1.resolveTaskMeldDataPath)("openclaw-device.json");
+const CONTROL_UI_ORIGIN = "http://localhost:3000";
+const ED25519_SPKI_PREFIX = Buffer.from([
+    0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00,
+]);
+const MIN_PROTOCOL = 3;
+const MAX_PROTOCOL = 4;
+const CHALLENGE_TIMEOUT_MS = 5_000;
+const HELLO_TIMEOUT_MS = 8_000;
+const BASE_RECONNECT_MS = 1_000;
+const MAX_RECONNECT_MS = 30_000;
+const base64UrlEncode = (data) => data
+    .toString("base64")
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=+$/, "");
+const base64UrlDecode = (value) => {
+    const padded = value.padEnd(Math.ceil(value.length / 4) * 4, "=");
+    return Buffer.from(padded.replace(/-/g, "+").replace(/_/g, "/"), "base64");
+};
+const sha256Hex = (data) => (0, node_crypto_1.createHash)("sha256").update(data).digest("hex");
+const publicKeyRawBase64Url = (spkiBuffer) => {
+    if (spkiBuffer.length === ED25519_SPKI_PREFIX.length + 32 &&
+        spkiBuffer.subarray(0, ED25519_SPKI_PREFIX.length).equals(ED25519_SPKI_PREFIX)) {
+        return base64UrlEncode(spkiBuffer.subarray(ED25519_SPKI_PREFIX.length));
+    }
+    return base64UrlEncode(spkiBuffer);
+};
+const fingerprintPublicKey = (spkiBuffer) => {
+    let rawKey = spkiBuffer;
+    if (spkiBuffer.length === ED25519_SPKI_PREFIX.length + 32 &&
+        spkiBuffer.subarray(0, ED25519_SPKI_PREFIX.length).equals(ED25519_SPKI_PREFIX)) {
+        rawKey = spkiBuffer.subarray(ED25519_SPKI_PREFIX.length);
+    }
+    return sha256Hex(rawKey);
+};
+const buildDeviceAuthPayload = ({ deviceId, clientId, clientMode, role, scopes, signedAt, token, nonce, }) => {
+    const version = nonce ? "v2" : "v1";
+    const scopeStr = scopes.join(",");
+    const base = [
+        version,
+        deviceId,
+        clientId,
+        clientMode,
+        role,
+        scopeStr,
+        String(signedAt),
+        token || "",
+    ];
+    if (version === "v2")
+        base.push(nonce || "");
+    return {
+        version,
+        value: base.join("|"),
+    };
+};
+const signDevicePayload = (privateKeyBase64Url, payload) => {
+    const message = Buffer.from(payload, "utf8");
+    const privateKeyBuffer = base64UrlDecode(privateKeyBase64Url);
+    const key = (0, node_crypto_1.createPrivateKey)({ key: privateKeyBuffer, format: "der", type: "pkcs8" });
+    const signature = (0, node_crypto_1.sign)(null, message, key);
+    return base64UrlEncode(signature);
+};
+const loadOrCreateIdentity = async () => {
+    try {
+        const stored = await node_fs_1.promises.readFile(STORAGE_FILE, "utf8");
+        const parsed = JSON.parse(stored);
+        if (!parsed?.deviceId || !parsed?.publicKey || !parsed?.privateKey) {
+            throw new Error("invalid_device_identity");
+        }
+        return parsed;
+    }
+    catch {
+        await node_fs_1.promises.mkdir(STORAGE_DIR, { recursive: true });
+        const { publicKey, privateKey } = (0, node_crypto_1.generateKeyPairSync)("ed25519");
+        const publicKeyBuffer = publicKey.export({ type: "spki", format: "der" });
+        const privateKeyBuffer = privateKey.export({ type: "pkcs8", format: "der" });
+        const identity = {
+            deviceId: fingerprintPublicKey(publicKeyBuffer),
+            publicKey: publicKeyRawBase64Url(publicKeyBuffer),
+            privateKey: base64UrlEncode(privateKeyBuffer),
+        };
+        await node_fs_1.promises.writeFile(STORAGE_FILE, JSON.stringify(identity, null, 2), "utf8");
+        return identity;
+    }
+};
+const getBackoffMs = (attempt) => {
+    const base = Math.min(MAX_RECONNECT_MS, BASE_RECONNECT_MS * 2 ** attempt);
+    const jitter = Math.floor(base * Math.random() * 0.2);
+    return base + jitter;
+};
+const createGatewayClient = (options) => {
+    let socket = null;
+    let status = "idle";
+    let lastError = null;
+    let lastHelloAt = null;
+    let protocol = null;
+    let activeScopes = [...(options.scopes ?? ["operator.read", "operator.write"])];
+    let isManualClose = false;
+    let reconnectAttempt = 0;
+    let reconnectTimer = null;
+    let challengeTimer = null;
+    let helloTimer = null;
+    let connectRequestId = null;
+    const connectWaiters = new Set();
+    const pending = new Map();
+    const eventHandlers = new Set();
+    const clearTimer = (timer) => {
+        if (timer) {
+            clearTimeout(timer);
+        }
+    };
+    const clearHandshakeTimers = () => {
+        clearTimer(challengeTimer);
+        clearTimer(helloTimer);
+        challengeTimer = null;
+        helloTimer = null;
+    };
+    const getStatus = () => ({
+        status,
+        lastError,
+        lastHelloAt,
+        protocol,
+        scopes: [...activeScopes],
+    });
+    const updateStatus = (next, error) => {
+        status = next;
+        if (error !== undefined) {
+            lastError = error;
+        }
+        options.onStatus?.(getStatus());
+    };
+    const rejectAllPending = (reason) => {
+        for (const [id, entry] of pending.entries()) {
+            clearTimeout(entry.timer);
+            entry.reject(new Error(reason));
+            pending.delete(id);
+        }
+    };
+    const failConnectWaiters = (reason) => {
+        for (const waiter of connectWaiters) {
+            waiter.reject(new Error(reason));
+        }
+        connectWaiters.clear();
+    };
+    const shouldReconnect = (failedStatus, reason) => {
+        if (isManualClose) {
+            return false;
+        }
+        if (failedStatus === "failed_auth" || failedStatus === "failed_protocol") {
+            return false;
+        }
+        return options.shouldReconnect?.(failedStatus, reason) ?? true;
+    };
+    const scheduleReconnect = (failedStatus, reason) => {
+        if (!shouldReconnect(failedStatus, reason)) {
+            return;
+        }
+        if (reconnectTimer) {
+            return;
+        }
+        const delay = getBackoffMs(reconnectAttempt++);
+        reconnectTimer = setTimeout(() => {
+            reconnectTimer = null;
+            void openSocket();
+        }, delay);
+    };
+    const failAndMaybeReconnect = (failedStatus, reason) => {
+        clearHandshakeTimers();
+        updateStatus(failedStatus, reason);
+        rejectAllPending(reason);
+        failConnectWaiters(reason);
+        scheduleReconnect(failedStatus, reason);
+    };
+    const makeConnectParams = async (nonce) => {
+        const identity = await loadOrCreateIdentity();
+        const signedAt = Date.now();
+        const clientId = options.clientId ?? "openclaw-control-ui";
+        const clientMode = options.clientMode ?? "webchat";
+        const role = "operator";
+        const authPayload = buildDeviceAuthPayload({
+            deviceId: identity.deviceId,
+            clientId,
+            clientMode,
+            role,
+            scopes: activeScopes,
+            signedAt,
+            token: options.token,
+            nonce,
+        });
+        const signature = signDevicePayload(identity.privateKey, authPayload.value);
+        return {
+            minProtocol: MIN_PROTOCOL,
+            maxProtocol: MAX_PROTOCOL,
+            client: {
+                id: clientId,
+                version: options.clientVersion ?? "0.1.0",
+                platform: options.platform ?? "web",
+                mode: clientMode,
+                instanceId: (0, node_crypto_1.randomUUID)(),
+            },
+            role,
+            scopes: [...activeScopes],
+            caps: ["tool-events"],
+            commands: [],
+            permissions: {
+                "device.auth.version.v1": authPayload.version === "v1",
+                "device.auth.version.v2": authPayload.version === "v2",
+            },
+            auth: { token: options.token },
+            locale: options.locale ?? "en-US",
+            userAgent: `openclaw-control/${process.version} (${process.platform})`,
+            device: {
+                id: identity.deviceId,
+                publicKey: identity.publicKey,
+                signature,
+                signedAt,
+                nonce,
+            },
+        };
+    };
+    const sendConnectRequest = async (nonce) => {
+        if (!socket || socket.readyState !== ws_1.WebSocket.OPEN) {
+            throw new Error("socket_not_open");
+        }
+        if (connectRequestId) {
+            return;
+        }
+        const reqId = `connect-${Date.now()}-${(0, node_crypto_1.randomUUID)()}`;
+        const connectParams = await makeConnectParams(nonce);
+        const req = {
+            type: "req",
+            id: reqId,
+            method: "connect",
+            params: connectParams,
+        };
+        connectRequestId = reqId;
+        updateStatus("connect_sent", null);
+        socket.send(JSON.stringify(req));
+        helloTimer = setTimeout(() => {
+            failAndMaybeReconnect("failed_timeout", "hello_timeout");
+            socket?.close();
+        }, HELLO_TIMEOUT_MS);
+    };
+    const handleHandshakeResponse = (frame) => {
+        if (!connectRequestId || frame.id !== connectRequestId) {
+            return;
+        }
+        clearTimer(helloTimer);
+        helloTimer = null;
+        if (!frame.ok) {
+            const msg = `connect_failed:${JSON.stringify(frame.error ?? {})}`;
+            failAndMaybeReconnect("failed_auth", msg);
+            socket?.close();
+            return;
+        }
+        const payload = (frame.payload ?? {});
+        if (payload?.type && payload.type !== "hello-ok") {
+            failAndMaybeReconnect("failed_protocol", `invalid_hello_type:${String(payload.type)}`);
+            return;
+        }
+        const nextProtocol = Number(payload?.protocol ?? 0);
+        if (!Number.isFinite(nextProtocol) || nextProtocol < MIN_PROTOCOL || nextProtocol > MAX_PROTOCOL) {
+            failAndMaybeReconnect("failed_protocol", `protocol_mismatch:${String(payload?.protocol)}`);
+            return;
+        }
+        protocol = nextProtocol;
+        lastHelloAt = Date.now();
+        reconnectAttempt = 0;
+        connectRequestId = null;
+        updateStatus("ready", null);
+        for (const waiter of connectWaiters) {
+            waiter.resolve(payload);
+        }
+        connectWaiters.clear();
+    };
+    const handleMessage = async (raw) => {
+        let frame;
+        try {
+            frame = JSON.parse(raw.toString());
+        }
+        catch (error) {
+            options.onError?.(error);
+            return;
+        }
+        const rawFrame = frame;
+        const diagnosticFrame = (0, frame_sanitizer_1.sanitizeGatewayFrame)(rawFrame, { maxTextLength: 16384, maxTextTailChars: 16384 });
+        options.onRawFrame?.(rawFrame);
+        options.onFrame?.(diagnosticFrame);
+        if (frame.type === "event") {
+            const event = frame;
+            if (event.event === "connect.challenge") {
+                if (status !== "ws_open") {
+                    return;
+                }
+                clearTimer(challengeTimer);
+                challengeTimer = null;
+                updateStatus("challenged", null);
+                const nonce = event.payload?.nonce;
+                try {
+                    await sendConnectRequest(nonce);
+                }
+                catch (error) {
+                    options.onError?.(error);
+                    failAndMaybeReconnect("failed_transport", "connect_send_failed");
+                    socket?.close();
+                }
+            }
+            for (const handler of eventHandlers) {
+                handler(event);
+            }
+            return;
+        }
+        if (frame.type === "res") {
+            const response = frame;
+            if (connectRequestId && response.id === connectRequestId) {
+                handleHandshakeResponse(response);
+                return;
+            }
+            const entry = pending.get(response.id);
+            if (entry) {
+                clearTimeout(entry.timer);
+                pending.delete(response.id);
+                entry.resolve(response);
+            }
+        }
+    };
+    const openSocket = async () => {
+        clearTimer(reconnectTimer);
+        reconnectTimer = null;
+        // S7 fix: 旧 socket 必须显式解绑 listener + close，避免重连时旧实例和监听器闭包滞留
+        if (socket) {
+            try {
+                socket.removeAllListeners();
+            }
+            catch { /* noop */ }
+            try {
+                socket.close();
+            }
+            catch { /* noop */ }
+            socket = null;
+        }
+        updateStatus("connecting", null);
+        connectRequestId = null;
+        socket = new ws_1.WebSocket(options.gatewayUrl, {
+            headers: { origin: CONTROL_UI_ORIGIN },
+            maxPayload: 8 * 1024 * 1024,
+        });
+        socket.on("open", () => {
+            updateStatus("ws_open", null);
+            options.onOpen?.();
+            challengeTimer = setTimeout(() => {
+                if (!connectRequestId) {
+                    failAndMaybeReconnect("failed_timeout", "challenge_timeout");
+                    socket?.close();
+                }
+            }, CHALLENGE_TIMEOUT_MS);
+        });
+        socket.on("message", (data) => {
+            void handleMessage(data);
+        });
+        socket.on("error", (error) => {
+            options.onError?.(error);
+            failAndMaybeReconnect("failed_transport", "socket_error");
+            socket?.close();
+        });
+        socket.on("close", (code, reason) => {
+            clearHandshakeTimers();
+            rejectAllPending(`socket_closed:${code}`);
+            if (status !== "failed_auth" && status !== "failed_protocol") {
+                updateStatus(isManualClose ? "closed" : "failed_transport", `closed:${code}`);
+            }
+            options.onClose?.(code, reason.toString());
+            // 握手阶段如果已经判定为鉴权/协议错误，close 只是前面主动断开的收尾动作。
+            // 这里不能再按 failed_transport 继续重连，否则 pairing required / scope-upgrade
+            // 会触发本地无限重连，持续打 127.0.0.1:18789。
+            if (!isManualClose && status !== "failed_auth" && status !== "failed_protocol") {
+                scheduleReconnect("failed_transport", `closed:${code}`);
+            }
+        });
+    };
+    const connect = async () => {
+        isManualClose = false;
+        if (status === "ready") {
+            return {
+                type: "hello-ok",
+                protocol: protocol ?? MIN_PROTOCOL,
+            };
+        }
+        const promise = new Promise((resolve, reject) => {
+            connectWaiters.add({ resolve, reject });
+        });
+        if (status === "idle" || status === "closed" || status.startsWith("failed")) {
+            await openSocket();
+        }
+        return promise;
+    };
+    const sendReq = async (method, params = {}, opts = {}) => {
+        if (status !== "ready" || !socket || socket.readyState !== ws_1.WebSocket.OPEN) {
+            throw new Error("gateway_not_ready");
+        }
+        const id = `${method}-${Date.now()}-${(0, node_crypto_1.randomUUID)()}`;
+        const timeoutMs = opts.timeoutMs ?? 15_000;
+        const finalParams = { ...params };
+        if (opts.sideEffect) {
+            finalParams.idempotencyKey = opts.idempotencyKey ?? (0, node_crypto_1.randomUUID)();
+        }
+        const request = {
+            type: "req",
+            id,
+            method,
+            params: finalParams,
+        };
+        options.onFrame?.((0, frame_sanitizer_1.sanitizeGatewayFrame)(request, { maxTextLength: 16384, maxTextTailChars: 16384 }));
+        const response = await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                pending.delete(id);
+                reject(new Error(`request_timeout:${method}`));
+            }, timeoutMs);
+            pending.set(id, { resolve, reject, timer });
+            socket?.send(JSON.stringify(request));
+        });
+        if (!response.ok) {
+            throw new Error(`request_failed:${method}:${JSON.stringify(response.error ?? {})}`);
+        }
+        return response.payload;
+    };
+    const close = () => {
+        isManualClose = true;
+        clearHandshakeTimers();
+        clearTimer(reconnectTimer);
+        reconnectTimer = null;
+        rejectAllPending("gateway_closed");
+        failConnectWaiters("gateway_closed");
+        socket?.close();
+        updateStatus("closed", null);
+    };
+    const onEvent = (handler) => {
+        eventHandlers.add(handler);
+        return () => {
+            eventHandlers.delete(handler);
+        };
+    };
+    return {
+        connect,
+        close,
+        sendReq,
+        onEvent,
+        getStatus,
+        getSocket: () => socket,
+    };
+};
+exports.createGatewayClient = createGatewayClient;

package/dist/src/gateway/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./gateway-client"), exports);

package/dist/src/gateway/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/index.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGatewayClient = void 0;
+require("dotenv/config");
+const node_http_1 = require("node:http");
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const gateway_1 = require("./gateway");
+Object.defineProperty(exports, "createGatewayClient", { enumerable: true, get: function () { return gateway_1.createGatewayClient; } });
+const create_app_context_1 = require("./app/create-app-context");
+const user_config_1 = require("./app/user-config");
+const api_handler_1 = require("./server/api-handler");
+const ws_broker_1 = require("./transport/ws-broker");
+const data_dir_1 = require("./app/data-dir");
+const serverRuntimeIdentity = {
+    serverId: (0, node_crypto_1.randomUUID)(),
+    startedAt: new Date().toISOString(),
+};
+const getServerRuntimeDir = () => {
+    const override = process.env.TASKMELD_SERVER_RUNTIME_DIR?.trim();
+    if (override)
+        return override;
+    return (0, data_dir_1.resolveTaskMeldDataPath)("server");
+};
+const getServerRuntimeMetadataPath = () => (0, node_path_1.join)(getServerRuntimeDir(), "runtime.json");
+const writeServerRuntimeMetadata = async (port) => {
+    const metadataPath = getServerRuntimeMetadataPath();
+    await (0, promises_1.mkdir)(getServerRuntimeDir(), { recursive: true });
+    await (0, promises_1.writeFile)(metadataPath, JSON.stringify({
+        serverId: serverRuntimeIdentity.serverId,
+        pid: process.pid,
+        port,
+        endpoint: `http://127.0.0.1:${port}`,
+        startedAt: serverRuntimeIdentity.startedAt,
+    }, null, 2));
+};
+const removeServerRuntimeMetadata = async () => {
+    await (0, promises_1.rm)(getServerRuntimeMetadataPath(), { force: true });
+};
+if (require.main === module) {
+    (async () => {
+        const gatewayConfig = await (0, user_config_1.resolveGatewayConfig)();
+        const appContext = (0, create_app_context_1.createAppContext)({
+            gatewayUrl: gatewayConfig.url ?? undefined,
+            gatewayToken: gatewayConfig.token ?? undefined,
+        });
+        const app = appContext.app;
+        appContext.gateway.setHandlers({
+            onStatus: (_status) => {
+                // silence intermediate status transitions
+            },
+            onError: (error) => {
+                console.error("gateway-error", error);
+            },
+        });
+        const apiServer = (0, node_http_1.createServer)((0, api_handler_1.createApiHandler)({
+            apiPort: appContext.api.port,
+            webOrigin: appContext.api.webOrigin,
+            app,
+            serverRuntimeIdentity: {
+                serverId: serverRuntimeIdentity.serverId,
+                pid: process.pid,
+                port: appContext.api.port,
+                endpoint: `http://127.0.0.1:${appContext.api.port}`,
+                startedAt: serverRuntimeIdentity.startedAt,
+            },
+        }));
+        const wsBroker = (0, ws_broker_1.createWsBroker)({
+            server: apiServer,
+            path: "/api/ws",
+            getBootstrapPayload: app.getBootstrapPayload,
+        });
+        app.runtime.setBroadcast(wsBroker.broadcast);
+        void appContext.initialize();
+        apiServer.listen(appContext.api.port, appContext.api.host, () => {
+            void writeServerRuntimeMetadata(appContext.api.port).catch((error) => {
+                console.error("server-runtime-metadata-write-failed", error);
+            });
+            console.log(`api-server-ready v${process.env.npm_package_version ?? "?.?.?"}  http://${appContext.api.host}:${appContext.api.port}`);
+        });
+        if (appContext.gateway.url && appContext.gateway.token) {
+            appContext.gateway.connect()
+                .then((hello) => {
+                const sv = hello?.server;
+                console.log(`gateway-ready  server=${sv?.version ?? "?"}  conn=${sv?.connId ?? "?"}  proto=v${hello?.protocol ?? "?"}`);
+                console.log(`taskmeld v${process.env.npm_package_version ?? "?.?.?"}  running, Ctrl+C to stop`);
+            })
+                .catch((error) => {
+                console.error("gateway-connect-failed", error);
+                console.log(`taskmeld v${process.env.npm_package_version ?? "?.?.?"}  running (gateway disconnected), Ctrl+C to stop`);
+                process.exitCode = 1;
+            });
+        }
+        else {
+            console.warn("gateway-connect-skipped missing OPENCLAW_GATEWAY_URL or OPENCLAW_GATEWAY_TOKEN");
+            console.log(`taskmeld v${process.env.npm_package_version ?? "?.?.?"}  running (no gateway), Ctrl+C to stop`);
+        }
+        let shutdownStarted = false;
+        const shutdown = () => {
+            if (shutdownStarted)
+                return;
+            shutdownStarted = true;
+            wsBroker.close();
+            appContext.dispose();
+            void removeServerRuntimeMetadata().catch(() => { });
+        };
+        process.on("SIGTERM", () => {
+            shutdown();
+            process.exit(0);
+        });
+        process.on("SIGINT", () => {
+            shutdown();
+            process.exit(0);
+        });
+        process.on("exit", () => {
+            shutdown();
+        });
+    })().catch((error) => {
+        console.error("app-context-create-failed", error);
+        process.exit(1);
+    });
+}