@agents-tower/core 0.1.0

package/dist/adapters/openclaw.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openClawAdapter = void 0;
+const openclaw_1 = require("../openclaw");
+const helpers_1 = require("./helpers");
+const static_source_1 = require("./static-source");
+exports.openClawAdapter = {
+    id: "openclaw",
+    source: "openclaw",
+    capabilities: {
+        discoverProjects: true
+    },
+    discoverProjects(limit) {
+        return (0, openclaw_1.discoverOpenClawProjects)(limit);
+    },
+    createSource(context) {
+        return new static_source_1.StaticProjectSource(async () => {
+            const generatedAt = new Date().toISOString();
+            try {
+                const agents = await (0, openclaw_1.loadOpenClawAgents)(context.projectRoot);
+                return (0, helpers_1.emptyAdapterSnapshot)({
+                    adapterId: "openclaw",
+                    source: "openclaw",
+                    agents,
+                    generatedAt
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return (0, helpers_1.emptyAdapterSnapshot)({
+                    adapterId: "openclaw",
+                    source: "openclaw",
+                    generatedAt,
+                    notes: [`OpenClaw gateway agents unavailable: ${message}`],
+                    health: (0, helpers_1.degradedHealth)(message, generatedAt)
+                });
+            }
+        }, (0, helpers_1.emptyAdapterSnapshot)({ adapterId: "openclaw", source: "openclaw" }));
+    }
+};
+//# sourceMappingURL=openclaw.js.map

package/dist/adapters/openclaw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openclaw.js","sourceRoot":"","sources":["../../src/adapters/openclaw.ts"],"names":[],"mappings":";;;AAAA,0CAA2E;AAE3E,uCAAiE;AACjE,mDAAsD;AAEzC,QAAA,eAAe,GAAmB;IAC7C,EAAE,EAAE,UAAU;IACd,MAAM,EAAE,UAAU;IAClB,YAAY,EAAE;QACZ,gBAAgB,EAAE,IAAI;KACvB;IACD,gBAAgB,CAAC,KAAK;QACpB,OAAO,IAAA,mCAAwB,EAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IACD,YAAY,CAAC,OAAO;QAClB,OAAO,IAAI,mCAAmB,CAAC,KAAK,IAAI,EAAE;YACxC,MAAM,WAAW,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;YAC7C,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,MAAM,IAAA,6BAAkB,EAAC,OAAO,CAAC,WAAW,CAAC,CAAC;gBAC7D,OAAO,IAAA,8BAAoB,EAAC;oBAC1B,SAAS,EAAE,UAAU;oBACrB,MAAM,EAAE,UAAU;oBAClB,MAAM;oBACN,WAAW;iBACZ,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBACvE,OAAO,IAAA,8BAAoB,EAAC;oBAC1B,SAAS,EAAE,UAAU;oBACrB,MAAM,EAAE,UAAU;oBAClB,WAAW;oBACX,KAAK,EAAE,CAAC,wCAAwC,OAAO,EAAE,CAAC;oBAC1D,MAAM,EAAE,IAAA,wBAAc,EAAC,OAAO,EAAE,WAAW,CAAC;iBAC7C,CAAC,CAAC;YACL,CAAC;QACH,CAAC,EAAE,IAAA,8BAAoB,EAAC,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC;IAC1E,CAAC;CACF,CAAC"}

package/dist/adapters/presence.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectAdapter } from "./types";
+export declare const presenceAdapter: ProjectAdapter;

package/dist/adapters/presence.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.presenceAdapter = void 0;
+const presence_1 = require("../presence");
+const helpers_1 = require("./helpers");
+const static_source_1 = require("./static-source");
+exports.presenceAdapter = {
+    id: "presence",
+    source: "presence",
+    capabilities: {},
+    createSource(context) {
+        return new static_source_1.StaticProjectSource(async () => {
+            const generatedAt = new Date().toISOString();
+            try {
+                const agents = await (0, presence_1.loadFreshPresenceAgents)(context.projectRoot);
+                return (0, helpers_1.emptyAdapterSnapshot)({
+                    adapterId: "presence",
+                    source: "presence",
+                    agents,
+                    generatedAt
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return (0, helpers_1.emptyAdapterSnapshot)({
+                    adapterId: "presence",
+                    source: "presence",
+                    generatedAt,
+                    notes: [`Presence unavailable: ${message}`],
+                    health: (0, helpers_1.degradedHealth)(message, generatedAt)
+                });
+            }
+        }, (0, helpers_1.emptyAdapterSnapshot)({ adapterId: "presence", source: "presence" }));
+    }
+};
+//# sourceMappingURL=presence.js.map

package/dist/adapters/presence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"presence.js","sourceRoot":"","sources":["../../src/adapters/presence.ts"],"names":[],"mappings":";;;AAAA,0CAAsD;AAEtD,uCAAiE;AACjE,mDAAsD;AAEzC,QAAA,eAAe,GAAmB;IAC7C,EAAE,EAAE,UAAU;IACd,MAAM,EAAE,UAAU;IAClB,YAAY,EAAE,EAAE;IAChB,YAAY,CAAC,OAAO;QAClB,OAAO,IAAI,mCAAmB,CAAC,KAAK,IAAI,EAAE;YACxC,MAAM,WAAW,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;YAC7C,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,MAAM,IAAA,kCAAuB,EAAC,OAAO,CAAC,WAAW,CAAC,CAAC;gBAClE,OAAO,IAAA,8BAAoB,EAAC;oBAC1B,SAAS,EAAE,UAAU;oBACrB,MAAM,EAAE,UAAU;oBAClB,MAAM;oBACN,WAAW;iBACZ,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBACvE,OAAO,IAAA,8BAAoB,EAAC;oBAC1B,SAAS,EAAE,UAAU;oBACrB,MAAM,EAAE,UAAU;oBAClB,WAAW;oBACX,KAAK,EAAE,CAAC,yBAAyB,OAAO,EAAE,CAAC;oBAC3C,MAAM,EAAE,IAAA,wBAAc,EAAC,OAAO,EAAE,WAAW,CAAC;iBAC7C,CAAC,CAAC;YACL,CAAC;QACH,CAAC,EAAE,IAAA,8BAAoB,EAAC,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC;IAC1E,CAAC;CACF,CAAC"}

package/dist/adapters/static-source.d.ts

@@ -0,0 +1,15 @@
+import type { AdapterSnapshot, ProjectSource, AdapterRefreshReason } from "./types";
+type SnapshotLoader = () => Promise<AdapterSnapshot>;
+export declare class StaticProjectSource implements ProjectSource {
+    private readonly loadSnapshot;
+    private cachedSnapshot;
+    private readonly listeners;
+    private refreshGeneration;
+    constructor(loadSnapshot: SnapshotLoader, initialSnapshot: AdapterSnapshot);
+    warm(): Promise<void>;
+    refresh(_reason: AdapterRefreshReason): Promise<void>;
+    getCachedSnapshot(): AdapterSnapshot;
+    subscribe(listener: () => void): () => void;
+    dispose(): Promise<void>;
+}
+export {};

package/dist/adapters/static-source.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticProjectSource = void 0;
+class StaticProjectSource {
+    loadSnapshot;
+    cachedSnapshot;
+    listeners = new Set();
+    refreshGeneration = 0;
+    constructor(loadSnapshot, initialSnapshot) {
+        this.loadSnapshot = loadSnapshot;
+        this.cachedSnapshot = initialSnapshot;
+    }
+    async warm() {
+        await this.refresh("warm");
+    }
+    async refresh(_reason) {
+        const generation = ++this.refreshGeneration;
+        const snapshot = await this.loadSnapshot();
+        if (generation !== this.refreshGeneration) {
+            return;
+        }
+        this.cachedSnapshot = snapshot;
+        for (const listener of this.listeners) {
+            listener();
+        }
+    }
+    getCachedSnapshot() {
+        return this.cachedSnapshot;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    async dispose() {
+        this.listeners.clear();
+    }
+}
+exports.StaticProjectSource = StaticProjectSource;
+//# sourceMappingURL=static-source.js.map

package/dist/adapters/static-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-source.js","sourceRoot":"","sources":["../../src/adapters/static-source.ts"],"names":[],"mappings":";;;AAIA,MAAa,mBAAmB;IAMX;IALX,cAAc,CAAkB;IACvB,SAAS,GAAG,IAAI,GAAG,EAAc,CAAC;IAC3C,iBAAiB,GAAG,CAAC,CAAC;IAE9B,YACmB,YAA4B,EAC7C,eAAgC;QADf,iBAAY,GAAZ,YAAY,CAAgB;QAG7C,IAAI,CAAC,cAAc,GAAG,eAAe,CAAC;IACxC,CAAC;IAED,KAAK,CAAC,IAAI;QACR,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7B,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,OAA6B;QACzC,MAAM,UAAU,GAAG,EAAE,IAAI,CAAC,iBAAiB,CAAC;QAC5C,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;QAC3C,IAAI,UAAU,KAAK,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC1C,OAAO;QACT,CAAC;QACD,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC;QAC/B,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACtC,QAAQ,EAAE,CAAC;QACb,CAAC;IACH,CAAC;IAED,iBAAiB;QACf,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAED,SAAS,CAAC,QAAoB;QAC5B,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC7B,OAAO,GAAG,EAAE;YACV,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAClC,CAAC,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,OAAO;QACX,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;IACzB,CAAC;CACF;AA1CD,kDA0CC"}

package/dist/adapters/types.d.ts

@@ -0,0 +1,44 @@
+import type { CloudTask, DashboardAgent, DashboardEvent } from "../types";
+import type { DiscoveredProject } from "../project-paths";
+export type AdapterHealthStatus = "ready" | "degraded" | "error";
+export type AdapterRefreshReason = "warm" | "startup" | "interval" | "manual" | "event";
+export interface AdapterCapabilities {
+    discoverProjects?: boolean;
+    liveUpdates?: boolean;
+    typedNeedsUser?: boolean;
+    cloudTasks?: boolean;
+}
+export interface AdapterHealth {
+    status: AdapterHealthStatus;
+    detail: string | null;
+    lastUpdatedAt: string | null;
+}
+export interface AdapterSnapshot {
+    adapterId: string;
+    source: DashboardAgent["source"];
+    generatedAt: string;
+    agents: DashboardAgent[];
+    events: DashboardEvent[];
+    notes: string[];
+    cloudTasks?: CloudTask[];
+    health: AdapterHealth;
+}
+export interface ProjectAdapterContext {
+    projectRoot: string;
+    localLimit?: number;
+    readThreads?: boolean;
+}
+export interface ProjectSource {
+    warm(): Promise<void>;
+    refresh(reason: AdapterRefreshReason): Promise<void>;
+    getCachedSnapshot(): AdapterSnapshot;
+    subscribe?(listener: () => void): () => void;
+    dispose(): Promise<void>;
+}
+export interface ProjectAdapter {
+    id: string;
+    source: DashboardAgent["source"];
+    capabilities: AdapterCapabilities;
+    discoverProjects?(limit?: number): Promise<DiscoveredProject[]>;
+    createSource(context: ProjectAdapterContext): ProjectSource;
+}

package/dist/adapters/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/adapters/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/adapters/types.ts"],"names":[],"mappings":""}

package/dist/app-server.d.ts

@@ -0,0 +1,94 @@
+import type { CodexThread } from "./types";
+type ThreadListSortKey = "created_at" | "updated_at";
+type SortDirection = "asc" | "desc";
+export interface AppServerThreadGoal {
+    threadId: string;
+    objective: string;
+    status: string;
+    tokenBudget: number | null;
+    tokensUsed: number;
+    timeUsedSeconds: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export declare function appServerCwdParam(cwd: string | null | undefined): string | null;
+export interface ToolRequestUserInputAnswer {
+    answers: string[];
+}
+export interface ToolRequestUserInputResponse {
+    answers: Record<string, ToolRequestUserInputAnswer>;
+}
+export interface AppServerNotification {
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface AppServerServerRequest {
+    id: number;
+    method: string;
+    params?: Record<string, unknown>;
+}
+interface AppServerResponseMessage {
+    id: number;
+    result?: unknown;
+    error?: {
+        message?: string;
+    };
+}
+type ParsedAppServerMessage = {
+    kind: "response";
+    message: AppServerResponseMessage;
+} | {
+    kind: "notification";
+    message: AppServerNotification;
+} | {
+    kind: "serverRequest";
+    message: AppServerServerRequest;
+} | {
+    kind: "unknown";
+};
+export declare function parseAppServerMessage(line: string): ParsedAppServerMessage;
+export declare class CodexAppServerClient {
+    private child;
+    private buffer;
+    private nextId;
+    private pending;
+    private stderr;
+    private notificationListeners;
+    private serverRequestListeners;
+    private constructor();
+    static create(): Promise<CodexAppServerClient>;
+    static createWithCandidateLabel(): Promise<{
+        client: CodexAppServerClient;
+        candidateLabel: string;
+    }>;
+    private onStdout;
+    private send;
+    notify(method: string, params?: Record<string, unknown>): void;
+    onNotification(listener: (message: AppServerNotification) => void): () => void;
+    onServerRequest(listener: (message: AppServerServerRequest) => void): () => void;
+    request<TResult>(method: string, params?: Record<string, unknown>): Promise<TResult>;
+    requestNoWait(method: string, params?: Record<string, unknown>): number;
+    respondToServerRequest(requestId: number, result: unknown): void;
+    respondToToolRequestUserInput(requestId: number, response: ToolRequestUserInputResponse): void;
+    respondToApprovalRequest(requestId: number, decision: string): void;
+    respondToDynamicToolCallUnsupported(requestId: number, tool: string | null | undefined): void;
+    listThreads(params: {
+        cwd?: string;
+        limit?: number;
+        sourceKinds?: string[];
+        sortKey?: ThreadListSortKey;
+        sortDirection?: SortDirection;
+    }): Promise<CodexThread[]>;
+    readThread(threadId: string): Promise<CodexThread>;
+    getThreadGoal(threadId: string): Promise<AppServerThreadGoal | null>;
+    resumeThread(threadId: string): Promise<CodexThread>;
+    startTurn(threadId: string, text: string, cwd?: string): Promise<string>;
+    startTurnNoWait(threadId: string, text: string, cwd?: string): number;
+    steerTurn(threadId: string, expectedTurnId: string, text: string): Promise<string>;
+    steerTurnNoWait(threadId: string, expectedTurnId: string, text: string): number;
+    unsubscribeThread(threadId: string): Promise<"unsubscribed" | "notSubscribed" | "notLoaded">;
+    listLoadedThreads(): Promise<string[]>;
+    close(): void;
+}
+export declare function withAppServerClient<T>(fn: (client: CodexAppServerClient) => Promise<T>): Promise<T>;
+export {};

package/dist/app-server.js

@@ -0,0 +1,382 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexAppServerClient = void 0;
+exports.appServerCwdParam = appServerCwdParam;
+exports.parseAppServerMessage = parseAppServerMessage;
+exports.withAppServerClient = withAppServerClient;
+const node_process_1 = require("node:process");
+const codex_command_1 = require("./codex-command");
+function appServerCwdParam(cwd) {
+    if (!cwd) {
+        return null;
+    }
+    const match = cwd.match(/^\/mnt\/([a-zA-Z])\/(.*)$/);
+    if (node_process_1.platform !== "win32" || !match) {
+        return cwd;
+    }
+    const drive = match[1].toUpperCase();
+    const rest = match[2].replace(/\//g, "\\");
+    return `${drive}:\\${rest}`;
+}
+const MAX_APP_SERVER_LINE_BYTES = 8 * 1024 * 1024;
+const APP_SERVER_INITIALIZE_TIMEOUT_MS = 15000;
+async function withTimeout(promise, timeoutMs, label) {
+    return await Promise.race([
+        promise,
+        new Promise((_, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            timer.unref?.();
+            promise.finally(() => clearTimeout(timer)).catch(() => clearTimeout(timer));
+        })
+    ]);
+}
+function messageIdFromOversizedLine(line) {
+    const prefix = line.slice(0, 256);
+    const match = prefix.match(/"id"\s*:\s*(\d+)/);
+    return match ? Number(match[1]) : null;
+}
+function parseAppServerMessage(line) {
+    let message;
+    try {
+        message = JSON.parse(line);
+    }
+    catch {
+        return { kind: "unknown" };
+    }
+    if (typeof message.id === "number" && typeof message.method === "string") {
+        return {
+            kind: "serverRequest",
+            message: {
+                id: message.id,
+                method: message.method,
+                params: message.params
+            }
+        };
+    }
+    if (typeof message.method === "string") {
+        return {
+            kind: "notification",
+            message: {
+                method: message.method,
+                params: message.params
+            }
+        };
+    }
+    if (typeof message.id === "number") {
+        return {
+            kind: "response",
+            message: {
+                id: message.id,
+                result: message.result,
+                error: message.error
+            }
+        };
+    }
+    return { kind: "unknown" };
+}
+class CodexAppServerClient {
+    child;
+    buffer = "";
+    nextId = 1;
+    pending = new Map();
+    stderr = "";
+    notificationListeners = new Set();
+    serverRequestListeners = new Set();
+    constructor(child) {
+        this.child = child;
+        this.child.stdout.setEncoding("utf8");
+        this.child.stderr.setEncoding("utf8");
+        this.child.stdout.on("data", (chunk) => this.onStdout(chunk));
+        this.child.stderr.on("data", (chunk) => {
+            this.stderr += chunk;
+        });
+        this.child.on("error", (error) => {
+            for (const pending of this.pending.values()) {
+                pending.reject(error instanceof Error ? error : new Error(String(error)));
+            }
+            this.pending.clear();
+        });
+        this.child.on("exit", (code, signal) => {
+            const reason = code === 0 || signal === "SIGTERM"
+                ? null
+                : new Error(`codex app-server exited unexpectedly (${code ?? signal ?? "unknown"}).`);
+            if (!reason) {
+                return;
+            }
+            for (const pending of this.pending.values()) {
+                pending.reject(reason);
+            }
+            this.pending.clear();
+        });
+    }
+    static async create() {
+        const { child } = await (0, codex_command_1.spawnCodexProcess)(["app-server"]);
+        const client = new CodexAppServerClient(child);
+        try {
+            await withTimeout(client.request("initialize", {
+                clientInfo: {
+                    name: "codex_agents_office",
+                    title: "Codex Agents Office",
+                    version: "0.1.0"
+                },
+                capabilities: {
+                    experimentalApi: true,
+                    requestAttestation: false
+                }
+            }), APP_SERVER_INITIALIZE_TIMEOUT_MS, "app-server initialize");
+        }
+        catch (error) {
+            client.close();
+            throw error;
+        }
+        client.notify("initialized");
+        return client;
+    }
+    static async createWithCandidateLabel() {
+        const { child, candidate } = await (0, codex_command_1.spawnCodexProcess)(["app-server"]);
+        const client = new CodexAppServerClient(child);
+        try {
+            await withTimeout(client.request("initialize", {
+                clientInfo: {
+                    name: "codex_agents_office",
+                    title: "Codex Agents Office",
+                    version: "0.1.0"
+                },
+                capabilities: {
+                    experimentalApi: true,
+                    requestAttestation: false
+                }
+            }), APP_SERVER_INITIALIZE_TIMEOUT_MS, "app-server initialize");
+        }
+        catch (error) {
+            client.close();
+            throw error;
+        }
+        client.notify("initialized");
+        return { client, candidateLabel: candidate.label };
+    }
+    onStdout(chunk) {
+        this.buffer += chunk;
+        while (true) {
+            const newlineIndex = this.buffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                return;
+            }
+            const line = this.buffer.slice(0, newlineIndex).trim();
+            this.buffer = this.buffer.slice(newlineIndex + 1);
+            if (!line) {
+                continue;
+            }
+            if (line.length > MAX_APP_SERVER_LINE_BYTES) {
+                const requestId = messageIdFromOversizedLine(line);
+                if (requestId !== null) {
+                    const pending = this.pending.get(requestId);
+                    if (pending) {
+                        this.pending.delete(requestId);
+                        pending.reject(new Error(`app-server message exceeded ${MAX_APP_SERVER_LINE_BYTES} bytes`));
+                    }
+                }
+                continue;
+            }
+            const parsed = parseAppServerMessage(line);
+            if (parsed.kind === "notification") {
+                for (const listener of this.notificationListeners) {
+                    listener(parsed.message);
+                }
+                continue;
+            }
+            if (parsed.kind === "serverRequest") {
+                for (const listener of this.serverRequestListeners) {
+                    listener(parsed.message);
+                }
+                continue;
+            }
+            if (parsed.kind !== "response") {
+                continue;
+            }
+            const pending = this.pending.get(parsed.message.id);
+            if (!pending) {
+                continue;
+            }
+            this.pending.delete(parsed.message.id);
+            if (parsed.message.error) {
+                pending.reject(new Error(parsed.message.error.message ?? "app-server request failed"));
+            }
+            else {
+                pending.resolve(parsed.message.result);
+            }
+        }
+    }
+    send(payload) {
+        this.child.stdin.write(`${JSON.stringify(payload)}\n`);
+    }
+    notify(method, params) {
+        this.send(params ? { method, params } : { method });
+    }
+    onNotification(listener) {
+        this.notificationListeners.add(listener);
+        return () => {
+            this.notificationListeners.delete(listener);
+        };
+    }
+    onServerRequest(listener) {
+        this.serverRequestListeners.add(listener);
+        return () => {
+            this.serverRequestListeners.delete(listener);
+        };
+    }
+    request(method, params) {
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve: (value) => resolve(value), reject });
+            this.send(params ? { id, method, params } : { id, method });
+        });
+    }
+    requestNoWait(method, params) {
+        const id = this.nextId++;
+        this.send(params ? { id, method, params } : { id, method });
+        return id;
+    }
+    respondToServerRequest(requestId, result) {
+        this.send({ id: requestId, result });
+    }
+    respondToToolRequestUserInput(requestId, response) {
+        this.respondToServerRequest(requestId, response);
+    }
+    respondToApprovalRequest(requestId, decision) {
+        this.respondToServerRequest(requestId, { decision });
+    }
+    respondToDynamicToolCallUnsupported(requestId, tool) {
+        const toolLabel = tool && tool.trim().length > 0 ? tool.trim() : "dynamic tool";
+        const response = {
+            success: false,
+            contentItems: [
+                {
+                    type: "inputText",
+                    text: `Agents Office observes Codex workload but does not execute ${toolLabel} dynamic tool requests.`
+                }
+            ]
+        };
+        this.respondToServerRequest(requestId, response);
+    }
+    async listThreads(params) {
+        const requestedLimit = Math.max(0, params.limit ?? 12);
+        const sourceKinds = params.sourceKinds ?? [
+            "cli",
+            "vscode",
+            "exec",
+            "appServer",
+            "subAgent",
+            "subAgentReview",
+            "subAgentCompact",
+            "subAgentThreadSpawn",
+            "subAgentOther",
+            "unknown"
+        ];
+        const threads = [];
+        const seenCursors = new Set();
+        let cursor = null;
+        while (threads.length < requestedLimit) {
+            const result = await this.request("thread/list", {
+                cwd: appServerCwdParam(params.cwd),
+                cursor,
+                limit: Math.min(100, requestedLimit - threads.length),
+                sortKey: params.sortKey ?? "updated_at",
+                sortDirection: params.sortDirection ?? "desc",
+                sourceKinds,
+                archived: false
+            });
+            const page = result.data ?? [];
+            threads.push(...page);
+            const nextCursor = result.nextCursor ?? null;
+            if (page.length === 0 || !nextCursor || seenCursors.has(nextCursor)) {
+                break;
+            }
+            seenCursors.add(nextCursor);
+            cursor = nextCursor;
+        }
+        return threads.slice(0, requestedLimit);
+    }
+    async readThread(threadId) {
+        const result = await this.request("thread/read", {
+            threadId,
+            includeTurns: true
+        });
+        return result.thread;
+    }
+    async getThreadGoal(threadId) {
+        const result = await this.request("thread/goal/get", { threadId });
+        return result.goal ?? null;
+    }
+    async resumeThread(threadId) {
+        const result = await this.request("thread/resume", {
+            threadId
+        });
+        return result.thread;
+    }
+    async startTurn(threadId, text, cwd) {
+        const result = await this.request("turn/start", {
+            threadId,
+            input: [textUserInput(text)],
+            cwd: cwd ?? null
+        });
+        return result.turn?.id ?? "";
+    }
+    startTurnNoWait(threadId, text, cwd) {
+        return this.requestNoWait("turn/start", {
+            threadId,
+            input: [textUserInput(text)],
+            cwd: cwd ?? null
+        });
+    }
+    async steerTurn(threadId, expectedTurnId, text) {
+        const result = await this.request("turn/steer", {
+            threadId,
+            input: [textUserInput(text)],
+            expectedTurnId
+        });
+        return result.turnId ?? "";
+    }
+    steerTurnNoWait(threadId, expectedTurnId, text) {
+        return this.requestNoWait("turn/steer", {
+            threadId,
+            input: [textUserInput(text)],
+            expectedTurnId
+        });
+    }
+    async unsubscribeThread(threadId) {
+        const result = await this.request("thread/unsubscribe", {
+            threadId
+        });
+        return result.status;
+    }
+    async listLoadedThreads() {
+        const result = await this.request("thread/loaded/list", {});
+        return Array.isArray(result.data) ? result.data : [];
+    }
+    close() {
+        if (!this.child.killed) {
+            this.child.kill();
+        }
+    }
+}
+exports.CodexAppServerClient = CodexAppServerClient;
+function textUserInput(text) {
+    return {
+        type: "text",
+        text,
+        text_elements: []
+    };
+}
+async function withAppServerClient(fn) {
+    const client = await CodexAppServerClient.create();
+    try {
+        return await fn(client);
+    }
+    finally {
+        client.close();
+    }
+}
+//# sourceMappingURL=app-server.js.map