@paperclipai/adapter-cursor-cloud 0.3.1

package/dist/cli/format-event.d.ts

@@ -0,0 +1,2 @@
+export declare function printCursorCloudEvent(raw: string, _debug: boolean): void;
+//# sourceMappingURL=format-event.d.ts.map

package/dist/cli/format-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-event.d.ts","sourceRoot":"","sources":["../../src/cli/format-event.ts"],"names":[],"mappings":"AAGA,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAsCxE"}

package/dist/cli/format-event.js

@@ -0,0 +1,42 @@
+import pc from "picocolors";
+import { parseCursorCloudStdoutLine } from "../ui/parse-stdout.js";
+export function printCursorCloudEvent(raw, _debug) {
+    const entries = parseCursorCloudStdoutLine(raw, new Date().toISOString());
+    for (const entry of entries) {
+        switch (entry.kind) {
+            case "assistant":
+                console.log(pc.green(`assistant: ${entry.text}`));
+                break;
+            case "thinking":
+                console.log(pc.gray(`thinking: ${entry.text}`));
+                break;
+            case "user":
+                console.log(pc.gray(`user: ${entry.text}`));
+                break;
+            case "tool_call":
+                console.log(pc.yellow(`tool_call: ${entry.name}`));
+                break;
+            case "tool_result":
+                console.log((entry.isError ? pc.red : pc.cyan)(entry.content || "tool result"));
+                break;
+            case "result":
+                console.log((entry.isError ? pc.red : pc.blue)(`result: ${entry.subtype}${entry.text ? ` - ${entry.text}` : ""}`));
+                break;
+            case "stderr":
+                console.error(pc.red(entry.text));
+                break;
+            case "system":
+                console.log(pc.blue(entry.text));
+                break;
+            case "init":
+                console.log(pc.blue(`Cursor Cloud init (${entry.sessionId})`));
+                break;
+            case "stdout":
+                console.log(entry.text);
+                break;
+            default:
+                console.log("text" in entry ? entry.text : JSON.stringify(entry));
+        }
+    }
+}
+//# sourceMappingURL=format-event.js.map

package/dist/cli/format-event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-event.js","sourceRoot":"","sources":["../../src/cli/format-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAEnE,MAAM,UAAU,qBAAqB,CAAC,GAAW,EAAE,MAAe;IAChE,MAAM,OAAO,GAAG,0BAA0B,CAAC,GAAG,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;IAC1E,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;YACnB,KAAK,WAAW;gBACd,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,cAAc,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;gBAClD,MAAM;YACR,KAAK,UAAU;gBACb,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;gBAChD,MAAM;YACR,KAAK,MAAM;gBACT,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;gBAC5C,MAAM;YACR,KAAK,WAAW;gBACd,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,cAAc,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;gBACnD,MAAM;YACR,KAAK,aAAa;gBAChB,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,aAAa,CAAC,CAAC,CAAC;gBAChF,MAAM;YACR,KAAK,QAAQ;gBACX,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,WAAW,KAAK,CAAC,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;gBACnH,MAAM;YACR,KAAK,QAAQ;gBACX,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;gBAClC,MAAM;YACR,KAAK,QAAQ;gBACX,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;gBACjC,MAAM;YACR,KAAK,MAAM;gBACT,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,sBAAsB,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC;gBAC/D,MAAM;YACR,KAAK,QAAQ;gBACX,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBACxB,MAAM;YACR;gBACE,OAAO,CAAC,GAAG,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;QACtE,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+export { printCursorCloudEvent } from "./format-event.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/cli/index.js

@@ -0,0 +1,2 @@
+export { printCursorCloudEvent } from "./format-event.js";
+//# sourceMappingURL=index.js.map

package/dist/cli/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export declare const type = "cursor_cloud";
+export declare const label = "Cursor Cloud";
+export declare const agentConfigurationDoc = "# cursor_cloud agent configuration\n\nAdapter: cursor_cloud\n\nUse when:\n- You want Paperclip to run Cursor Cloud Agents through the official Cursor SDK\n- You want durable remote Cursor agent sessions across Paperclip heartbeats\n- You want Paperclip to keep task state while Cursor handles remote code execution\n\nCore fields:\n- repoUrl (string, required): Git repository URL Cursor should open\n- repoStartingRef (string, optional): starting ref for the repo\n- repoPullRequestUrl (string, optional): PR URL to attach the agent to\n- runtimeEnvType (string, optional): cloud | pool | machine\n- runtimeEnvName (string, optional): named cloud/pool/machine target\n- workOnCurrentBranch (boolean, optional): continue work on current branch\n- autoCreatePR (boolean, optional): let Cursor auto-create a PR\n- skipReviewerRequest (boolean, optional): suppress reviewer request on auto-created PRs\n- instructionsFilePath (string, optional): agent instructions file prepended to the prompt\n- promptTemplate (string, optional): heartbeat prompt template\n- bootstrapPromptTemplate (string, optional): first-run-only bootstrap prompt template\n- model (string, optional): Cursor model id; omit to use the account default\n- env.CURSOR_API_KEY (string, required): Cursor API key\n- env.* (optional): additional env vars injected into the cloud agent shell\n\nNotes:\n- Paperclip reuses the durable Cursor agent across heartbeats when the repo/runtime identity still matches.\n- Each Paperclip heartbeat maps to a Cursor run on that durable agent.\n- Paperclip injects PAPERCLIP_* runtime env vars into the cloud agent shell through Cursor SDK cloud envVars.\n- Paperclip remains the source of truth for issue/task state; Cursor provides the remote execution surface.\n";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,iBAAiB,CAAC;AACnC,eAAO,MAAM,KAAK,iBAAiB,CAAC;AAEpC,eAAO,MAAM,qBAAqB,4uDA8BjC,CAAC"}

package/dist/index.js

@@ -0,0 +1,34 @@
+export const type = "cursor_cloud";
+export const label = "Cursor Cloud";
+export const agentConfigurationDoc = `# cursor_cloud agent configuration
+
+Adapter: cursor_cloud
+
+Use when:
+- You want Paperclip to run Cursor Cloud Agents through the official Cursor SDK
+- You want durable remote Cursor agent sessions across Paperclip heartbeats
+- You want Paperclip to keep task state while Cursor handles remote code execution
+
+Core fields:
+- repoUrl (string, required): Git repository URL Cursor should open
+- repoStartingRef (string, optional): starting ref for the repo
+- repoPullRequestUrl (string, optional): PR URL to attach the agent to
+- runtimeEnvType (string, optional): cloud | pool | machine
+- runtimeEnvName (string, optional): named cloud/pool/machine target
+- workOnCurrentBranch (boolean, optional): continue work on current branch
+- autoCreatePR (boolean, optional): let Cursor auto-create a PR
+- skipReviewerRequest (boolean, optional): suppress reviewer request on auto-created PRs
+- instructionsFilePath (string, optional): agent instructions file prepended to the prompt
+- promptTemplate (string, optional): heartbeat prompt template
+- bootstrapPromptTemplate (string, optional): first-run-only bootstrap prompt template
+- model (string, optional): Cursor model id; omit to use the account default
+- env.CURSOR_API_KEY (string, required): Cursor API key
+- env.* (optional): additional env vars injected into the cloud agent shell
+
+Notes:
+- Paperclip reuses the durable Cursor agent across heartbeats when the repo/runtime identity still matches.
+- Each Paperclip heartbeat maps to a Cursor run on that durable agent.
+- Paperclip injects PAPERCLIP_* runtime env vars into the cloud agent shell through Cursor SDK cloud envVars.
+- Paperclip remains the source of truth for issue/task state; Cursor provides the remote execution surface.
+`;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,IAAI,GAAG,cAAc,CAAC;AACnC,MAAM,CAAC,MAAM,KAAK,GAAG,cAAc,CAAC;AAEpC,MAAM,CAAC,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BpC,CAAC"}

package/dist/server/execute.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterExecutionContext, AdapterExecutionResult } from "@paperclipai/adapter-utils";
+export declare function execute(ctx: AdapterExecutionContext): Promise<AdapterExecutionResult>;
+//# sourceMappingURL=execute.d.ts.map

package/dist/server/execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../src/server/execute.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,uBAAuB,EAAE,sBAAsB,EAAyB,MAAM,4BAA4B,CAAC;AAqTzH,wBAAsB,OAAO,CAAC,GAAG,EAAE,uBAAuB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CA8R3F"}

package/dist/server/execute.js

@@ -0,0 +1,524 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Agent, } from "@cursor/sdk";
+import { DEFAULT_PAPERCLIP_AGENT_PROMPT_TEMPLATE, asBoolean, asString, buildPaperclipEnv, joinPromptSections, parseObject, readPaperclipIssueWorkModeFromContext, renderPaperclipWakePrompt, renderTemplate, stringifyPaperclipWakePayload, } from "@paperclipai/adapter-utils/server-utils";
+function asRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    return value;
+}
+function asStringEnvMap(value) {
+    const parsed = parseObject(value);
+    const env = {};
+    for (const [key, entry] of Object.entries(parsed)) {
+        if (typeof entry === "string") {
+            env[key] = entry;
+        }
+        else if (typeof entry === "object" && entry !== null && !Array.isArray(entry)) {
+            const rec = entry;
+            if (rec.type === "plain" && typeof rec.value === "string")
+                env[key] = rec.value;
+        }
+    }
+    return env;
+}
+function normalizeEnvType(raw) {
+    const value = raw.trim().toLowerCase();
+    if (value === "pool" || value === "machine")
+        return value;
+    return "cloud";
+}
+function trimNullable(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function firstNonEmptyLine(text) {
+    return (text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean) ?? "");
+}
+function toModelSelection(rawModel) {
+    const model = rawModel.trim();
+    return model ? { id: model } : undefined;
+}
+function toSummary(result) {
+    const direct = trimNullable(result.result);
+    if (direct)
+        return firstNonEmptyLine(direct);
+    return null;
+}
+function formatRunError(err) {
+    if (err instanceof Error && err.message.trim().length > 0)
+        return err.message.trim();
+    return String(err);
+}
+function buildWakeEnv(ctx, configEnv) {
+    const { runId, agent, context, authToken } = ctx;
+    const env = {
+        ...configEnv,
+        ...buildPaperclipEnv(agent),
+        PAPERCLIP_RUN_ID: runId,
+    };
+    const wakeTaskId = trimNullable(context.taskId) ?? trimNullable(context.issueId);
+    const wakeReason = trimNullable(context.wakeReason);
+    const wakeCommentId = trimNullable(context.wakeCommentId) ?? trimNullable(context.commentId);
+    const approvalId = trimNullable(context.approvalId);
+    const approvalStatus = trimNullable(context.approvalStatus);
+    const linkedIssueIds = Array.isArray(context.issueIds)
+        ? context.issueIds.filter((value) => typeof value === "string" && value.trim().length > 0)
+        : [];
+    const wakePayloadJson = stringifyPaperclipWakePayload(context.paperclipWake);
+    const issueWorkMode = readPaperclipIssueWorkModeFromContext(context);
+    if (wakeTaskId)
+        env.PAPERCLIP_TASK_ID = wakeTaskId;
+    if (wakeReason)
+        env.PAPERCLIP_WAKE_REASON = wakeReason;
+    if (wakeCommentId)
+        env.PAPERCLIP_WAKE_COMMENT_ID = wakeCommentId;
+    if (approvalId)
+        env.PAPERCLIP_APPROVAL_ID = approvalId;
+    if (approvalStatus)
+        env.PAPERCLIP_APPROVAL_STATUS = approvalStatus;
+    if (linkedIssueIds.length > 0)
+        env.PAPERCLIP_LINKED_ISSUE_IDS = linkedIssueIds.join(",");
+    if (wakePayloadJson)
+        env.PAPERCLIP_WAKE_PAYLOAD_JSON = wakePayloadJson;
+    if (issueWorkMode)
+        env.PAPERCLIP_ISSUE_WORK_MODE = issueWorkMode;
+    if (!trimNullable(env.PAPERCLIP_API_KEY) && authToken) {
+        env.PAPERCLIP_API_KEY = authToken;
+    }
+    const workspace = parseObject(context.paperclipWorkspace);
+    const workspaceMappings = [
+        ["PAPERCLIP_WORKSPACE_CWD", workspace.cwd],
+        ["PAPERCLIP_WORKSPACE_SOURCE", workspace.source],
+        ["PAPERCLIP_WORKSPACE_ID", workspace.workspaceId],
+        ["PAPERCLIP_WORKSPACE_REPO_URL", workspace.repoUrl],
+        ["PAPERCLIP_WORKSPACE_REPO_REF", workspace.repoRef],
+        ["PAPERCLIP_WORKSPACE_BRANCH", workspace.branch],
+        ["PAPERCLIP_WORKSPACE_WORKTREE_PATH", workspace.worktreePath],
+        ["AGENT_HOME", workspace.agentHome],
+    ];
+    for (const [key, value] of workspaceMappings) {
+        const normalized = trimNullable(value);
+        if (normalized)
+            env[key] = normalized;
+    }
+    delete env.CURSOR_API_KEY;
+    return env;
+}
+async function buildInstructionsPrefix(config, onLog) {
+    const instructionsFilePath = asString(config.instructionsFilePath, "").trim();
+    if (!instructionsFilePath) {
+        return { prefix: "", notes: [], chars: 0 };
+    }
+    try {
+        const contents = await fs.readFile(instructionsFilePath, "utf8");
+        const instructionsDir = `${path.dirname(instructionsFilePath)}/`;
+        const prefix = `${contents.trim()}\n\nThe above agent instructions were loaded from ${instructionsFilePath}. Resolve any relative file references from ${instructionsDir}.\n`;
+        return {
+            prefix,
+            chars: prefix.length,
+            notes: [
+                `Loaded agent instructions from ${instructionsFilePath}`,
+                `Prepended instructions + path directive to prompt (relative references from ${instructionsDir}).`,
+            ],
+        };
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        await onLog("stderr", `[paperclip] Warning: could not read agent instructions file "${instructionsFilePath}": ${reason}\n`);
+        return {
+            prefix: "",
+            chars: 0,
+            notes: [
+                `Configured instructionsFilePath ${instructionsFilePath}, but file could not be read; continuing without injected instructions.`,
+            ],
+        };
+    }
+}
+function renderPaperclipEnvNote(env) {
+    const keys = Object.keys(env)
+        .filter((key) => key.startsWith("PAPERCLIP_"))
+        .sort();
+    if (keys.length === 0)
+        return "";
+    return [
+        "Paperclip runtime note:",
+        `The following PAPERCLIP_* environment variables are available in the cloud agent shell: ${keys.join(", ")}`,
+        "Use them directly instead of assuming they are absent.",
+    ].join("\n");
+}
+function readSession(params) {
+    if (!params)
+        return null;
+    const record = asRecord(params);
+    if (!record)
+        return null;
+    const cursorAgentId = trimNullable(record.cursorAgentId) ??
+        trimNullable(record.agentId) ??
+        trimNullable(record.sessionId);
+    if (!cursorAgentId)
+        return null;
+    const latestRunId = trimNullable(record.latestRunId) ?? trimNullable(record.runId) ?? undefined;
+    const envType = trimNullable(record.envType);
+    const envName = trimNullable(record.envName);
+    const reposValue = Array.isArray(record.repos) ? record.repos : [];
+    const repos = reposValue
+        .map((entry) => asRecord(entry))
+        .filter((entry) => Boolean(entry))
+        .map((entry) => ({
+        url: asString(entry.url, "").trim(),
+        startingRef: trimNullable(entry.startingRef) ?? undefined,
+        prUrl: trimNullable(entry.prUrl) ?? undefined,
+    }))
+        .filter((entry) => entry.url.length > 0);
+    return {
+        cursorAgentId,
+        ...(latestRunId ? { latestRunId } : {}),
+        runtime: "cloud",
+        ...(envType ? { envType: normalizeEnvType(envType) } : {}),
+        ...(envName ? { envName } : {}),
+        repos,
+    };
+}
+function sessionMatches(session, envType, envName, repos) {
+    if (!session)
+        return false;
+    if ((session.envType ?? "cloud") !== envType)
+        return false;
+    if ((session.envName ?? null) !== envName)
+        return false;
+    if (session.repos.length !== repos.length)
+        return false;
+    return session.repos.every((repo, index) => {
+        const next = repos[index];
+        return repo.url === next.url
+            && (repo.startingRef ?? null) === (next.startingRef ?? null)
+            && (repo.prUrl ?? null) === (next.prUrl ?? null);
+    });
+}
+function buildAgentOptions(input) {
+    return {
+        apiKey: input.apiKey,
+        name: input.name,
+        ...(input.model ? { model: input.model } : {}),
+        cloud: {
+            env: {
+                type: input.envType,
+                ...(input.envName ? { name: input.envName } : {}),
+            },
+            repos: input.repos,
+            workOnCurrentBranch: input.workOnCurrentBranch,
+            autoCreatePR: input.autoCreatePR,
+            skipReviewerRequest: input.skipReviewerRequest,
+            envVars: input.envVars,
+        },
+    };
+}
+function eventLine(event) {
+    return `${JSON.stringify(event)}\n`;
+}
+async function emitMessage(onLog, message) {
+    await onLog("stdout", eventLine({ type: "cursor_cloud.message", message }));
+}
+async function emitStatus(onLog, status, message) {
+    await onLog("stdout", eventLine({ type: "cursor_cloud.status", status, ...(message ? { message } : {}) }));
+}
+async function streamRun(run, onLog) {
+    if (!run.supports("stream"))
+        return;
+    for await (const message of run.stream()) {
+        await emitMessage(onLog, message);
+    }
+}
+async function getAttachedRun(input) {
+    const latestRunId = input.session?.latestRunId;
+    const cursorAgentId = input.session?.cursorAgentId;
+    if (!latestRunId || !cursorAgentId)
+        return null;
+    try {
+        const run = await Agent.getRun(latestRunId, {
+            runtime: "cloud",
+            agentId: cursorAgentId,
+            apiKey: input.apiKey,
+        });
+        return run.status === "running" ? run : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function execute(ctx) {
+    const { runId, agent, runtime, config, context, onLog, onMeta } = ctx;
+    const envConfig = asStringEnvMap(config.env);
+    const apiKey = asString(envConfig.CURSOR_API_KEY, "").trim();
+    if (!apiKey) {
+        return {
+            exitCode: 1,
+            signal: null,
+            timedOut: false,
+            errorMessage: "CURSOR_API_KEY is required for cursor_cloud.",
+            provider: "cursor",
+            biller: "cursor",
+            billingType: "api",
+            clearSession: false,
+        };
+    }
+    const workspace = parseObject(context.paperclipWorkspace);
+    const repoUrl = asString(config.repoUrl, "").trim() ||
+        asString(workspace.repoUrl, "").trim();
+    if (!repoUrl) {
+        return {
+            exitCode: 1,
+            signal: null,
+            timedOut: false,
+            errorMessage: "cursor_cloud requires repoUrl in adapterConfig or workspace context.",
+            provider: "cursor",
+            biller: "cursor",
+            billingType: "api",
+            clearSession: false,
+        };
+    }
+    const repoStartingRef = trimNullable(config.repoStartingRef) ??
+        trimNullable(workspace.repoRef) ??
+        undefined;
+    const repoPullRequestUrl = trimNullable(config.repoPullRequestUrl) ?? undefined;
+    const envType = normalizeEnvType(asString(config.runtimeEnvType, "cloud"));
+    const envName = trimNullable(config.runtimeEnvName);
+    const workOnCurrentBranch = asBoolean(config.workOnCurrentBranch, false);
+    const autoCreatePR = asBoolean(config.autoCreatePR, false);
+    const skipReviewerRequest = asBoolean(config.skipReviewerRequest, false);
+    const model = toModelSelection(asString(config.model, ""));
+    const repos = [{
+            url: repoUrl,
+            ...(repoStartingRef ? { startingRef: repoStartingRef } : {}),
+            ...(repoPullRequestUrl ? { prUrl: repoPullRequestUrl } : {}),
+        }];
+    const remoteEnv = buildWakeEnv(ctx, envConfig);
+    const session = readSession(runtime.sessionParams) ?? (runtime.sessionId
+        ? {
+            cursorAgentId: runtime.sessionId,
+            runtime: "cloud",
+            repos,
+        }
+        : null);
+    const canReuseSession = sessionMatches(session, envType, envName, repos);
+    const promptTemplate = asString(config.promptTemplate, DEFAULT_PAPERCLIP_AGENT_PROMPT_TEMPLATE);
+    const bootstrapPromptTemplate = asString(config.bootstrapPromptTemplate, "");
+    const templateData = {
+        agentId: agent.id,
+        companyId: agent.companyId,
+        runId,
+        company: { id: agent.companyId },
+        agent,
+        run: { id: runId, source: "on_demand" },
+        context,
+    };
+    const instructions = await buildInstructionsPrefix(config, onLog);
+    const wakePrompt = renderPaperclipWakePrompt(context.paperclipWake, { resumedSession: canReuseSession });
+    const renderedBootstrapPrompt = !canReuseSession && bootstrapPromptTemplate.trim().length > 0
+        ? renderTemplate(bootstrapPromptTemplate, templateData).trim()
+        : "";
+    const renderedPrompt = canReuseSession && wakePrompt.length > 0
+        ? ""
+        : renderTemplate(promptTemplate, templateData).trim();
+    const paperclipEnvNote = renderPaperclipEnvNote(remoteEnv);
+    const prompt = joinPromptSections([
+        instructions.prefix,
+        renderedBootstrapPrompt,
+        wakePrompt,
+        paperclipEnvNote,
+        renderedPrompt,
+    ]);
+    const sessionHandoffNote = asString(context.paperclipSessionHandoffMarkdown, "").trim();
+    const finalPrompt = joinPromptSections([prompt, sessionHandoffNote]);
+    const agentOptions = buildAgentOptions({
+        apiKey,
+        name: `Paperclip ${agent.name}`,
+        model,
+        envType,
+        envName,
+        repos,
+        workOnCurrentBranch,
+        autoCreatePR,
+        skipReviewerRequest,
+        envVars: remoteEnv,
+    });
+    const commandNotes = [
+        ...instructions.notes,
+        canReuseSession
+            ? `Reusing Cursor cloud agent session ${session?.cursorAgentId ?? "unknown"}`
+            : "Creating a new Cursor cloud agent session",
+        `Repository: ${repoUrl}${repoStartingRef ? ` @ ${repoStartingRef}` : ""}`,
+        `Runtime target: ${envType}${envName ? ` (${envName})` : ""}`,
+    ];
+    if (onMeta) {
+        const meta = {
+            adapterType: "cursor_cloud",
+            command: "@cursor/sdk",
+            commandNotes,
+            prompt: finalPrompt,
+            promptMetrics: {
+                promptChars: finalPrompt.length,
+                instructionsChars: instructions.chars,
+                bootstrapPromptChars: renderedBootstrapPrompt.length,
+                wakePromptChars: wakePrompt.length,
+                heartbeatPromptChars: renderedPrompt.length,
+            },
+            context: {
+                cursorCloud: {
+                    envType,
+                    envName,
+                    repoUrl,
+                    repoStartingRef,
+                    repoPullRequestUrl,
+                    canReuseSession,
+                },
+            },
+        };
+        await onMeta(meta);
+    }
+    let sdkAgent = null;
+    let run = null;
+    let streamError = null;
+    try {
+        const attachedRun = canReuseSession
+            ? await getAttachedRun({ apiKey, session })
+            : null;
+        if (attachedRun) {
+            await emitStatus(onLog, "running", `Reattached to existing Cursor run ${attachedRun.id}.`);
+            await onLog("stdout", eventLine({
+                type: "cursor_cloud.init",
+                sessionId: attachedRun.agentId,
+                agentId: attachedRun.agentId,
+                runId: attachedRun.id,
+                ...(model?.id ? { model: model.id } : {}),
+            }));
+            const priorStreamPromise = streamRun(attachedRun, onLog).catch((err) => {
+                streamError = formatRunError(err);
+            });
+            if (attachedRun.supports("wait"))
+                await attachedRun.wait();
+            await priorStreamPromise;
+            streamError = null;
+            await emitStatus(onLog, "running", `Prior Cursor run ${attachedRun.id} finished; sending heartbeat follow-up so this wake's context is not dropped.`);
+        }
+        sdkAgent = canReuseSession && session
+            ? await Agent.resume(session.cursorAgentId, agentOptions)
+            : await Agent.create(agentOptions);
+        run = await sdkAgent.send(finalPrompt, {
+            ...(model ? { model } : {}),
+        });
+        await onLog("stdout", eventLine({
+            type: "cursor_cloud.init",
+            sessionId: sdkAgent.agentId,
+            agentId: sdkAgent.agentId,
+            runId: run.id,
+            ...(model?.id ? { model: model.id } : {}),
+        }));
+        await emitStatus(onLog, "running", `Started Cursor run ${run.id}.`);
+        const streamPromise = streamRun(run, onLog).catch((err) => {
+            streamError = formatRunError(err);
+        });
+        const result = run.supports("wait")
+            ? await run.wait()
+            : {
+                id: run.id,
+                status: run.status === "running" ? "error" : run.status,
+                result: run.result,
+                model: run.model,
+                durationMs: run.durationMs,
+                git: run.git,
+            };
+        await streamPromise;
+        const modelId = result.model?.id ?? model?.id ?? null;
+        await onLog("stdout", eventLine({
+            type: "cursor_cloud.result",
+            status: result.status,
+            ...(result.result ? { result: result.result } : {}),
+            ...(modelId ? { model: modelId } : {}),
+            ...(typeof result.durationMs === "number" ? { durationMs: result.durationMs } : {}),
+            ...(result.git ? { git: result.git } : {}),
+            ...(streamError ? { error: streamError } : {}),
+        }));
+        const nextSession = {
+            cursorAgentId: run.agentId,
+            latestRunId: result.id,
+            runtime: "cloud",
+            envType,
+            ...(envName ? { envName } : {}),
+            repos,
+        };
+        const isError = result.status !== "finished";
+        return {
+            exitCode: isError ? 1 : 0,
+            signal: null,
+            timedOut: false,
+            errorMessage: isError ? (trimNullable(result.result) ?? streamError ?? `Cursor run ${result.status}`) : null,
+            sessionId: run.agentId,
+            sessionDisplayId: run.agentId,
+            sessionParams: nextSession,
+            provider: "cursor",
+            biller: "cursor",
+            billingType: "api",
+            model: modelId,
+            costUsd: null,
+            summary: toSummary(result),
+            resultJson: {
+                status: result.status,
+                cursorAgentId: run.agentId,
+                cursorRunId: result.id,
+                envType,
+                envName,
+                repos,
+                ...(result.result ? { result: result.result } : {}),
+                ...(result.git ? { git: result.git } : {}),
+                ...(typeof result.durationMs === "number" ? { durationMs: result.durationMs } : {}),
+                ...(streamError ? { streamError } : {}),
+            },
+            clearSession: false,
+        };
+    }
+    catch (err) {
+        const reason = formatRunError(err);
+        if (run) {
+            await onLog("stdout", eventLine({
+                type: "cursor_cloud.result",
+                status: "error",
+                error: reason,
+            }));
+        }
+        return {
+            exitCode: 1,
+            signal: null,
+            timedOut: false,
+            errorMessage: reason,
+            sessionId: session?.cursorAgentId ?? null,
+            sessionDisplayId: session?.cursorAgentId ?? null,
+            sessionParams: session,
+            provider: "cursor",
+            biller: "cursor",
+            billingType: "api",
+            costUsd: null,
+            clearSession: false,
+            resultJson: {
+                status: "error",
+                ...(run ? { cursorRunId: run.id } : {}),
+                ...(session?.cursorAgentId ? { cursorAgentId: session.cursorAgentId } : {}),
+                error: reason,
+            },
+        };
+    }
+    finally {
+        if (sdkAgent) {
+            try {
+                await sdkAgent[Symbol.asyncDispose]();
+            }
+            catch {
+                // Best effort only.
+            }
+        }
+    }
+}
+//# sourceMappingURL=execute.js.map