diffact 0.1.0

package/dist/agent-manager.d.ts

@@ -0,0 +1,32 @@
+import type { AgentInfo } from "./types.js";
+import type { WsHub } from "./ws-hub.js";
+export declare class AgentManager {
+    #private;
+    constructor(params: {
+        hub: WsHub;
+    });
+    listAgents(): AgentInfo[];
+    listThreads(params: {
+        cursor?: string | null;
+        limit?: number | null;
+        projectPath?: string | null;
+    }): Promise<unknown>;
+    getAgent(id: string): AgentInfo | null;
+    resumeThread(params: {
+        threadId: string;
+        projectPath: string;
+        label?: string;
+    }): Promise<AgentInfo>;
+    startAgent(params: {
+        label?: string;
+        projectPath: string;
+        prompt: string;
+    }): Promise<AgentInfo>;
+    startThread(params: {
+        label?: string;
+        projectPath: string;
+    }): Promise<AgentInfo>;
+    stopAgent(id: string): boolean;
+    stopThread(threadId: string): boolean;
+    sendMessage(id: string, message: string): Promise<boolean>;
+}

package/dist/agent-manager.js

@@ -0,0 +1,502 @@
+import { AppServerClient } from "./app-server-client.js";
+import { resolveProjectRoot } from "./project-path.js";
+import { createId } from "./utils.js";
+const getApprovalPolicy = () => process.env.CODEX_APPROVAL_POLICY?.trim() || "on-request";
+const getSandboxMode = () => process.env.CODEX_SANDBOX_MODE?.trim() || "workspace-write";
+const parseTurnId = (params) => {
+    if (!params || typeof params !== "object") {
+        return null;
+    }
+    const record = params;
+    const turn = record.turn;
+    if (turn && typeof turn === "object" && "id" in turn) {
+        const id = turn.id;
+        return typeof id === "string" ? id : null;
+    }
+    if ("turnId" in record) {
+        const id = record.turnId;
+        return typeof id === "string" ? id : null;
+    }
+    return null;
+};
+const parseThreadId = (params) => {
+    if (!params || typeof params !== "object") {
+        return null;
+    }
+    const record = params;
+    if ("threadId" in record) {
+        const id = record.threadId;
+        return typeof id === "string" ? id : null;
+    }
+    const thread = record.thread;
+    if (thread && typeof thread === "object" && "id" in thread) {
+        const id = thread.id;
+        return typeof id === "string" ? id : null;
+    }
+    return null;
+};
+const parseTurnError = (params) => {
+    if (!params || typeof params !== "object") {
+        return null;
+    }
+    const record = params;
+    const error = record.error;
+    if (error && typeof error === "object" && "message" in error) {
+        const message = error.message;
+        return typeof message === "string" ? message : null;
+    }
+    return null;
+};
+const FILTERED_THREAD_CURSOR_PREFIX = "project:";
+const parseThreadListResponse = (value) => {
+    if (!value || typeof value !== "object") {
+        return { data: [], nextCursor: null };
+    }
+    const record = value;
+    const data = Array.isArray(record.data)
+        ? record.data.filter((item) => Boolean(item) && typeof item === "object")
+        : [];
+    const nextCursor = typeof record.nextCursor === "string" ? record.nextCursor : null;
+    return { data, nextCursor };
+};
+const parseThreadListCursor = (cursor) => {
+    if (!cursor || !cursor.startsWith(FILTERED_THREAD_CURSOR_PREFIX)) {
+        return null;
+    }
+    const payload = cursor.slice(FILTERED_THREAD_CURSOR_PREFIX.length);
+    try {
+        const decoded = Buffer.from(payload, "base64").toString("utf8");
+        const parsed = JSON.parse(decoded);
+        if (!parsed || typeof parsed !== "object") {
+            return null;
+        }
+        const record = parsed;
+        const upstreamCursor = typeof record.upstreamCursor === "string" ? record.upstreamCursor : null;
+        const buffered = Array.isArray(record.buffered)
+            ? record.buffered.filter((item) => Boolean(item) && typeof item === "object")
+            : [];
+        return { upstreamCursor, buffered };
+    }
+    catch {
+        return null;
+    }
+};
+const serializeThreadListCursor = (state) => {
+    const payload = Buffer.from(JSON.stringify(state)).toString("base64");
+    return `${FILTERED_THREAD_CURSOR_PREFIX}${payload}`;
+};
+export class AgentManager {
+    #hub;
+    #agents = new Map();
+    #agentsByThread = new Map();
+    #client;
+    constructor(params) {
+        this.#hub = params.hub;
+        this.#client = new AppServerClient({
+            onNotification: (notification) => {
+                this.#routeNotification(notification);
+            },
+            onRequest: async (request) => this.#handleRequest(request),
+            onClose: (error) => {
+                this.#handleAppServerClose(error);
+            },
+        });
+    }
+    listAgents() {
+        return Array.from(this.#agents.values()).map((agent) => this.#toAgentInfo(agent));
+    }
+    async listThreads(params) {
+        await this.#client.initialize({
+            name: "diffact",
+            title: "diffact",
+            version: "0.1.0",
+        });
+        if (!params.projectPath) {
+            return this.#client.request("thread/list", {
+                cursor: params.cursor ?? null,
+                limit: params.limit ?? null,
+                modelProviders: null,
+            });
+        }
+        const limit = params.limit ?? null;
+        const parsedCursor = parseThreadListCursor(params.cursor ?? null);
+        let upstreamCursor = parsedCursor?.upstreamCursor ?? params.cursor ?? null;
+        const buffered = (parsedCursor?.buffered ?? []).filter((item) => item.cwd === params.projectPath);
+        if (limit !== null && limit <= 0) {
+            return { data: [], nextCursor: null };
+        }
+        if (limit === null) {
+            const response = await this.#client.request("thread/list", {
+                cursor: upstreamCursor,
+                limit: null,
+                modelProviders: null,
+            });
+            const page = parseThreadListResponse(response);
+            return {
+                data: page.data.filter((item) => item.cwd === params.projectPath),
+                nextCursor: page.nextCursor,
+            };
+        }
+        if (buffered.length >= limit) {
+            const remainder = buffered.slice(limit);
+            return {
+                data: buffered.slice(0, limit),
+                nextCursor: remainder.length
+                    ? serializeThreadListCursor({
+                        upstreamCursor,
+                        buffered: remainder,
+                    })
+                    : upstreamCursor,
+            };
+        }
+        const collected = buffered.slice();
+        const seen = new Set();
+        while (true) {
+            const response = await this.#client.request("thread/list", {
+                cursor: upstreamCursor,
+                limit,
+                modelProviders: null,
+            });
+            const page = parseThreadListResponse(response);
+            collected.push(...page.data.filter((item) => item.cwd === params.projectPath));
+            if (collected.length >= limit) {
+                const remainder = collected.slice(limit);
+                return {
+                    data: collected.slice(0, limit),
+                    nextCursor: remainder.length
+                        ? serializeThreadListCursor({
+                            upstreamCursor: page.nextCursor ?? null,
+                            buffered: remainder,
+                        })
+                        : (page.nextCursor ?? null),
+                };
+            }
+            if (!page.nextCursor) {
+                return { data: collected, nextCursor: null };
+            }
+            if (seen.has(page.nextCursor)) {
+                return { data: collected, nextCursor: page.nextCursor };
+            }
+            seen.add(page.nextCursor);
+            upstreamCursor = page.nextCursor;
+        }
+    }
+    getAgent(id) {
+        const agent = this.#agents.get(id);
+        return agent ? this.#toAgentInfo(agent) : null;
+    }
+    async resumeThread(params) {
+        const existing = this.#agentsByThread.get(params.threadId);
+        if (existing) {
+            return this.#toAgentInfo(existing);
+        }
+        const id = createId();
+        const now = new Date().toISOString();
+        const runtime = {
+            id,
+            label: params.label || `thread-${params.threadId.slice(0, 6)}`,
+            status: "completed",
+            createdAt: now,
+            projectPath: params.projectPath,
+            threadId: params.threadId,
+            lastError: undefined,
+            exitCode: null,
+            signal: null,
+            stoppedByUser: false,
+            activeTurnId: null,
+        };
+        this.#agents.set(id, runtime);
+        this.#agentsByThread.set(params.threadId, runtime);
+        this.#hub.send("agent_status", this.#toAgentInfo(runtime));
+        try {
+            await this.#client.initialize({
+                name: "diffact",
+                title: "diffact",
+                version: "0.1.0",
+            });
+            const threadResponse = await this.#client.request("thread/resume", {
+                threadId: params.threadId,
+            });
+            const threadId = parseThreadId(threadResponse);
+            if (threadId && threadId !== params.threadId) {
+                runtime.threadId = threadId;
+                this.#agentsByThread.set(threadId, runtime);
+            }
+        }
+        catch (error) {
+            runtime.status = "error";
+            runtime.lastError =
+                error instanceof Error ? error.message : "app_server_error";
+            this.#hub.send("agent_status", this.#toAgentInfo(runtime));
+        }
+        return this.#toAgentInfo(runtime);
+    }
+    async startAgent(params) {
+        const project = await resolveProjectRoot(params.projectPath);
+        const id = createId();
+        const now = new Date().toISOString();
+        const runtime = {
+            id,
+            label: params.label || `agent-${id.slice(0, 6)}`,
+            status: "starting",
+            createdAt: now,
+            projectPath: project.rootPath,
+            threadId: null,
+            lastError: undefined,
+            exitCode: null,
+            signal: null,
+            stoppedByUser: false,
+            activeTurnId: null,
+        };
+        this.#agents.set(id, runtime);
+        this.#hub.send("agent_status", this.#toAgentInfo(runtime));
+        try {
+            await this.#client.initialize({
+                name: "diffact",
+                title: "diffact",
+                version: "0.1.0",
+            });
+            const threadResponse = await this.#client.request("thread/start", {
+                model: null,
+                modelProvider: null,
+                cwd: project.rootPath,
+                approvalPolicy: getApprovalPolicy(),
+                sandbox: getSandboxMode(),
+                config: null,
+                baseInstructions: null,
+                developerInstructions: null,
+                experimentalRawEvents: false,
+            });
+            const threadId = parseThreadId(threadResponse);
+            if (!threadId) {
+                throw new Error("app_server_thread_start_failed");
+            }
+            runtime.threadId = threadId;
+            this.#agentsByThread.set(threadId, runtime);
+            this.#hub.send("agent_status", this.#toAgentInfo(runtime));
+            await this.#client.request("turn/start", {
+                threadId: runtime.threadId,
+                input: [{ type: "text", text: params.prompt }],
+                cwd: null,
+                approvalPolicy: null,
+                sandboxPolicy: null,
+                model: null,
+                effort: null,
+                summary: null,
+                outputSchema: null,
+            });
+        }
+        catch (error) {
+            runtime.status = "error";
+            runtime.lastError =
+                error instanceof Error ? error.message : "app_server_error";
+            this.#hub.send("agent_status", this.#toAgentInfo(runtime));
+        }
+        return this.#toAgentInfo(runtime);
+    }
+    async startThread(params) {
+        const project = await resolveProjectRoot(params.projectPath);
+        const id = createId();
+        const now = new Date().toISOString();
+        const runtime = {
+            id,
+            label: params.label || `thread-${id.slice(0, 6)}`,
+            status: "starting",
+            createdAt: now,
+            projectPath: project.rootPath,
+            threadId: null,
+            lastError: undefined,
+            exitCode: null,
+            signal: null,
+            stoppedByUser: false,
+            activeTurnId: null,
+        };
+        this.#agents.set(id, runtime);
+        this.#hub.send("agent_status", this.#toAgentInfo(runtime));
+        try {
+            await this.#client.initialize({
+                name: "diffact",
+                title: "diffact",
+                version: "0.1.0",
+            });
+            const threadResponse = await this.#client.request("thread/start", {
+                model: null,
+                modelProvider: null,
+                cwd: project.rootPath,
+                approvalPolicy: getApprovalPolicy(),
+                sandbox: getSandboxMode(),
+                config: null,
+                baseInstructions: null,
+                developerInstructions: null,
+                experimentalRawEvents: false,
+            });
+            const threadId = parseThreadId(threadResponse);
+            if (!threadId) {
+                throw new Error("app_server_thread_start_failed");
+            }
+            runtime.threadId = threadId;
+            runtime.status = "completed";
+            this.#agentsByThread.set(threadId, runtime);
+            this.#hub.send("agent_status", this.#toAgentInfo(runtime));
+        }
+        catch (error) {
+            runtime.status = "error";
+            runtime.lastError =
+                error instanceof Error ? error.message : "app_server_error";
+            this.#hub.send("agent_status", this.#toAgentInfo(runtime));
+        }
+        return this.#toAgentInfo(runtime);
+    }
+    stopAgent(id) {
+        const agent = this.#agents.get(id);
+        if (!agent) {
+            return false;
+        }
+        agent.stoppedByUser = true;
+        agent.status = "stopped";
+        if (agent.threadId && agent.activeTurnId) {
+            this.#client
+                .request("turn/interrupt", {
+                threadId: agent.threadId,
+                turnId: agent.activeTurnId,
+            })
+                .catch(() => { });
+        }
+        if (agent.threadId) {
+            this.#agentsByThread.delete(agent.threadId);
+        }
+        this.#hub.send("agent_status", this.#toAgentInfo(agent));
+        return true;
+    }
+    stopThread(threadId) {
+        const runtime = this.#agentsByThread.get(threadId);
+        if (!runtime) {
+            return false;
+        }
+        return this.stopAgent(runtime.id);
+    }
+    async sendMessage(id, message) {
+        const agent = this.#agents.get(id);
+        if (!agent || !agent.threadId) {
+            return false;
+        }
+        agent.status = "running";
+        agent.lastError = undefined;
+        this.#hub.send("agent_status", this.#toAgentInfo(agent));
+        try {
+            await this.#client.initialize({
+                name: "diffact",
+                title: "diffact",
+                version: "0.1.0",
+            });
+            await this.#client.request("turn/start", {
+                threadId: agent.threadId,
+                input: [{ type: "text", text: message }],
+                cwd: null,
+                approvalPolicy: null,
+                sandboxPolicy: null,
+                model: null,
+                effort: null,
+                summary: null,
+                outputSchema: null,
+            });
+        }
+        catch (error) {
+            agent.status = "error";
+            agent.lastError =
+                error instanceof Error ? error.message : "app_server_error";
+            this.#hub.send("agent_status", this.#toAgentInfo(agent));
+        }
+        return true;
+    }
+    #routeNotification(notification) {
+        const threadId = parseThreadId(notification.params);
+        if (threadId) {
+            const runtime = this.#agentsByThread.get(threadId);
+            if (runtime && !runtime.stoppedByUser) {
+                this.#handleNotification(runtime, notification);
+            }
+            return;
+        }
+        for (const runtime of this.#agents.values()) {
+            if (runtime.stoppedByUser) {
+                continue;
+            }
+            this.#handleNotification(runtime, notification);
+        }
+    }
+    #handleNotification(runtime, notification) {
+        let statusChanged = false;
+        if (notification.method === "thread/started") {
+            const threadId = parseThreadId(notification.params);
+            if (threadId) {
+                runtime.threadId = threadId;
+                this.#agentsByThread.set(threadId, runtime);
+                statusChanged = true;
+            }
+        }
+        if (notification.method === "turn/started") {
+            runtime.status = "running";
+            runtime.activeTurnId = parseTurnId(notification.params);
+            statusChanged = true;
+        }
+        if (notification.method === "turn/completed") {
+            runtime.status = "completed";
+            runtime.activeTurnId = null;
+            statusChanged = true;
+        }
+        if (notification.method === "error") {
+            runtime.status = "error";
+            runtime.lastError = parseTurnError(notification.params) || "turn_error";
+            statusChanged = true;
+        }
+        if (statusChanged) {
+            this.#hub.send("agent_status", this.#toAgentInfo(runtime));
+        }
+        this.#hub.send("agent_event", {
+            projectPath: runtime.projectPath,
+            threadId: runtime.threadId,
+            event: notification,
+        });
+    }
+    #handleAppServerClose(error) {
+        this.#agentsByThread.clear();
+        for (const runtime of this.#agents.values()) {
+            if (runtime.stoppedByUser) {
+                continue;
+            }
+            runtime.status = "error";
+            runtime.lastError = error?.message || "app_server_closed";
+            runtime.activeTurnId = null;
+            this.#hub.send("agent_status", this.#toAgentInfo(runtime));
+        }
+    }
+    async #handleRequest(request) {
+        if (request.method === "item/commandExecution/requestApproval") {
+            return { decision: "accept" };
+        }
+        if (request.method === "item/fileChange/requestApproval") {
+            return { decision: "accept" };
+        }
+        if (request.method === "applyPatchApproval") {
+            return { decision: "approved" };
+        }
+        if (request.method === "execCommandApproval") {
+            return { decision: "approved" };
+        }
+        return null;
+    }
+    #toAgentInfo(agent) {
+        return {
+            id: agent.id,
+            label: agent.label,
+            status: agent.status,
+            createdAt: agent.createdAt,
+            projectPath: agent.projectPath,
+            threadId: agent.threadId ?? null,
+            lastError: agent.lastError,
+            exitCode: agent.exitCode ?? null,
+            signal: agent.signal ?? null,
+        };
+    }
+}

package/dist/app-server-client.d.ts

@@ -0,0 +1,38 @@
+type RequestId = string | number;
+export type AppServerMessage = {
+    id?: RequestId;
+    method?: string;
+    params?: unknown;
+    result?: unknown;
+    error?: unknown;
+};
+export type AppServerNotification = {
+    method: string;
+    params?: unknown;
+};
+export type AppServerRequest = {
+    id: RequestId;
+    method: string;
+    params?: unknown;
+};
+type AppServerClientOptions = {
+    command?: string;
+    args?: string[];
+    onNotification?: (notification: AppServerNotification) => void;
+    onRequest?: (request: AppServerRequest) => Promise<unknown> | unknown;
+    onClose?: (error?: Error) => void;
+};
+export declare class AppServerClient {
+    #private;
+    constructor(options: AppServerClientOptions);
+    connect(): Promise<void>;
+    initialize(params: {
+        name: string;
+        title?: string;
+        version: string;
+    }): Promise<void>;
+    request(method: string, params?: unknown): Promise<unknown>;
+    notify(method: string, params?: unknown): void;
+    close(): void;
+}
+export {};