@companyhelm/cli 0.0.2 → 0.0.6

package/dist/state/service/app_server.js

@@ -1,392 +0,0 @@
-"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

@@ -1,73 +0,0 @@
-"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;