@companyhelm/cli 0.0.2

package/dist/state/service/app_server.js

@@ -0,0 +1,392 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppServerService = void 0;
+const async_queue_js_1 = require("../utils/async_queue.js");
+const NOOP_APP_SERVER_LOGGER = { debug: () => undefined };
+class AppServerTimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AppServerTimeoutError";
+    }
+}
+function hasTag(message) {
+    return typeof message === "object" && message !== null && "type" in message;
+}
+function isResponseMessage(message) {
+    return (typeof message === "object" &&
+        message !== null &&
+        "id" in message &&
+        !("method" in message) &&
+        !("type" in message));
+}
+function isServerNotificationMessage(message) {
+    return (typeof message === "object" &&
+        message !== null &&
+        "method" in message &&
+        "params" in message);
+}
+function formatUnknownError(value) {
+    if (value instanceof Error) {
+        return value.message;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function isModelListResponse(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const data = value.data;
+    const nextCursor = value.nextCursor;
+    return Array.isArray(data) && (typeof nextCursor === "string" || nextCursor === null);
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasMessageShape(value) {
+    return isJsonObject(value) && ("method" in value || "id" in value || "result" in value || "error" in value);
+}
+class AppServerService {
+    constructor(transport, clientName, logger) {
+        this.stream = null;
+        this.pumpTask = null;
+        this.messageQueue = new async_queue_js_1.AsyncQueue();
+        this.pendingRequests = new Map();
+        this.pendingResponses = new Map();
+        this.nextRequestId = 1;
+        this.stderrLines = [];
+        this.stdoutBuffer = Buffer.alloc(0);
+        this.framing = "unknown";
+        this.transport = transport;
+        this.clientName = clientName;
+        this.logger = logger ?? NOOP_APP_SERVER_LOGGER;
+    }
+    async start() {
+        await this.transport.start();
+        this.stream = this.transport.receiveOutput();
+        this.pumpTask = this.pumpMessages();
+        await this.initialize();
+    }
+    async stop() {
+        const pump = this.pumpTask;
+        this.pumpTask = null;
+        this.stream = null;
+        this.rejectAllPendingRequests(new Error("app-server stopped"));
+        this.pendingResponses.clear();
+        this.messageQueue.close();
+        this.stdoutBuffer = Buffer.alloc(0);
+        this.framing = "unknown";
+        await this.transport.stop();
+        if (pump) {
+            await pump;
+        }
+    }
+    async listModels(cursor, limit) {
+        const result = await this.request("model/list", { cursor, limit }, 10000);
+        if (!isModelListResponse(result)) {
+            throw new Error("app-server returned an invalid model/list payload");
+        }
+        return result;
+    }
+    async startThread(params) {
+        return this.request("thread/start", params, 15000);
+    }
+    async resumeThread(params) {
+        return this.request("thread/resume", params, 15000);
+    }
+    async startTurn(params) {
+        return this.request("turn/start", params, 15000);
+    }
+    async steerTurn(params) {
+        return this.request("turn/steer", params, 15000);
+    }
+    async interruptTurn(params) {
+        return this.request("turn/interrupt", params, 15000);
+    }
+    async waitForTurnCompletion(threadId, turnId, onNotification, timeoutMs = 2 * 60 * 60000) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            const remaining = Math.max(1, deadline - Date.now());
+            const message = await this.popMessageWithTimeout(remaining);
+            if (!message) {
+                break;
+            }
+            if (hasTag(message)) {
+                if (message.type === "parse_error") {
+                    throw new Error(`Failed to parse app-server message: ${message.reason}`);
+                }
+                if (message.type === "stderr") {
+                    const trimmed = message.payload.trim();
+                    if (trimmed.length > 0) {
+                        this.stderrLines.push(trimmed);
+                    }
+                }
+                continue;
+            }
+            if (isResponseMessage(message)) {
+                continue;
+            }
+            if (!isServerNotificationMessage(message)) {
+                continue;
+            }
+            if (onNotification) {
+                await onNotification(message);
+            }
+            if (message.method === "error" &&
+                message.params.threadId === threadId &&
+                message.params.turnId === turnId) {
+                throw new Error(message.params.error.message);
+            }
+            if (message.method === "turn/completed" &&
+                message.params.threadId === threadId &&
+                message.params.turn.id === turnId) {
+                const status = message.params.turn.status;
+                if (status === "completed" || status === "interrupted" || status === "failed") {
+                    return status;
+                }
+            }
+        }
+        throw new AppServerTimeoutError(`Timed out waiting for completion of turn '${turnId}' in thread '${threadId}'.`);
+    }
+    async initialize() {
+        const params = {
+            clientInfo: {
+                name: this.clientName,
+                title: null,
+                version: "0.0.1",
+            },
+            capabilities: {
+                experimentalApi: true,
+                optOutNotificationMethods: [],
+            },
+        };
+        const attempts = 5;
+        for (let attempt = 1; attempt <= attempts; attempt += 1) {
+            try {
+                await this.request("initialize", params, 3000);
+                return;
+            }
+            catch (error) {
+                if (!(error instanceof AppServerTimeoutError) || attempt === attempts) {
+                    throw error;
+                }
+            }
+        }
+    }
+    async request(method, params, timeoutMs) {
+        const requestId = this.nextRequestId++;
+        const request = {
+            method,
+            id: requestId,
+            params,
+        };
+        await this.sendMessage(request);
+        return this.waitForResponseResult(requestId, timeoutMs);
+    }
+    async sendMessage(message) {
+        const payload = JSON.stringify(message);
+        this.logger.debug(`[app-server][outgoing] ${payload}`);
+        await this.transport.sendRaw(`${payload}\n`);
+    }
+    async pumpMessages() {
+        if (!this.stream) {
+            return;
+        }
+        try {
+            for await (const event of this.stream) {
+                if (event.type === "stdout") {
+                    this.consumeStdout(event.payload);
+                    continue;
+                }
+                if (event.type === "stderr") {
+                    this.messageQueue.push({ type: "stderr", payload: event.payload });
+                    continue;
+                }
+                this.rejectAllPendingRequests(new Error(event.reason));
+                this.messageQueue.push({
+                    type: "parse_error",
+                    payload: "",
+                    reason: event.reason,
+                });
+            }
+        }
+        finally {
+            this.messageQueue.close();
+        }
+    }
+    consumeStdout(chunk) {
+        this.stdoutBuffer = Buffer.concat([this.stdoutBuffer, chunk]);
+        while (true) {
+            if (this.framing === "unknown") {
+                if (this.stdoutBuffer.length === 0) {
+                    return;
+                }
+                const head = this.stdoutBuffer.toString("utf8", 0, Math.min(this.stdoutBuffer.length, 64));
+                if (head.startsWith("Content-Length:")) {
+                    this.framing = "content-length";
+                }
+                else if (this.stdoutBuffer.includes(0x0a)) {
+                    this.framing = "newline";
+                }
+                else {
+                    return;
+                }
+            }
+            if (this.framing === "content-length") {
+                const payload = this.tryParseContentLengthFrame();
+                if (!payload) {
+                    return;
+                }
+                this.processPayload(payload);
+                continue;
+            }
+            const payload = this.tryParseNewlineFrame();
+            if (!payload) {
+                return;
+            }
+            this.processPayload(payload);
+        }
+    }
+    tryParseContentLengthFrame() {
+        const crlfDelimiter = Buffer.from("\r\n\r\n");
+        const lfDelimiter = Buffer.from("\n\n");
+        let headerEnd = this.stdoutBuffer.indexOf(crlfDelimiter);
+        let delimiterBytes = 4;
+        if (headerEnd < 0) {
+            headerEnd = this.stdoutBuffer.indexOf(lfDelimiter);
+            delimiterBytes = 2;
+        }
+        if (headerEnd < 0) {
+            return null;
+        }
+        const headerText = this.stdoutBuffer.subarray(0, headerEnd).toString("utf8");
+        const match = /Content-Length:\s*(\d+)/i.exec(headerText);
+        if (!match) {
+            this.stdoutBuffer = this.stdoutBuffer.subarray(headerEnd + delimiterBytes);
+            this.messageQueue.push({
+                type: "parse_error",
+                payload: headerText,
+                reason: "missing Content-Length header",
+            });
+            return null;
+        }
+        const contentLength = Number.parseInt(match[1], 10);
+        const bodyStart = headerEnd + delimiterBytes;
+        const bodyEnd = bodyStart + contentLength;
+        if (this.stdoutBuffer.length < bodyEnd) {
+            return null;
+        }
+        const payload = this.stdoutBuffer.subarray(bodyStart, bodyEnd).toString("utf8");
+        this.stdoutBuffer = this.stdoutBuffer.subarray(bodyEnd);
+        return payload;
+    }
+    tryParseNewlineFrame() {
+        const newlineIndex = this.stdoutBuffer.indexOf(0x0a);
+        if (newlineIndex < 0) {
+            return null;
+        }
+        const line = this.stdoutBuffer.subarray(0, newlineIndex).toString("utf8").replace(/\r$/, "");
+        this.stdoutBuffer = this.stdoutBuffer.subarray(newlineIndex + 1);
+        if (!line.trim()) {
+            return "";
+        }
+        return line;
+    }
+    processPayload(payload) {
+        if (!payload.trim()) {
+            return;
+        }
+        this.logger.debug(`[app-server][incoming] ${payload}`);
+        let parsed;
+        try {
+            parsed = JSON.parse(payload);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : "invalid JSON";
+            this.messageQueue.push({ type: "parse_error", payload, reason });
+            return;
+        }
+        if (!hasMessageShape(parsed)) {
+            this.rejectAllPendingRequests(new Error("message does not match expected app-server envelope"));
+            this.messageQueue.push({
+                type: "parse_error",
+                payload,
+                reason: "message does not match expected app-server envelope",
+            });
+            return;
+        }
+        const message = parsed;
+        if (isResponseMessage(message)) {
+            this.routeResponseMessage(message);
+            return;
+        }
+        this.messageQueue.push(message);
+    }
+    async popMessageWithTimeout(timeoutMs) {
+        return this.messageQueue.popWithTimeout(timeoutMs);
+    }
+    routeResponseMessage(message) {
+        const pendingRequest = this.pendingRequests.get(message.id);
+        if (!pendingRequest) {
+            this.pendingResponses.set(message.id, message);
+            return;
+        }
+        this.pendingRequests.delete(message.id);
+        clearTimeout(pendingRequest.timeout);
+        if (message.error !== undefined) {
+            pendingRequest.reject(new Error(`app-server returned an error for request ${String(message.id)}: ${formatUnknownError(message.error)}`));
+            return;
+        }
+        pendingRequest.resolve(message.result);
+    }
+    rejectAllPendingRequests(error) {
+        for (const [requestId, pendingRequest] of this.pendingRequests.entries()) {
+            this.pendingRequests.delete(requestId);
+            clearTimeout(pendingRequest.timeout);
+            pendingRequest.reject(new Error(`request ${String(requestId)} failed: ${error.message}`));
+        }
+    }
+    async waitForResponseResult(requestId, timeoutMs) {
+        const immediateResponse = this.pendingResponses.get(requestId);
+        if (immediateResponse) {
+            this.pendingResponses.delete(requestId);
+            if (immediateResponse.error !== undefined) {
+                throw new Error(`app-server returned an error for request ${String(requestId)}: ${formatUnknownError(immediateResponse.error)}`);
+            }
+            return immediateResponse.result;
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(requestId);
+                reject(new AppServerTimeoutError(`Timed out waiting for response to request ${String(requestId)}`));
+            }, timeoutMs);
+            const pendingRequest = {
+                timeout,
+                resolve: (result) => {
+                    resolve(result);
+                },
+                reject: (error) => {
+                    reject(error);
+                },
+            };
+            this.pendingRequests.set(requestId, pendingRequest);
+            const bufferedResponse = this.pendingResponses.get(requestId);
+            if (!bufferedResponse) {
+                return;
+            }
+            this.pendingResponses.delete(requestId);
+            this.pendingRequests.delete(requestId);
+            clearTimeout(timeout);
+            if (bufferedResponse.error !== undefined) {
+                reject(new Error(`app-server returned an error for request ${String(requestId)}: ${formatUnknownError(bufferedResponse.error)}`));
+                return;
+            }
+            resolve(bufferedResponse.result);
+        });
+    }
+}
+exports.AppServerService = AppServerService;

package/dist/state/service/buffered_client_message_sender.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BufferedClientMessageSender = void 0;
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+class BufferedClientMessageSender {
+    constructor(options) {
+        this.bufferedMessages = [];
+        this.channel = null;
+        this.flushing = false;
+        this.droppedMessages = 0;
+        this.maxBufferedMessages = Math.max(1, options.maxBufferedMessages);
+        this.logger = options.logger;
+    }
+    bind(channel) {
+        this.channel = channel;
+        if (this.bufferedMessages.length > 0) {
+            this.logger.debug(`Bound command channel and attempting to flush ${this.bufferedMessages.length} buffered client message(s).`);
+        }
+        void this.flush();
+    }
+    unbind(channel) {
+        if (!channel || this.channel === channel) {
+            this.channel = null;
+        }
+    }
+    async send(message) {
+        this.enqueue(message);
+        await this.flush();
+    }
+    getBufferedMessageCount() {
+        return this.bufferedMessages.length;
+    }
+    getDroppedMessageCount() {
+        return this.droppedMessages;
+    }
+    enqueue(message) {
+        if (this.bufferedMessages.length >= this.maxBufferedMessages) {
+            this.droppedMessages += 1;
+            if (this.droppedMessages === 1 || this.droppedMessages % 100 === 0) {
+                this.logger.warn(`Dropping client message because outbound buffer reached ${this.maxBufferedMessages} messages ` +
+                    `(dropped=${this.droppedMessages}).`);
+            }
+            return;
+        }
+        this.bufferedMessages.push(message);
+    }
+    async flush() {
+        if (this.flushing) {
+            return;
+        }
+        this.flushing = true;
+        try {
+            while (this.channel && this.bufferedMessages.length > 0) {
+                const nextMessage = this.bufferedMessages[0];
+                try {
+                    await this.channel.send(nextMessage);
+                    this.bufferedMessages.shift();
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to send buffered client message: ${toErrorMessage(error)}`);
+                    this.channel = null;
+                    break;
+                }
+            }
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+}
+exports.BufferedClientMessageSender = BufferedClientMessageSender;