@buildify-cli/cursor-agent 0.1.1 → 0.2.1

package/dist/runner.js

@@ -1,714 +0,0 @@
-import { Agent, Cursor, CursorAgentError } from "@cursor/sdk";
-import EventSource from "eventsource";
-import fs from "node:fs";
-import path from "node:path";
-import { AGENT_CLIENT_ID_HEADER, AGENT_SESSION_ID_HEADER, } from "./types.js";
-const APP_NAME = "buildify-cursor-agent";
-const DEFAULT_MODEL = "composer-2.5";
-const TASK_POLL_INTERVAL_MS = 5_000;
-const HEARTBEAT_FAILURES_BEFORE_RECONNECT = 2;
-const REPORT_RETRY_COUNT = 3;
-const LOG_LEVEL_WEIGHT = {
-    error: 0,
-    warn: 1,
-    info: 2,
-    debug: 3,
-};
-export class AgentRunner {
-    config;
-    sessionId = null;
-    heartbeatIntervalSec = 15;
-    heartbeatTimer = null;
-    pollTimer = null;
-    eventSource = null;
-    reconnectTimer = null;
-    stopped = false;
-    connected = false;
-    reconnecting = false;
-    pulling = false;
-    reconnectAttempts = 0;
-    heartbeatFailures = 0;
-    activeTasks = new Map();
-    availableModels = [];
-    constructor(config) {
-        this.config = config;
-    }
-    async start() {
-        this.setupSignalHandlers();
-        await this.connectWithRetry();
-        this.startHeartbeat();
-        this.openSse();
-        this.startTaskPoller();
-        this.info(`connected clientId=${this.config.clientId} session=${this.sessionId} maxConcurrent=${this.config.maxConcurrent}`);
-    }
-    async stop() {
-        if (this.stopped) {
-            return;
-        }
-        this.stopped = true;
-        this.clearTimers();
-        this.closeSse();
-        for (const task of this.activeTasks.values()) {
-            task.cancelRequested = true;
-            await this.cancelRun(task).catch((error) => this.warn("cancel during stop failed", error));
-        }
-        if (this.sessionId) {
-            await this.disconnect();
-        }
-        this.connected = false;
-        this.info("stopped");
-    }
-    getStatus() {
-        return {
-            connected: this.connected,
-            sessionId: this.sessionId,
-            runningCount: this.activeTasks.size,
-            maxConcurrent: this.config.maxConcurrent,
-            clientId: this.config.clientId,
-            server: this.config.server,
-            activeTaskIds: [...this.activeTasks.keys()],
-        };
-    }
-    setupSignalHandlers() {
-        const shutdown = () => {
-            void this.stop().finally(() => process.exit(0));
-        };
-        process.once("SIGINT", shutdown);
-        process.once("SIGTERM", shutdown);
-    }
-    clearTimers() {
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = null;
-        }
-        if (this.pollTimer) {
-            clearInterval(this.pollTimer);
-            this.pollTimer = null;
-        }
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-    }
-    clearConnectionTimers() {
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = null;
-        }
-        if (this.pollTimer) {
-            clearInterval(this.pollTimer);
-            this.pollTimer = null;
-        }
-    }
-    baseUrl() {
-        return this.config.server.replace(/\/$/, "");
-    }
-    sessionHeaders() {
-        if (!this.sessionId) {
-            throw new Error("Not connected");
-        }
-        return {
-            [AGENT_SESSION_ID_HEADER]: this.sessionId,
-        };
-    }
-    async connectWithRetry() {
-        while (!this.stopped) {
-            try {
-                await this.connect();
-                this.reconnectAttempts = 0;
-                this.heartbeatFailures = 0;
-                return;
-            }
-            catch (error) {
-                const delay = this.nextReconnectDelay();
-                this.warn(`connect failed, retrying in ${delay}ms`, error);
-                await sleep(delay);
-            }
-        }
-    }
-    async connect() {
-        const headers = {
-            "Content-Type": "application/json",
-            [AGENT_CLIENT_ID_HEADER]: this.config.clientId,
-        };
-        if (this.config.token) {
-            headers.Authorization = `Bearer ${this.config.token}`;
-        }
-        const response = await this.fetchWithTimeout(`${this.baseUrl()}/connect`, {
-            method: "POST",
-            headers,
-            body: JSON.stringify({
-                capabilities: {
-                    maxConcurrent: this.config.maxConcurrent,
-                    models: this.availableModels,
-                },
-            }),
-        });
-        if (!response.ok) {
-            const body = await response.text();
-            throw new Error(`Connect failed (${response.status}): ${body}`);
-        }
-        const data = (await response.json());
-        this.sessionId =
-            response.headers.get(AGENT_SESSION_ID_HEADER) ?? data.sessionId ?? null;
-        this.heartbeatIntervalSec = data.heartbeatIntervalSec ?? 15;
-        this.connected = true;
-    }
-    async disconnect() {
-        const sessionId = this.sessionId;
-        if (!sessionId) {
-            return;
-        }
-        try {
-            await this.fetchWithTimeout(`${this.baseUrl()}/disconnect`, {
-                method: "DELETE",
-                headers: this.sessionHeaders(),
-            });
-        }
-        catch (error) {
-            this.warn("disconnect failed", error);
-        }
-        finally {
-            this.sessionId = null;
-            this.connected = false;
-        }
-    }
-    startHeartbeat() {
-        void this.sendHeartbeat();
-        this.heartbeatTimer = setInterval(() => {
-            void this.sendHeartbeat();
-        }, this.heartbeatIntervalSec * 1000);
-    }
-    async sendHeartbeat() {
-        if (this.stopped || !this.sessionId) {
-            return;
-        }
-        try {
-            const response = await this.fetchWithTimeout(`${this.baseUrl()}/heartbeat`, {
-                method: "POST",
-                headers: {
-                    ...this.sessionHeaders(),
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify({
-                    runningCount: this.activeTasks.size,
-                    models: this.availableModels,
-                }),
-            });
-            if (response.status === 404) {
-                this.warn("session expired, reconnecting");
-                this.scheduleReconnect();
-                return;
-            }
-            if (!response.ok && response.status !== 204) {
-                throw new Error(`Heartbeat failed (${response.status}): ${await response.text()}`);
-            }
-            this.heartbeatFailures = 0;
-        }
-        catch (error) {
-            this.heartbeatFailures++;
-            this.warn(`heartbeat failed (${this.heartbeatFailures})`, error);
-            if (this.heartbeatFailures >= HEARTBEAT_FAILURES_BEFORE_RECONNECT) {
-                this.scheduleReconnect();
-            }
-        }
-    }
-    openSse() {
-        if (this.stopped || !this.sessionId) {
-            return;
-        }
-        this.closeSse();
-        const source = new EventSource(`${this.baseUrl()}/events`, {
-            headers: this.sessionHeaders(),
-        });
-        this.eventSource = source;
-        source.onopen = () => {
-            this.debug("SSE connected");
-        };
-        source.addEventListener("newTask", () => {
-            void this.tryPullAndRunTasks();
-        });
-        source.addEventListener("cancelled", (event) => {
-            void this.handleCancelledEvent(event.data);
-        });
-        source.onerror = () => {
-            if (this.stopped) {
-                return;
-            }
-            this.warn("SSE disconnected, reconnecting");
-            this.closeSse();
-            this.scheduleReconnect();
-        };
-    }
-    closeSse() {
-        if (this.eventSource) {
-            this.eventSource.close();
-            this.eventSource = null;
-        }
-    }
-    startTaskPoller() {
-        void this.tryPullAndRunTasks();
-        this.pollTimer = setInterval(() => {
-            void this.tryPullAndRunTasks();
-        }, TASK_POLL_INTERVAL_MS);
-    }
-    scheduleReconnect() {
-        if (this.stopped || this.reconnecting || this.reconnectTimer) {
-            return;
-        }
-        const delay = this.nextReconnectDelay();
-        this.reconnectTimer = setTimeout(() => {
-            this.reconnectTimer = null;
-            void this.reconnect();
-        }, delay);
-        this.debug(`scheduled reconnect in ${delay}ms`);
-    }
-    async reconnect() {
-        if (this.stopped || this.reconnecting) {
-            return;
-        }
-        this.reconnecting = true;
-        this.connected = false;
-        this.clearConnectionTimers();
-        this.closeSse();
-        this.sessionId = null;
-        try {
-            await this.connectWithRetry();
-            if (this.stopped) {
-                return;
-            }
-            this.startHeartbeat();
-            this.openSse();
-            this.startTaskPoller();
-            this.info("reconnected");
-        }
-        finally {
-            this.reconnecting = false;
-        }
-    }
-    nextReconnectDelay() {
-        const min = Math.max(250, this.config.reconnectMinDelayMs);
-        const max = Math.max(min, this.config.reconnectMaxDelayMs);
-        const exponential = Math.min(max, min * 2 ** this.reconnectAttempts);
-        this.reconnectAttempts++;
-        const jitter = Math.floor(exponential * 0.2 * Math.random());
-        return Math.min(max, exponential + jitter);
-    }
-    async tryPullAndRunTasks() {
-        if (this.stopped || this.pulling || !this.sessionId || this.reconnecting) {
-            return;
-        }
-        this.pulling = true;
-        try {
-            while (!this.stopped && this.connected && this.activeTasks.size < this.config.maxConcurrent) {
-                const task = await this.pullNextTask();
-                if (!task) {
-                    break;
-                }
-                await this.reportTaskReceived(task);
-                void this.executeTask(task).finally(() => {
-                    void this.tryPullAndRunTasks();
-                });
-            }
-        }
-        catch (error) {
-            this.warn("task polling failed", error);
-            this.scheduleReconnect();
-        }
-        finally {
-            this.pulling = false;
-        }
-    }
-    async pullNextTask() {
-        if (!this.sessionId) {
-            return null;
-        }
-        const response = await this.fetchWithTimeout(`${this.baseUrl()}/tasks/next`, {
-            method: "GET",
-            headers: this.sessionHeaders(),
-        });
-        if (response.status === 204) {
-            return null;
-        }
-        if (response.status === 404) {
-            this.scheduleReconnect();
-            return null;
-        }
-        if (!response.ok) {
-            const body = await response.text();
-            throw new Error(`Pull task failed (${response.status}): ${body}`);
-        }
-        return (await response.json());
-    }
-    async executeTask(task) {
-        const active = {
-            task,
-            startedAt: Date.now(),
-            cancelRequested: false,
-        };
-        this.activeTasks.set(task.taskId, active);
-        try {
-            const cwd = this.ensureCwd(task.cwd);
-            const model = task.model?.trim() || DEFAULT_MODEL;
-            const cursorApiKey = task.cursorApiKey?.trim();
-            this.info(`task started taskId=${task.taskId} cwd=${cwd} model=${model}`);
-            if (!cursorApiKey) {
-                throw new Error("Task is missing cursorApiKey");
-            }
-            await this.refreshAvailableModels(cursorApiKey);
-            void this.sendHeartbeat();
-            const agentOptions = {
-                apiKey: cursorApiKey,
-                model: { id: model },
-                name: `Buildify ${task.taskId}`,
-                local: {
-                    cwd,
-                    settingSources: [],
-                },
-            };
-            if (task.mcpServers && Object.keys(task.mcpServers).length > 0) {
-                agentOptions.mcpServers = task.mcpServers;
-            }
-            const agent = await Agent.create(agentOptions);
-            active.agent = agent;
-            if (active.cancelRequested) {
-                await this.reportCancelled(active, "cancelled before run started");
-                return;
-            }
-            const run = await agent.send(task.prompt, {
-                model: { id: model },
-                idempotencyKey: task.taskId,
-            });
-            active.run = run;
-            this.info(`task run created taskId=${task.taskId} agentId=${run.agentId} runId=${run.id}`);
-            await this.reportTaskEvent(task.taskId, {
-                eventType: "progress",
-                runId: run.id,
-                agentId: run.agentId,
-                phase: "started",
-                summary: "Cursor run started",
-            });
-            if (active.cancelRequested) {
-                await this.cancelRun(active);
-            }
-            const streamPromise = this.consumeRunStream(active).catch((error) => {
-                this.warn(`stream failed taskId=${task.taskId}`, error);
-            });
-            const result = await run.wait();
-            await streamPromise;
-            const durationMs = Date.now() - active.startedAt;
-            if (active.cancelRequested || result.status === "cancelled") {
-                await this.reportTaskEvent(task.taskId, {
-                    eventType: "cancelled",
-                    runId: run.id,
-                    agentId: run.agentId,
-                    durationMs,
-                    summary: "Cursor run cancelled",
-                });
-                this.info(`task cancelled taskId=${task.taskId} durationMs=${durationMs}`);
-                return;
-            }
-            if (result.status === "finished") {
-                await this.reportTaskEvent(task.taskId, {
-                    eventType: "completed",
-                    result: result.result ?? undefined,
-                    runId: run.id,
-                    agentId: run.agentId,
-                    durationMs: result.durationMs ?? durationMs,
-                });
-                this.info(`task completed taskId=${task.taskId} durationMs=${durationMs}`);
-                return;
-            }
-            await this.reportTaskEvent(task.taskId, {
-                eventType: "failed",
-                runId: run.id,
-                agentId: run.agentId,
-                errorCode: result.status,
-                errorMessage: `Cursor run finished with status: ${result.status}`,
-                durationMs: result.durationMs ?? durationMs,
-            });
-            this.warn(`task failed taskId=${task.taskId} status=${result.status}`);
-        }
-        catch (error) {
-            await this.reportExecutionError(active, error);
-        }
-        finally {
-            await this.disposeAgent(active);
-            this.activeTasks.delete(task.taskId);
-            void this.sendHeartbeat();
-        }
-    }
-    async consumeRunStream(active) {
-        const run = active.run;
-        if (!run || !run.supports("stream")) {
-            return;
-        }
-        let toolCallCount = 0;
-        for await (const message of run.stream()) {
-            if (active.cancelRequested) {
-                continue;
-            }
-            const line = this.formatSdkMessage(message);
-            if (line && (this.config.streamLogs || this.shouldLog("debug"))) {
-                this.info(`task stream taskId=${active.task.taskId} ${line}`);
-            }
-            if (message.type === "tool_call") {
-                toolCallCount++;
-                if (message.status === "completed" || message.status === "error") {
-                    await this.reportTaskEvent(active.task.taskId, {
-                        eventType: "progress",
-                        runId: message.run_id,
-                        agentId: message.agent_id,
-                        phase: `tool:${message.status}`,
-                        summary: message.name,
-                        toolCallCount,
-                    });
-                }
-            }
-            else if (message.type === "status") {
-                await this.reportTaskEvent(active.task.taskId, {
-                    eventType: "progress",
-                    runId: message.run_id,
-                    agentId: message.agent_id,
-                    phase: message.status.toLowerCase(),
-                    summary: message.message,
-                    toolCallCount,
-                });
-            }
-        }
-    }
-    async handleCancelledEvent(data) {
-        const payload = this.parseCancelEvent(data);
-        const taskId = payload.taskId;
-        if (!taskId) {
-            this.warn(`cancelled SSE missing taskId data=${data}`);
-            return;
-        }
-        const active = this.activeTasks.get(taskId);
-        if (!active) {
-            this.debug(`cancelled SSE ignored for inactive taskId=${taskId}`);
-            return;
-        }
-        active.cancelRequested = true;
-        this.info(`cancel requested taskId=${taskId}`);
-        await this.cancelRun(active);
-    }
-    async cancelRun(active) {
-        const run = active.run;
-        if (!run) {
-            return;
-        }
-        if (!run.supports("cancel")) {
-            this.warn(`run does not support cancel taskId=${active.task.taskId} reason=${run.unsupportedReason("cancel") ?? "unknown"}`);
-            return;
-        }
-        await run.cancel();
-    }
-    async reportCancelled(active, summary) {
-        await this.reportTaskEvent(active.task.taskId, {
-            eventType: "cancelled",
-            runId: active.run?.id,
-            agentId: active.run?.agentId ?? active.agent?.agentId,
-            durationMs: Date.now() - active.startedAt,
-            summary,
-        });
-    }
-    async reportExecutionError(active, error) {
-        const durationMs = Date.now() - active.startedAt;
-        const run = active.run;
-        if (active.cancelRequested) {
-            await this.reportCancelled(active, "Cursor run cancellation requested");
-            return;
-        }
-        if (error instanceof CursorAgentError) {
-            await this.reportTaskEvent(active.task.taskId, {
-                eventType: "failed",
-                runId: run?.id,
-                agentId: run?.agentId ?? active.agent?.agentId,
-                errorCode: "CURSOR_AGENT_ERROR",
-                errorMessage: error.message,
-                durationMs,
-            });
-        }
-        else {
-            await this.reportTaskEvent(active.task.taskId, {
-                eventType: "failed",
-                runId: run?.id,
-                agentId: run?.agentId ?? active.agent?.agentId,
-                errorCode: "INTERNAL_ERROR",
-                errorMessage: error instanceof Error ? error.message : String(error),
-                durationMs,
-            });
-        }
-        this.error(`task error taskId=${active.task.taskId}`, error);
-    }
-    async refreshAvailableModels(apiKey) {
-        try {
-            const models = await Cursor.models.list({ apiKey });
-            const next = models
-                .map((model) => this.modelId(model))
-                .filter((id) => Boolean(id))
-                .filter((id, index, all) => all.indexOf(id) === index);
-            if (next.length > 0) {
-                this.availableModels = next;
-                this.debug(`refreshed ${next.length} Cursor models`);
-            }
-        }
-        catch (error) {
-            this.warn("refresh Cursor models failed", error);
-        }
-    }
-    modelId(model) {
-        const id = model.id?.trim();
-        return id || null;
-    }
-    async disposeAgent(active) {
-        if (!active.agent) {
-            return;
-        }
-        try {
-            await active.agent[Symbol.asyncDispose]();
-        }
-        catch {
-            active.agent.close();
-        }
-    }
-    ensureCwd(taskCwd) {
-        const raw = taskCwd?.trim() || this.config.defaultCwd;
-        const resolved = path.resolve(raw);
-        if (!fs.existsSync(resolved)) {
-            fs.mkdirSync(resolved, { recursive: true });
-            this.info(`created working directory cwd=${resolved}`);
-        }
-        else if (!fs.statSync(resolved).isDirectory()) {
-            throw new Error(`Working directory path is not a directory: ${resolved}`);
-        }
-        return resolved;
-    }
-    async reportTaskReceived(task) {
-        await this.reportTaskEvent(task.taskId, {
-            eventType: "received",
-            summary: "Task received by buildify-cursor-agent",
-        });
-        this.info(`task received taskId=${task.taskId}`);
-    }
-    async reportTaskEvent(taskId, payload) {
-        for (let attempt = 1; attempt <= REPORT_RETRY_COUNT; attempt++) {
-            if (!this.sessionId) {
-                await sleep(this.nextShortRetryDelay(attempt));
-                continue;
-            }
-            try {
-                const response = await this.fetchWithTimeout(`${this.baseUrl()}/tasks/${taskId}/events`, {
-                    method: "POST",
-                    headers: {
-                        ...this.sessionHeaders(),
-                        "Content-Type": "application/json",
-                    },
-                    body: JSON.stringify(payload),
-                });
-                if (response.ok || response.status === 204) {
-                    return;
-                }
-                if (response.status === 404) {
-                    this.scheduleReconnect();
-                }
-                const body = await response.text();
-                throw new Error(`Report task event failed (${response.status}): ${body}`);
-            }
-            catch (error) {
-                if (attempt === REPORT_RETRY_COUNT) {
-                    throw error;
-                }
-                this.warn(`report event retry ${attempt}/${REPORT_RETRY_COUNT} taskId=${taskId}`, error);
-                await sleep(this.nextShortRetryDelay(attempt));
-            }
-        }
-    }
-    async fetchWithTimeout(input, init) {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), this.config.requestTimeoutMs);
-        try {
-            return await fetch(input, {
-                ...init,
-                signal: controller.signal,
-            });
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
-    nextShortRetryDelay(attempt) {
-        return Math.min(5_000, 500 * 2 ** (attempt - 1));
-    }
-    parseCancelEvent(data) {
-        try {
-            return JSON.parse(data);
-        }
-        catch {
-            return {};
-        }
-    }
-    formatSdkMessage(message) {
-        switch (message.type) {
-            case "system":
-                return `system agentId=${message.agent_id} runId=${message.run_id}`;
-            case "status":
-                return `status=${message.status}${message.message ? ` message=${message.message}` : ""}`;
-            case "assistant": {
-                const text = message.message.content
-                    .filter((block) => block.type === "text")
-                    .map((block) => block.text)
-                    .join("");
-                return text ? `assistant=${truncate(text)}` : null;
-            }
-            case "thinking":
-                return `thinking=${truncate(message.text)}`;
-            case "tool_call":
-                return `tool=${message.name} status=${message.status}`;
-            case "task":
-                return `task status=${message.status ?? ""} text=${truncate(message.text ?? "")}`;
-            default:
-                return `event=${message.type}`;
-        }
-    }
-    shouldLog(level) {
-        return LOG_LEVEL_WEIGHT[this.config.logLevel] >= LOG_LEVEL_WEIGHT[level];
-    }
-    log(method, message, error) {
-        if (!this.shouldLog(method)) {
-            return;
-        }
-        const line = `[${APP_NAME}] ${message}`;
-        if (error === undefined) {
-            console[method](line);
-        }
-        else {
-            console[method](line, error);
-        }
-    }
-    error(message, error) {
-        this.log("error", message, error);
-    }
-    warn(message, error) {
-        this.log("warn", message, error);
-    }
-    info(message, error) {
-        this.log("info", message, error);
-    }
-    debug(message, error) {
-        this.log("debug", message, error);
-    }
-}
-export async function runAgent(config) {
-    const runner = new AgentRunner(config);
-    await runner.start();
-    return runner;
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function truncate(value, max = 500) {
-    return value.length <= max ? value : `${value.slice(0, max)}...`;
-}
-//# sourceMappingURL=runner.js.map