@companyhelm/runner 0.0.12 → 0.0.13

package/dist/service/companyhelm_api_client.js

@@ -0,0 +1,337 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompanyhelmApiClient = exports.CompanyhelmCommandChannel = void 0;
+exports.parseCompanyhelmApiUrl = parseCompanyhelmApiUrl;
+exports.createAgentRunnerControlServiceDefinition = createAgentRunnerControlServiceDefinition;
+const protobuf_1 = require("@bufbuild/protobuf");
+const protos_1 = require("@companyhelm/protos");
+const grpc = __importStar(require("@grpc/grpc-js"));
+const async_queue_js_1 = require("../utils/async_queue.js");
+function normalizePathPrefix(value) {
+    if (!value || value === "/") {
+        return "";
+    }
+    const withLeadingSlash = value.startsWith("/") ? value : `/${value}`;
+    const withoutTrailingSlash = withLeadingSlash.replace(/\/+$/g, "");
+    return withoutTrailingSlash === "/" ? "" : withoutTrailingSlash;
+}
+function buildRpcPath(methodName, pathPrefix) {
+    return `${normalizePathPrefix(pathPrefix)}/${protos_1.AgentRunnerControlService.typeName}/${methodName}`.replace(/\/{2,}/g, "/");
+}
+function extractTargetHost(target) {
+    const trimmed = target.trim().toLowerCase();
+    if (trimmed.startsWith("[")) {
+        const closingBracketIndex = trimmed.indexOf("]");
+        if (closingBracketIndex > 0) {
+            return trimmed.slice(1, closingBracketIndex);
+        }
+    }
+    const colonIndex = trimmed.indexOf(":");
+    return colonIndex >= 0 ? trimmed.slice(0, colonIndex) : trimmed;
+}
+function isLikelyLocalTarget(target) {
+    const host = extractTargetHost(target);
+    return host === "localhost" || host === "127.0.0.1" || host === "0.0.0.0" || host === "::1";
+}
+function parseCompanyhelmApiUrl(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new Error("companyhelm_api_url cannot be empty.");
+    }
+    if (trimmed.includes("://")) {
+        const parsed = new URL(trimmed);
+        const host = parsed.hostname.includes(":") ? `[${parsed.hostname}]` : parsed.hostname;
+        const target = parsed.port ? `${host}:${parsed.port}` : host;
+        if (!target) {
+            throw new Error(`Invalid companyhelm_api_url '${value}'.`);
+        }
+        return {
+            target,
+            pathPrefix: normalizePathPrefix(parsed.pathname),
+            useTls: parsed.protocol !== "http:",
+        };
+    }
+    const firstSlash = trimmed.indexOf("/");
+    const target = firstSlash >= 0 ? trimmed.slice(0, firstSlash) : trimmed;
+    const pathPrefix = firstSlash >= 0 ? trimmed.slice(firstSlash) : "";
+    if (!target) {
+        throw new Error(`Invalid companyhelm_api_url '${value}'.`);
+    }
+    return {
+        target,
+        pathPrefix: normalizePathPrefix(pathPrefix),
+        useTls: !isLikelyLocalTarget(target),
+    };
+}
+function defaultCredentials(endpoint) {
+    return endpoint.useTls ? grpc.credentials.createSsl() : grpc.credentials.createInsecure();
+}
+function createAgentRunnerControlServiceDefinition(pathPrefix = "") {
+    const methods = protos_1.AgentRunnerControlService.method;
+    return {
+        registerRunner: {
+            path: buildRpcPath(methods.registerRunner.name, pathPrefix),
+            requestStream: false,
+            responseStream: false,
+            requestSerialize: (request) => Buffer.from((0, protobuf_1.toBinary)(protos_1.RegisterRunnerRequestSchema, request)),
+            requestDeserialize: (bytes) => (0, protobuf_1.fromBinary)(protos_1.RegisterRunnerRequestSchema, bytes),
+            responseSerialize: (response) => Buffer.from((0, protobuf_1.toBinary)(protos_1.RegisterRunnerResponseSchema, response)),
+            responseDeserialize: (bytes) => (0, protobuf_1.fromBinary)(protos_1.RegisterRunnerResponseSchema, bytes),
+        },
+        controlChannel: {
+            path: buildRpcPath(methods.controlChannel.name, pathPrefix),
+            requestStream: true,
+            responseStream: true,
+            requestSerialize: (request) => Buffer.from((0, protobuf_1.toBinary)(protos_1.ClientMessageSchema, request)),
+            requestDeserialize: (bytes) => (0, protobuf_1.fromBinary)(protos_1.ClientMessageSchema, bytes),
+            responseSerialize: (response) => Buffer.from((0, protobuf_1.toBinary)(protos_1.ServerMessageSchema, response)),
+            responseDeserialize: (bytes) => (0, protobuf_1.fromBinary)(protos_1.ServerMessageSchema, bytes),
+        },
+        listGithubInstallationsForRunner: {
+            path: buildRpcPath(methods.listGithubInstallations.name, pathPrefix),
+            requestStream: false,
+            responseStream: false,
+            requestSerialize: (request) => Buffer.from((0, protobuf_1.toBinary)(protos_1.ListGithubInstallationsRequestSchema, request)),
+            requestDeserialize: (bytes) => (0, protobuf_1.fromBinary)(protos_1.ListGithubInstallationsRequestSchema, bytes),
+            responseSerialize: (response) => Buffer.from((0, protobuf_1.toBinary)(protos_1.ListGithubInstallationsResponseSchema, response)),
+            responseDeserialize: (bytes) => (0, protobuf_1.fromBinary)(protos_1.ListGithubInstallationsResponseSchema, bytes),
+        },
+        getGithubInstallationAccessTokenForRunner: {
+            path: buildRpcPath(methods.githubInstallationAccessToken.name, pathPrefix),
+            requestStream: false,
+            responseStream: false,
+            requestSerialize: (request) => Buffer.from((0, protobuf_1.toBinary)(protos_1.GithubInstallationAccessTokenRequestSchema, request)),
+            requestDeserialize: (bytes) => (0, protobuf_1.fromBinary)(protos_1.GithubInstallationAccessTokenRequestSchema, bytes),
+            responseSerialize: (response) => Buffer.from((0, protobuf_1.toBinary)(protos_1.GithubInstallationAccessTokenResponseSchema, response)),
+            responseDeserialize: (bytes) => (0, protobuf_1.fromBinary)(protos_1.GithubInstallationAccessTokenResponseSchema, bytes),
+        },
+    };
+}
+function createAgentRunnerControlClient(endpoint, credentials, channelOptions) {
+    const ClientCtor = grpc.makeGenericClientConstructor(createAgentRunnerControlServiceDefinition(endpoint.pathPrefix), "AgentRunnerControlService");
+    return new ClientCtor(endpoint.target, credentials, channelOptions);
+}
+function toError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+const NOOP_COMPANYHELM_API_CLIENT_LOGGER = {
+    debug: () => undefined,
+};
+function stringifyMessageForLog(message) {
+    try {
+        return JSON.stringify(message, (_, value) => (typeof value === "bigint" ? value.toString() : value));
+    }
+    catch {
+        return String(message);
+    }
+}
+function describeServerMessage(message) {
+    return message.request.case ?? "unknown";
+}
+function describeClientMessage(message) {
+    return message.payload.case ?? "unknown";
+}
+class CompanyhelmCommandChannel {
+    constructor(call, logger) {
+        this.messages = new async_queue_js_1.AsyncQueue();
+        this.resolveOpened = null;
+        this.rejectOpened = null;
+        this.openState = "pending";
+        this.call = call;
+        this.logger = logger ?? NOOP_COMPANYHELM_API_CLIENT_LOGGER;
+        this.opened = new Promise((resolve, reject) => {
+            this.resolveOpened = resolve;
+            this.rejectOpened = reject;
+        });
+        call.on("data", (message) => {
+            this.setOpened();
+            this.logger.debug(`[companyhelm-api][incoming][server-message:${describeServerMessage(message)}] ${stringifyMessageForLog(message)}`);
+            this.messages.push(message);
+        });
+        call.on("metadata", () => {
+            this.setOpened();
+        });
+        call.on("end", () => {
+            this.failOpen(new Error("command channel closed before becoming usable"));
+            this.messages.close();
+        });
+        call.on("error", (error) => {
+            const serviceError = error;
+            if (serviceError.code === grpc.status.CANCELLED) {
+                this.failOpen(new Error("command channel cancelled before becoming usable"));
+                this.messages.close();
+                return;
+            }
+            const channelError = toError(error);
+            this.failOpen(channelError);
+            this.messages.fail(channelError);
+        });
+        call.on("status", (status) => {
+            if (status.code === grpc.status.OK || status.code === grpc.status.CANCELLED) {
+                return;
+            }
+            const statusError = new Error(`command channel closed with status ${status.code}: ${status.details}`);
+            this.failOpen(statusError);
+            this.messages.fail(statusError);
+        });
+    }
+    setOpened() {
+        if (this.openState !== "pending") {
+            return;
+        }
+        this.openState = "opened";
+        this.resolveOpened?.();
+        this.resolveOpened = null;
+        this.rejectOpened = null;
+    }
+    failOpen(error) {
+        if (this.openState !== "pending") {
+            return;
+        }
+        this.openState = "failed";
+        this.rejectOpened?.(error);
+        this.resolveOpened = null;
+        this.rejectOpened = null;
+    }
+    send(message) {
+        this.logger.debug(`[companyhelm-api][outgoing][client-message:${describeClientMessage(message)}] ${stringifyMessageForLog(message)}`);
+        return new Promise((resolve, reject) => {
+            this.call.write(message, (error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    closeWrite() {
+        this.call.end();
+    }
+    cancel() {
+        this.call.cancel();
+    }
+    async waitForOpen(timeoutMs = 5000) {
+        let timeoutHandle;
+        try {
+            await Promise.race([
+                this.opened,
+                new Promise((_, reject) => {
+                    timeoutHandle = setTimeout(() => {
+                        reject(new Error(`command channel did not open within ${timeoutMs}ms`));
+                    }, timeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+        }
+    }
+    nextMessage() {
+        return this.messages.pop();
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            const message = await this.nextMessage();
+            if (message === null) {
+                return;
+            }
+            yield message;
+        }
+    }
+}
+exports.CompanyhelmCommandChannel = CompanyhelmCommandChannel;
+class CompanyhelmApiClient {
+    constructor(options) {
+        this.endpoint = parseCompanyhelmApiUrl(options.apiUrl);
+        this.logger = options.logger ?? NOOP_COMPANYHELM_API_CLIENT_LOGGER;
+        this.client = createAgentRunnerControlClient(this.endpoint, options.credentials ?? defaultCredentials(this.endpoint), options.channelOptions);
+    }
+    registerRunner(request, options) {
+        const metadata = options?.metadata ?? new grpc.Metadata();
+        const callOptions = options?.callOptions ?? {};
+        return new Promise((resolve, reject) => {
+            this.client.registerRunner(request, metadata, callOptions, (error, response) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(response ?? (0, protobuf_1.create)(protos_1.RegisterRunnerResponseSchema));
+            });
+        });
+    }
+    async connect(registerRequest, options) {
+        await this.registerRunner(registerRequest, options);
+        const stream = this.client.controlChannel(options?.metadata, options?.callOptions);
+        return new CompanyhelmCommandChannel(stream, this.logger);
+    }
+    listGithubInstallationsForRunner(options) {
+        const metadata = options?.metadata ?? new grpc.Metadata();
+        const callOptions = options?.callOptions ?? {};
+        const request = (0, protobuf_1.create)(protos_1.ListGithubInstallationsRequestSchema, {});
+        return new Promise((resolve, reject) => {
+            this.client.listGithubInstallationsForRunner(request, metadata, callOptions, (error, response) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(response ?? (0, protobuf_1.create)(protos_1.ListGithubInstallationsResponseSchema, {}));
+            });
+        });
+    }
+    getGithubInstallationAccessTokenForRunner(installationId, options) {
+        const metadata = options?.metadata ?? new grpc.Metadata();
+        const callOptions = options?.callOptions ?? {};
+        const request = (0, protobuf_1.create)(protos_1.GithubInstallationAccessTokenRequestSchema, {
+            installationId,
+        });
+        return new Promise((resolve, reject) => {
+            this.client.getGithubInstallationAccessTokenForRunner(request, metadata, callOptions, (error, response) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(response ?? (0, protobuf_1.create)(protos_1.GithubInstallationAccessTokenResponseSchema, {}));
+            });
+        });
+    }
+    close() {
+        this.client.close();
+    }
+}
+exports.CompanyhelmApiClient = CompanyhelmApiClient;

package/dist/service/docker/app_server_container.js

@@ -0,0 +1,319 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppServerContainerService = void 0;
+const node_fs_1 = require("node:fs");
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+const drizzle_orm_1 = require("drizzle-orm");
+const dockerode_1 = __importDefault(require("dockerode"));
+const config_js_1 = require("../../config.js");
+const db_js_1 = require("../../state/db.js");
+const schema_js_1 = require("../../state/schema.js");
+const async_queue_js_1 = require("../../utils/async_queue.js");
+const path_js_1 = require("../../utils/path.js");
+const runtime_shell_js_1 = require("../runtime_shell.js");
+const host_js_1 = require("../host.js");
+const DEFAULT_APP_SERVER_COMMAND = (0, runtime_shell_js_1.buildCodexAppServerCommand)();
+const BOOTSTRAP_TEMPLATE_PATH = "templates/app_server_bootstrap.sh.j2";
+function resolveContainerPath(path, containerHome) {
+    if (path === "~") {
+        return containerHome;
+    }
+    if (path.startsWith("~/")) {
+        return `${containerHome}${path.slice(1)}`;
+    }
+    return path;
+}
+function resolveTemplatePath() {
+    const distRelativePath = (0, node_path_1.join)(__dirname, "..", "..", BOOTSTRAP_TEMPLATE_PATH);
+    if ((0, node_fs_1.existsSync)(distRelativePath)) {
+        return distRelativePath;
+    }
+    const sourceRelativePath = (0, node_path_1.join)(__dirname, "..", "..", "..", "src", BOOTSTRAP_TEMPLATE_PATH);
+    if ((0, node_fs_1.existsSync)(sourceRelativePath)) {
+        return sourceRelativePath;
+    }
+    throw new Error(`Bootstrap template was not found at ${distRelativePath} or ${sourceRelativePath}`);
+}
+function renderJinjaTemplate(template, context) {
+    return template.replace(/{{\s*([a-zA-Z0-9_]+)\s*}}/g, (_match, key) => {
+        const value = context[key];
+        if (value === undefined) {
+            throw new Error(`Missing template value for key '${key}'`);
+        }
+        return value;
+    });
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+class AppServerContainerService {
+    constructor(options) {
+        this.messageQueue = new async_queue_js_1.AsyncQueue();
+        this.child = null;
+        this.containerName = null;
+        this.running = false;
+        this.recentStderrLines = [];
+        this.lastExitCode = null;
+        this.lastExitSignal = null;
+        this.docker = options?.docker ?? new dockerode_1.default();
+        this.imageStatusReporter = options?.imageStatusReporter;
+    }
+    reportImageStatus(message) {
+        this.imageStatusReporter?.(message);
+    }
+    recordStderr(chunk) {
+        const lines = chunk
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+        if (lines.length === 0) {
+            return;
+        }
+        this.recentStderrLines.push(...lines);
+        if (this.recentStderrLines.length > 8) {
+            this.recentStderrLines.splice(0, this.recentStderrLines.length - 8);
+        }
+    }
+    buildContainerStoppedErrorMessage() {
+        const details = [];
+        if (this.containerName) {
+            details.push(`container ${this.containerName}`);
+        }
+        if (this.lastExitCode !== null) {
+            details.push(`exit code ${this.lastExitCode}`);
+        }
+        else if (this.lastExitSignal) {
+            details.push(`signal ${this.lastExitSignal}`);
+        }
+        if (this.recentStderrLines.length > 0) {
+            details.push(`stderr: ${this.recentStderrLines.join(" | ")}`);
+        }
+        return details.length > 0
+            ? `App server container is not running (${details.join(", ")})`
+            : "App server container is not running";
+    }
+    static isImageNotFound(error) {
+        if (typeof error !== "object" || error === null) {
+            return false;
+        }
+        const statusCode = "statusCode" in error ? error.statusCode : undefined;
+        if (statusCode === 404) {
+            return true;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return /No such image/i.test(message);
+    }
+    static isRecord(value) {
+        return typeof value === "object" && value !== null;
+    }
+    async pullImage(image) {
+        let lastReportedProgressBucket = -1;
+        const layerProgress = new Map();
+        let lastReportedStatus = "";
+        const reportPullProgress = (event) => {
+            if (!AppServerContainerService.isRecord(event)) {
+                return;
+            }
+            const status = typeof event.status === "string" ? event.status.trim() : "";
+            const id = typeof event.id === "string" ? event.id.trim() : "";
+            const progressDetail = AppServerContainerService.isRecord(event.progressDetail) ? event.progressDetail : null;
+            const current = progressDetail && typeof progressDetail.current === "number"
+                ? progressDetail.current
+                : undefined;
+            const total = progressDetail && typeof progressDetail.total === "number"
+                ? progressDetail.total
+                : undefined;
+            if (id && current !== undefined && total !== undefined && total > 0) {
+                layerProgress.set(id, { current: Math.min(current, total), total });
+                let totalCurrent = 0;
+                let totalSize = 0;
+                for (const progress of layerProgress.values()) {
+                    totalCurrent += progress.current;
+                    totalSize += progress.total;
+                }
+                if (totalSize > 0) {
+                    const percent = Math.floor((totalCurrent / totalSize) * 100);
+                    const bucket = Math.floor(percent / 5) * 5;
+                    if (bucket > lastReportedProgressBucket) {
+                        lastReportedProgressBucket = bucket;
+                        this.reportImageStatus(`Pulling Docker image '${image}': ${bucket}%`);
+                    }
+                }
+                return;
+            }
+            if (status && status !== lastReportedStatus) {
+                lastReportedStatus = status;
+                this.reportImageStatus(`Pulling Docker image '${image}': ${status}`);
+            }
+        };
+        await new Promise((resolve, reject) => {
+            this.docker.pull(image, (error, stream) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                if (!stream) {
+                    reject(new Error(`Docker returned an empty stream while pulling image '${image}'.`));
+                    return;
+                }
+                const modem = this.docker.modem;
+                if (!modem?.followProgress) {
+                    resolve();
+                    return;
+                }
+                modem.followProgress(stream, (pullError) => {
+                    if (pullError) {
+                        reject(pullError);
+                        return;
+                    }
+                    resolve();
+                }, reportPullProgress);
+            });
+        });
+    }
+    async ensureImageAvailable(image) {
+        try {
+            await this.docker.getImage(image).inspect();
+            return;
+        }
+        catch (error) {
+            if (!AppServerContainerService.isImageNotFound(error)) {
+                throw error;
+            }
+        }
+        this.reportImageStatus(`Docker image '${image}' not found locally. Pulling remotely.`);
+        await this.pullImage(image);
+        this.reportImageStatus(`Docker image '${image}' is ready.`);
+    }
+    async start() {
+        if (this.running) {
+            throw new Error("App server container is already running");
+        }
+        this.recentStderrLines = [];
+        this.lastExitCode = null;
+        this.lastExitSignal = null;
+        const cfg = config_js_1.config.parse({});
+        await this.ensureImageAvailable(cfg.runtime_image);
+        const { db, client } = await (0, db_js_1.initDb)(cfg.state_db_path);
+        let codexAuthMode;
+        try {
+            const sdk = await db.select().from(schema_js_1.agentSdks).where((0, drizzle_orm_1.eq)(schema_js_1.agentSdks.name, "codex")).get();
+            if (!sdk) {
+                throw new Error("Codex SDK is not configured.");
+            }
+            if (!sdk.authentication || sdk.authentication === "unauthenticated") {
+                throw new Error("Codex SDK authentication is not configured.");
+            }
+            codexAuthMode = sdk.authentication;
+        }
+        finally {
+            client.close();
+        }
+        const hostInfo = (0, host_js_1.getHostInfo)(cfg.codex.codex_auth_path);
+        const containerHome = cfg.agent_home_directory;
+        const containerAuthPath = resolveContainerPath(cfg.codex.codex_auth_path, containerHome);
+        const hostDedicatedAuthPath = `${(0, path_js_1.expandHome)(cfg.config_directory)}/${cfg.codex.codex_auth_file_path}`;
+        const mountArgs = [];
+        if (codexAuthMode === "dedicated") {
+            if (!(0, host_js_1.getHostInfo)(hostDedicatedAuthPath).codexAuthExists) {
+                throw new Error(`Dedicated Codex auth file was not found at ${hostDedicatedAuthPath}`);
+            }
+            mountArgs.push("--mount", `type=bind,src=${hostDedicatedAuthPath},dst=${containerAuthPath}`);
+        }
+        this.containerName = `companyhelm-codex-app-server-${Date.now()}`;
+        const bootstrapTemplate = (0, node_fs_1.readFileSync)(resolveTemplatePath(), "utf8");
+        const bootstrapScript = renderJinjaTemplate(bootstrapTemplate, {
+            agent_user: shellQuote(cfg.agent_user),
+            agent_home: shellQuote(containerHome),
+            agent_uid: shellQuote(String(hostInfo.uid)),
+            agent_gid: shellQuote(String(hostInfo.gid)),
+            codex_auth_path: shellQuote(containerAuthPath),
+            app_server_command: shellQuote(DEFAULT_APP_SERVER_COMMAND),
+        });
+        const args = [
+            "run",
+            "--rm",
+            "-i",
+            "--name",
+            this.containerName,
+            "--entrypoint",
+            "bash",
+            ...mountArgs,
+            cfg.runtime_image,
+            "-lc",
+            bootstrapScript,
+        ];
+        this.reportImageStatus(`Launching Docker container from image '${cfg.runtime_image}'.`);
+        const child = (0, node_child_process_1.spawn)("docker", args, {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        child.stdout.on("data", (chunk) => {
+            this.messageQueue.push({ type: "stdout", payload: chunk });
+        });
+        child.stderr.on("data", (chunk) => {
+            const payload = chunk.toString("utf8");
+            this.recordStderr(payload);
+            this.messageQueue.push({ type: "stderr", payload });
+        });
+        child.on("error", (err) => {
+            this.recordStderr(err.message);
+            this.messageQueue.push({ type: "error", reason: `docker process error: ${err.message}` });
+            this.running = false;
+            this.messageQueue.close();
+        });
+        child.on("exit", (code, signal) => {
+            const wasRunning = this.running;
+            this.lastExitCode = code;
+            this.lastExitSignal = signal;
+            this.running = false;
+            if (wasRunning) {
+                this.messageQueue.push({
+                    type: "error",
+                    reason: this.buildContainerStoppedErrorMessage(),
+                });
+            }
+            this.messageQueue.close();
+        });
+        this.child = child;
+        this.running = true;
+        this.reportImageStatus(`Waiting for app-server to initialize in Docker container '${this.containerName}'.`);
+    }
+    async stop() {
+        this.running = false;
+        this.messageQueue.close();
+        const child = this.child;
+        this.child = null;
+        if (child) {
+            if (!child.killed) {
+                child.kill("SIGTERM");
+            }
+            await new Promise((resolve) => {
+                child.once("exit", () => resolve());
+            });
+        }
+        if (this.containerName) {
+            (0, node_child_process_1.spawnSync)("docker", ["rm", "-f", this.containerName], { stdio: "ignore" });
+            this.containerName = null;
+        }
+    }
+    async sendRaw(payload) {
+        if (!this.running || !this.child || !this.child.stdin) {
+            throw new Error(this.buildContainerStoppedErrorMessage());
+        }
+        this.child.stdin.write(payload);
+    }
+    async *receiveOutput() {
+        while (true) {
+            const item = await this.messageQueue.pop();
+            if (!item) {
+                return;
+            }
+            yield item;
+        }
+    }
+}
+exports.AppServerContainerService = AppServerContainerService;