@zq-silk/yui 0.0.0

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -0,0 +1,322 @@
+import { createRoleSessionSet, recordRoleAgentSession, updateRoleAgentSessionStatus } from "../executor/agentExecutor.js";
+import { createTaskEvent } from "../event/taskEvent.js";
+import { answerInputRequest } from "../input/inputRequest.js";
+import { activeRoleAgentBinding, updateRoleStatus } from "../role/role.js";
+import { SYSTEM_OPERATOR_ROLE } from "../role/systemRoles.js";
+import { failAgentRun, markAgentRunDelivered } from "../run/agentRun.js";
+import { pendingWakeupsMatch } from "../scheduler/pendingWakeup.js";
+import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
+import { updateWorkItemStatus } from "../workItem/workItem.js";
+/** Maps the authoritative FileTaskStore records to the scheduler's narrow port. */
+export class FileSchedulerStoreAdapter {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    listTasks() { return this.store.listTasks(); }
+    getTask(taskId) { return this.store.getTask(taskId); }
+    getTaskBrief(taskId) { return this.store.getTaskBrief(taskId); }
+    listDecisions(taskId) { return this.store.listDecisions(taskId); }
+    listMilestones(taskId) { return this.store.listMilestones(taskId); }
+    listRoles(taskId) {
+        return this.store.listRoles(taskId).map(mapRole);
+    }
+    getRole(taskId, roleName) {
+        const role = this.store.getRole(taskId, roleName);
+        return role === null ? null : mapRole(role);
+    }
+    getActiveAgentRun(taskId, roleName) {
+        return this.store.getActiveAgentRun(taskId, roleName);
+    }
+    hasOpenInputRequest(taskId) {
+        return this.store.listInputRequests(taskId).some((request) => request.status === "open");
+    }
+    listOpenInputRequests() {
+        return this.store.listAllInputRequests().filter((request) => request.status === "open");
+    }
+    getOperatorDeliveryTarget() {
+        const role = this.store.getGlobalRole(SYSTEM_OPERATOR_ROLE);
+        if (role === null)
+            return null;
+        return {
+            roleName: SYSTEM_OPERATOR_ROLE,
+            adapterId: activeRoleAgentBinding(role).adapterId
+        };
+    }
+    resolveExpiredInputRecommendations(now) {
+        return this.store.transaction((store) => {
+            const expired = store.listAllInputRequests().filter((request) => (request.status === "open"
+                && request.policy.kind === "recommended"
+                && Date.parse(request.policy.timeoutAt) <= now.getTime()));
+            const resolved = [];
+            for (const request of expired) {
+                const task = store.getTask(request.taskId);
+                if (task?.status !== "active" || request.policy.kind !== "recommended")
+                    continue;
+                const choiceKey = request.policy.recommendedChoiceKey;
+                const answered = answerInputRequest(request, { choiceKey }, "agent-timeout", now);
+                store.saveInputRequest(task.id, answered);
+                store.saveEvent(task.id, createTaskEvent(store.nextEventId(task.id), "input.auto-answered", { requestId: request.id, choiceKey }, now));
+                queueLeaderWakeup(store, task.id, `input-timeout:${request.id}`, now);
+                resolved.push({ inputRequestId: request.id, taskId: task.id, choiceKey });
+            }
+            return resolved;
+        });
+    }
+    getRoleSession(taskId, roleName) {
+        const session = this.store.getRoleSession(taskId, roleName);
+        return session === null ? null : mapSession(session);
+    }
+    nextAgentRunId(taskId) { return this.store.nextAgentRunId(taskId); }
+    getPendingWakeup(taskId) { return this.store.getPendingWakeup(taskId); }
+    listPendingWakeups() { return this.store.listPendingWakeups(); }
+    savePendingWakeup(wakeup) {
+        this.store.savePendingWakeup(wakeup);
+    }
+    clearPendingWakeup(taskId) { this.store.clearPendingWakeup(taskId); }
+    getLeaderFailure(taskId) { return this.store.getLeaderFailure(taskId); }
+    getOperatorNotification(taskId) { return this.store.getOperatorNotification(taskId); }
+    saveLeaderDispatch(input) {
+        return this.store.transaction((store) => {
+            const task = store.getTask(input.task.id);
+            if (task === null || task.status !== "active") {
+                return "unavailable";
+            }
+            const role = requireRole(store, input.task.id, input.role.name);
+            if (role.activeAgentId !== input.role.activeAgentId
+                || activeRoleAgentBinding(role).adapterId !== input.role.adapterId) {
+                return "state-changed";
+            }
+            if (store.getActiveAgentRun(input.task.id, input.role.name) !== null)
+                return "busy";
+            const pending = store.getPendingWakeup(input.task.id);
+            if (pending === null || !pendingWakeupsMatch(pending, input.wakeup)) {
+                return "state-changed";
+            }
+            store.saveActiveAgentRun(input.run);
+            store.saveRole(input.task.id, updateRoleStatus(role, "running", input.now));
+            if (input.session !== null && input.session.nativeSessionId !== undefined) {
+                saveTaskSession(store, role, {
+                    ...input.session,
+                    nativeSessionId: input.session.nativeSessionId
+                }, "running", input.now);
+            }
+            store.clearLeaderFailure(input.task.id);
+            store.clearOperatorNotification(input.task.id);
+            store.clearPendingWakeup(input.task.id);
+            return "claimed";
+        });
+    }
+    saveRoleRunDelivery(input) {
+        this.store.transaction((store) => {
+            const task = store.getTask(input.task.id);
+            if (task === null || task.status !== "active") {
+                throw new Error(`Task is not active: ${input.task.id}.`);
+            }
+            const role = requireRole(store, input.task.id, input.role.name);
+            const active = store.getActiveAgentRun(input.task.id, input.role.name);
+            if (active === null || active.id !== input.run.id) {
+                throw new Error(`Active Agent run changed before delivery was persisted: ${input.run.id}.`);
+            }
+            if (active.deliveredAt === undefined) {
+                store.saveAgentRun(markAgentRunDelivered(active, input.now));
+            }
+            if (role.status !== "running") {
+                store.saveRole(input.task.id, updateRoleStatus(role, "running", input.now));
+            }
+            if (input.session !== null && input.session.nativeSessionId !== undefined) {
+                const existing = store.getRoleSession(input.task.id, input.role.name);
+                if (existing?.agentId !== input.session.agentId
+                    || existing.adapterId !== input.session.adapterId
+                    || existing.nativeSessionId !== input.session.nativeSessionId
+                    || existing.status !== "running") {
+                    saveTaskSession(store, role, {
+                        ...input.session,
+                        nativeSessionId: input.session.nativeSessionId
+                    }, "running", input.now);
+                }
+            }
+        });
+    }
+    saveLeaderDispatchFailure(input) {
+        this.store.transaction((store) => {
+            const task = store.getTask(input.task.id);
+            if (task === null || task.status !== "active")
+                return;
+            const role = requireRole(store, input.task.id, input.role.name);
+            if (input.claimed !== undefined) {
+                const active = store.getActiveAgentRun(input.task.id, input.role.name);
+                if (active?.id === input.claimed.run.id) {
+                    store.saveAgentRun(failAgentRun(active, input.failure.message, input.now));
+                    store.clearActiveAgentRun(input.task.id, input.role.name);
+                }
+                store.savePendingWakeup(restorePendingWakeup(input.claimed.wakeup, store.getPendingWakeup(input.task.id)));
+            }
+            store.saveRole(input.task.id, updateRoleStatus(role, "failed", input.now));
+            breakTaskSessionIfPresent(store, input.task.id, role.name, role.activeAgentId, input.now);
+            store.saveLeaderFailure(input.failure);
+            store.saveOperatorNotification(input.notification);
+        });
+    }
+    saveExitedRoleRun(input) {
+        this.store.transaction((store) => {
+            const role = requireRole(store, input.task.id, input.role.name);
+            store.saveAgentRun(failAgentRun(input.run, input.summary, input.now));
+            store.clearActiveAgentRun(input.task.id, input.role.name);
+            if (input.run.workItemId !== undefined) {
+                const workItem = store.getWorkItem(input.task.id, input.run.workItemId);
+                if (workItem !== null && !["completed", "failed", "cancelled", "superseded"].includes(workItem.status)) {
+                    store.saveWorkItem(input.task.id, updateWorkItemStatus(workItem, "failed", input.summary, input.now));
+                }
+            }
+            store.saveRole(input.task.id, updateRoleStatus(role, "exited", input.now));
+            stopTaskSessionIfPresent(store, input.task.id, role.name, role.activeAgentId, input.now);
+        });
+    }
+    saveArchivedTaskStopped(taskId, now) {
+        this.store.transaction((store) => {
+            const task = store.getTask(taskId);
+            if (task === null || task.status !== "archived")
+                return;
+            for (const role of store.listRoles(taskId)) {
+                if (role.status !== "idle") {
+                    store.saveRole(taskId, updateRoleStatus(role, "idle", now));
+                }
+            }
+            for (const current of store.listRoleSessionSets(taskId)) {
+                if (Object.values(current.sessions).every((session) => session.status === "stopped")) {
+                    continue;
+                }
+                let updated = current;
+                for (const agentId of Object.keys(current.sessions)) {
+                    updated = updateRoleAgentSessionStatus(updated, agentId, "stopped", now);
+                }
+                store.saveRoleSessionSet(updated);
+            }
+        });
+    }
+    /** Called by the internal Codex notify hook, never by an LLM prompt. */
+    recordRuntimeNativeSession(input, now = new Date()) {
+        return this.store.transaction((store) => {
+            const task = store.getTask(input.taskId);
+            if (task === null)
+                throw new Error(`Task not found: ${input.taskId}.`);
+            if (task.status === "archived") {
+                throw new Error(`Cannot register a native session for archived Task: ${input.taskId}.`);
+            }
+            if (task.status !== "active") {
+                throw new Error(`Cannot register a native session for a Task that is not active: ${input.taskId}.`);
+            }
+            const role = requireRole(store, input.taskId, input.roleName);
+            const binding = activeRoleAgentBinding(role);
+            if (binding.agentId !== input.agentId || binding.adapterId !== input.adapterId) {
+                throw new Error("Native session registration does not match the active Role Agent binding.");
+            }
+            const current = store.getRoleSessionSet(input.taskId, input.roleName)
+                ?? createRoleSessionSet({ scope: "task", taskId: input.taskId, roleName: input.roleName }, role.activeAgentId, now);
+            const existing = current.sessions[input.agentId];
+            if (existing !== undefined && existing.nativeSessionId !== input.nativeSessionId) {
+                throw new Error("Native session registration conflicts with the fixed Role session.");
+            }
+            if (existing?.status === "running")
+                return existing;
+            const updated = recordRoleAgentSession(current, {
+                agentId: input.agentId,
+                adapterId: input.adapterId,
+                nativeSessionId: input.nativeSessionId,
+                policy: "fixed",
+                status: "running"
+            }, now);
+            store.saveRoleSessionSet(updated);
+            return updated.sessions[input.agentId];
+        });
+    }
+    recordGlobalRuntimeNativeSession(input, now = new Date()) {
+        return this.store.transaction((store) => {
+            const role = store.getGlobalRole(input.roleName);
+            if (role === null)
+                throw new Error(`Global Role not found: ${input.roleName}.`);
+            const binding = activeRoleAgentBinding(role);
+            if (binding.agentId !== input.agentId || binding.adapterId !== input.adapterId) {
+                throw new Error("Native session registration does not match the active global Role Agent binding.");
+            }
+            const current = store.getGlobalRoleSessionSet(input.roleName)
+                ?? createRoleSessionSet({ scope: "global", roleName: input.roleName }, role.activeAgentId, now);
+            const existing = current.sessions[input.agentId];
+            if (existing !== undefined && existing.nativeSessionId !== input.nativeSessionId) {
+                throw new Error("Native session registration conflicts with the fixed global Role session.");
+            }
+            if (existing?.status === "running")
+                return existing;
+            const updated = recordRoleAgentSession(current, {
+                agentId: input.agentId,
+                adapterId: input.adapterId,
+                nativeSessionId: input.nativeSessionId,
+                policy: "fixed",
+                status: "running"
+            }, now);
+            store.saveGlobalRoleSessionSet(updated);
+            return updated.sessions[input.agentId];
+        });
+    }
+}
+function restorePendingWakeup(claimed, current) {
+    if (current === null)
+        return claimed;
+    return {
+        schemaVersion: 1,
+        taskId: claimed.taskId,
+        reasons: [...new Set([...claimed.reasons, ...current.reasons])],
+        requestCount: claimed.requestCount + current.requestCount,
+        firstRequestedAt: claimed.firstRequestedAt,
+        lastRequestedAt: current.lastRequestedAt
+    };
+}
+function mapRole(role) {
+    const binding = activeRoleAgentBinding(role);
+    return {
+        taskId: role.taskId,
+        name: role.name,
+        activeAgentId: role.activeAgentId,
+        adapterId: binding.adapterId,
+        status: role.status
+    };
+}
+function mapSession(session) {
+    return {
+        agentId: session.agentId,
+        adapterId: session.adapterId,
+        nativeSessionId: session.nativeSessionId,
+        status: session.status
+    };
+}
+function saveTaskSession(store, role, session, status, now) {
+    const current = store.getRoleSessionSet(role.taskId, role.name)
+        ?? createRoleSessionSet({ scope: "task", taskId: role.taskId, roleName: role.name }, role.activeAgentId, now);
+    const updated = recordRoleAgentSession(current, {
+        agentId: session.agentId,
+        adapterId: session.adapterId,
+        nativeSessionId: session.nativeSessionId,
+        policy: "fixed",
+        status
+    }, now);
+    store.saveRoleSessionSet(updated);
+}
+function breakTaskSessionIfPresent(store, taskId, roleName, agentId, now) {
+    updateTaskSessionStatusIfPresent(store, taskId, roleName, agentId, "broken", now);
+}
+function stopTaskSessionIfPresent(store, taskId, roleName, agentId, now) {
+    updateTaskSessionStatusIfPresent(store, taskId, roleName, agentId, "stopped", now);
+}
+function updateTaskSessionStatusIfPresent(store, taskId, roleName, agentId, status, now) {
+    const set = store.getRoleSessionSet(taskId, roleName);
+    if (set === null || set.sessions[agentId] === undefined)
+        return;
+    store.saveRoleSessionSet(updateRoleAgentSessionStatus(set, agentId, status, now));
+}
+function requireRole(store, taskId, roleName) {
+    const role = store.getRole(taskId, roleName);
+    if (role === null)
+        throw new Error(`Role not found: ${taskId}/${roleName}.`);
+    return role;
+}

package/dist/controller/runtime.js

@@ -0,0 +1,31 @@
+import { reconciliationIntervalMilliseconds } from "../config/yuiConfig.js";
+import { ExecutorRegistry } from "../executor/executorRegistry.js";
+import { FileRoleLaunchPlanner } from "../executor/fileRoleLaunchPlanner.js";
+import { FileTaskStore } from "../storage/taskStore.js";
+import { FileTaskWorkspacePreparer } from "../repository/taskWorkspacePreparer.js";
+import { NodeCommandExecutor } from "../tmux/commandExecutor.js";
+import { TmuxManager } from "../tmux/tmuxManager.js";
+import { startFileTaskController } from "./controller.js";
+import { FileSchedulerStoreAdapter } from "./fileSchedulerStoreAdapter.js";
+import { createSessionNotifyDispatcher } from "./sessionNotify.js";
+/** Production composition root for the lean FileTaskStore + tmux Controller. */
+export async function startFileTaskControllerRuntime(home, options = {}) {
+    const store = options.store ?? new FileTaskStore(home);
+    const schedulerStore = options.schedulerStore ?? new FileSchedulerStoreAdapter(store);
+    const planner = options.planner ?? new FileRoleLaunchPlanner(home, store, {
+        environment: options.environment
+    });
+    const tmux = options.tmux ?? new TmuxManager(options.environment?.YUI_TMUX_BIN ?? process.env.YUI_TMUX_BIN ?? "tmux", new NodeCommandExecutor(), { yuiHome: home });
+    const delivery = options.delivery ?? new ExecutorRegistry(planner, tmux);
+    const workspacePreparer = options.workspacePreparer
+        ?? new FileTaskWorkspacePreparer(home, store);
+    const dispatcher = createSessionNotifyDispatcher(schedulerStore, options.dispatcher);
+    const running = await startFileTaskController(home, schedulerStore, delivery, dispatcher, {
+        intervalMs: options.intervalMs
+            ?? reconciliationIntervalMilliseconds(store.getConfig().reconciliationIntervalSeconds),
+        now: options.now,
+        onError: options.onError,
+        workspacePreparer
+    });
+    return { ...running, store, schedulerStore, planner, tmux, delivery, workspacePreparer };
+}

package/dist/controller/sessionNotify.js

@@ -0,0 +1,136 @@
+import { callFileTaskController } from "./clientRuntime.js";
+const SESSION_BIND_METHOD = "runtime.session.bind";
+/** Hidden CLI entrypoint used by Codex's structured legacy notify hook. */
+export async function runSessionNotifyCommand(payloadArgument, environment = process.env, call = callFileTaskController) {
+    const params = parseCodexSessionNotification(payloadArgument, environment);
+    await call(requireText(environment.YUI_HOME, "YUI_HOME"), SESSION_BIND_METHOD, toJson(params));
+}
+export function parseCodexSessionNotification(payloadArgument, environment) {
+    const payload = parseObject(payloadArgument, "Codex notify payload");
+    if (payload.type !== "agent-turn-complete") {
+        throw new Error("Codex notify payload type is invalid.");
+    }
+    const nativeSessionId = requireText(payload["thread-id"], "Codex thread-id");
+    const scope = environment.YUI_SESSION_SCOPE;
+    if (scope !== "task" && scope !== "global") {
+        throw new Error("YUI_SESSION_SCOPE must be task or global.");
+    }
+    const common = {
+        scope,
+        roleName: requireText(environment.YUI_ROLE, "YUI_ROLE"),
+        agentId: requireText(environment.YUI_AGENT_ID, "YUI_AGENT_ID"),
+        adapterId: requireCodexAdapter(environment.YUI_ADAPTER_ID),
+        nativeSessionId
+    };
+    return scope === "task"
+        ? {
+            ...common,
+            taskId: requireText(environment.YUI_TASK_ID, "YUI_TASK_ID")
+        }
+        : common;
+}
+/** Controller-side handler; session identity never travels through an Agent prompt. */
+export function createSessionNotifyDispatcher(store, fallback) {
+    return async (method, params) => {
+        if (method !== SESSION_BIND_METHOD) {
+            if (fallback !== undefined)
+                return fallback(method, params);
+            throw applicationError("METHOD_NOT_FOUND", "Controller method was not found.");
+        }
+        const input = parseSessionBindParams(params);
+        const recorded = input.scope === "task"
+            ? store.recordRuntimeNativeSession({
+                taskId: input.taskId,
+                roleName: input.roleName,
+                agentId: input.agentId,
+                adapterId: input.adapterId,
+                nativeSessionId: input.nativeSessionId
+            })
+            : store.recordGlobalRuntimeNativeSession({
+                roleName: input.roleName,
+                agentId: input.agentId,
+                adapterId: input.adapterId,
+                nativeSessionId: input.nativeSessionId
+            });
+        return {
+            recorded: true,
+            scope: input.scope,
+            roleName: input.roleName,
+            nativeSessionId: recorded.nativeSessionId
+        };
+    };
+}
+function parseSessionBindParams(value) {
+    if (!isObject(value))
+        throw invalidParams();
+    const input = value;
+    const scope = input.scope;
+    const expected = scope === "task"
+        ? ["scope", "taskId", "roleName", "agentId", "adapterId", "nativeSessionId"]
+        : ["scope", "roleName", "agentId", "adapterId", "nativeSessionId"];
+    if ((scope !== "task" && scope !== "global") || !hasExactKeys(input, expected)) {
+        throw invalidParams();
+    }
+    try {
+        const common = {
+            scope,
+            roleName: requireText(input.roleName, "Role name"),
+            agentId: requireText(input.agentId, "Agent id"),
+            adapterId: requireCodexAdapter(input.adapterId),
+            nativeSessionId: requireText(input.nativeSessionId, "Native session id")
+        };
+        return scope === "task"
+            ? { ...common, taskId: requireText(input.taskId, "Task id") }
+            : common;
+    }
+    catch {
+        throw invalidParams();
+    }
+}
+function parseObject(value, label) {
+    if (value === undefined || Buffer.byteLength(value) > 1_048_576) {
+        throw new Error(`${label} is invalid.`);
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (!isObject(parsed))
+            throw new Error("shape");
+        return parsed;
+    }
+    catch {
+        throw new Error(`${label} is invalid.`);
+    }
+}
+function requireCodexAdapter(value) {
+    if (value !== "codex")
+        throw new Error("Runtime session notify requires the Codex adapter.");
+    return value;
+}
+function requireText(value, label) {
+    if (typeof value !== "string" || value.includes("\0")) {
+        throw new Error(`${label} is required.`);
+    }
+    const text = value.trim();
+    if (text.length === 0 || text.length > 1_024)
+        throw new Error(`${label} is invalid.`);
+    return text;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, expected) {
+    const actual = Object.keys(value).sort();
+    return actual.length === expected.length
+        && actual.every((key, index) => key === [...expected].sort()[index]);
+}
+function invalidParams() {
+    return applicationError("INVALID_PARAMS", "Runtime session params are invalid.");
+}
+function applicationError(code, message) {
+    const error = Object.assign(new Error(message), { code });
+    error.name = "CoreApplicationError";
+    return error;
+}
+function toJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}

package/dist/core/controllerClient.js

@@ -0,0 +1,127 @@
+import { randomUUID } from "node:crypto";
+import { lstat, readFile } from "node:fs/promises";
+import { createConnection } from "node:net";
+import { join } from "node:path";
+import { CONTROLLER_DISCOVERY_PATH, CONTROLLER_SOCKET_PATH, MAX_CONTROLLER_MESSAGE_BYTES, ControllerProtocolError, encodeControllerRequest, parseControllerDiscovery, parseControllerResponse } from "./protocol.js";
+export class ControllerClientError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ControllerClientError";
+    }
+}
+export async function readControllerDiscovery(home) {
+    const discoveryPath = join(home, CONTROLLER_DISCOVERY_PATH);
+    const expectedSocketPath = join(home, CONTROLLER_SOCKET_PATH);
+    try {
+        const metadata = await lstat(discoveryPath);
+        if (!metadata.isFile()
+            || (metadata.mode & 0o077) !== 0
+            || metadata.size > 4_096) {
+            throw invalidDiscovery();
+        }
+        const value = JSON.parse(await readFile(discoveryPath, "utf8"));
+        return parseControllerDiscovery(value, expectedSocketPath);
+    }
+    catch (error) {
+        if (error instanceof ControllerClientError)
+            throw error;
+        if (isNodeError(error) && error.code === "ENOENT") {
+            throw new ControllerClientError("CONTROLLER_UNAVAILABLE", "Controller is not running.");
+        }
+        throw invalidDiscovery();
+    }
+}
+export async function callController(home, method, params = {}, options = {}) {
+    const discovery = await readControllerDiscovery(home);
+    const timeoutMs = options.timeoutMs ?? 5_000;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1) {
+        throw new TypeError("Controller timeout must be a positive integer.");
+    }
+    const id = options.id ?? randomUUID();
+    let requestLine;
+    try {
+        requestLine = encodeControllerRequest({
+            id,
+            token: discovery.token,
+            method,
+            params
+        });
+    }
+    catch (error) {
+        if (error instanceof ControllerProtocolError) {
+            throw new ControllerClientError(error.code, error.message);
+        }
+        throw new ControllerClientError("INVALID_REQUEST", "Invalid controller request.");
+    }
+    return exchange(discovery.socketPath, requestLine, id, timeoutMs);
+}
+function exchange(socketPath, requestLine, expectedId, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const socket = createConnection(socketPath);
+        let buffer = Buffer.alloc(0);
+        let settled = false;
+        const timer = setTimeout(() => {
+            fail(new ControllerClientError("CONTROLLER_TIMEOUT", "Controller request timed out."));
+        }, timeoutMs);
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            resolve(result);
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            reject(error);
+        };
+        socket.on("connect", () => socket.write(requestLine));
+        socket.on("data", (chunk) => {
+            if (settled)
+                return;
+            buffer = Buffer.concat([buffer, chunk]);
+            const newline = buffer.indexOf(0x0a);
+            if (newline < 0) {
+                if (buffer.length > MAX_CONTROLLER_MESSAGE_BYTES)
+                    fail(invalidResponse());
+                return;
+            }
+            if (newline > MAX_CONTROLLER_MESSAGE_BYTES || buffer.length !== newline + 1) {
+                fail(invalidResponse());
+                return;
+            }
+            try {
+                const response = parseControllerResponse(buffer.subarray(0, newline).toString("utf8"), expectedId);
+                if (response.ok)
+                    finish(response.result);
+                else
+                    fail(new ControllerClientError(response.error.code, response.error.message));
+            }
+            catch {
+                fail(invalidResponse());
+            }
+        });
+        socket.on("end", () => {
+            if (!settled)
+                fail(invalidResponse());
+        });
+        socket.on("error", () => {
+            fail(new ControllerClientError("CONTROLLER_UNAVAILABLE", "Controller is unavailable."));
+        });
+    });
+}
+function invalidDiscovery() {
+    return new ControllerClientError("CONTROLLER_DISCOVERY_INVALID", "Controller discovery is invalid.");
+}
+function invalidResponse() {
+    return new ControllerClientError("INVALID_RESPONSE", "Controller response is invalid.");
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}