@agentproto/adapter-claude-code-cloud 0.0.0-stage → 0.2.0

package/dist/chunk-RSQRK7X6.mjs

@@ -0,0 +1,855 @@
+import { Writable, Readable } from 'stream';
+import { PROTOCOL_VERSION, ndJsonStream, AgentSideConnection } from '@agentclientprotocol/sdk';
+import { sdkMessageToUpdates, promptText } from '@agentproto/adapter-claude-sdk';
+export { promptText } from '@agentproto/adapter-claude-sdk';
+import { execFile, spawn } from 'child_process';
+import { ANTHROPIC_CORE_SCRUB_ENV } from '@agentproto/provider-presets';
+import { readFile, mkdir, writeFile, rename } from 'fs/promises';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+import { promisify } from 'util';
+
+/**
+ * @agentproto/adapter-claude-code-cloud v0.1.0
+ * AIP-66 managed cloud agent adapter: Claude Code cloud sessions behind ACP.
+ */
+
+var execFileAsync = promisify(execFile);
+var KEYCHAIN_SERVICE = "Claude Code-credentials";
+function keychainCredentialSource(deps = {}) {
+  const execFileImpl = deps.execFileImpl ?? (async (cmd, args) => {
+    const { stdout } = await execFileAsync(cmd, args, {
+      // `security` writes the secret to stdout only; maxBuffer covers a
+      // long JSON blob. Never `echo` it anywhere else.
+      maxBuffer: 1 << 20
+    });
+    return { stdout };
+  });
+  const readFileSyncImpl = deps.readFileSyncImpl ?? ((path) => readFile(path, "utf8"));
+  const home = deps.homedir ?? homedir;
+  let cached = null;
+  return {
+    async get() {
+      if (cached) return cached;
+      const { stdout } = await execFileImpl("security", [
+        "find-generic-password",
+        "-s",
+        KEYCHAIN_SERVICE,
+        "-w"
+      ]);
+      const keychain = JSON.parse(stdout);
+      const accessToken = keychain.claudeAiOauth?.accessToken;
+      if (!accessToken) {
+        throw new Error(
+          "claude code cloud: no claudeAiOauth.accessToken in the Claude Code keychain entry \u2014 run `claude auth login`"
+        );
+      }
+      let orgUuid;
+      try {
+        const rc = JSON.parse(
+          await readFileSyncImpl(join(home(), ".claude.json"))
+        );
+        orgUuid = rc.oauthAccount?.organizationUuid;
+      } catch {
+      }
+      cached = { accessToken, ...orgUuid ? { orgUuid } : {} };
+      return cached;
+    }
+  };
+}
+function envCredentialSource(env = process.env) {
+  return {
+    async get() {
+      const accessToken = env.CLAUDE_CLOUD_OAUTH_TOKEN;
+      if (!accessToken) {
+        throw new Error(
+          "claude code cloud: CLAUDE_CLOUD_OAUTH_TOKEN is not set \u2014 run `claude auth login` and use the keychain credential source, or inject the token"
+        );
+      }
+      const orgUuid = env.CLAUDE_CLOUD_ORG_UUID;
+      return { accessToken, ...orgUuid ? { orgUuid } : {} };
+    }
+  };
+}
+function eventSequence(event) {
+  const raw = event.sequence_num;
+  if (typeof raw !== "string" || raw.trim() === "") return null;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : null;
+}
+function normalizeSessionId(id) {
+  const trimmed = id.trim();
+  if (trimmed.startsWith("session_")) return `cse_${trimmed.slice("session_".length)}`;
+  if (trimmed.startsWith("cse_")) return trimmed;
+  throw new Error(
+    `claude code cloud: unrecognized session id ${JSON.stringify(id)} \u2014 expected session_<id> or cse_<id>`
+  );
+}
+function toCliSessionId(id) {
+  const normalized = normalizeSessionId(id);
+  return `session_${normalized.slice("cse_".length)}`;
+}
+var UNAUTHORIZED_HINT = "run `claude auth login`";
+var SessionsApi = class {
+  #credentials;
+  #fetch;
+  #baseUrl;
+  #credential = null;
+  constructor(options) {
+    this.#credentials = options.credentials;
+    this.#fetch = options.fetchImpl ?? globalThis.fetch.bind(globalThis);
+    this.#baseUrl = (options.baseUrl ?? "https://api.anthropic.com").replace(/\/$/, "");
+  }
+  /** GET /v1/code/sessions/{id} */
+  async getSession(id) {
+    return this.#request(
+      "GET",
+      `/v1/code/sessions/${normalizeSessionId(id)}`
+    );
+  }
+  /**
+   * GET /v1/code/sessions/{id}/events — newest first. With no `cursor` this
+   * returns the NEWEST page; pass the page's `resume_cursor` (the oldest
+   * event's `sequence_num`) as `cursor` to fetch the next OLDER page.
+   */
+  async listEvents(id, opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.cursor) params.set("cursor", opts.cursor);
+    if (opts.limit !== void 0) params.set("limit", String(opts.limit));
+    const qs = params.toString();
+    return this.#request(
+      "GET",
+      `/v1/code/sessions/${normalizeSessionId(id)}/events${qs ? `?${qs}` : ""}`
+    );
+  }
+  /** GET /v1/code/sessions?limit=N */
+  async listSessions(opts = {}) {
+    const qs = opts.limit !== void 0 ? `?limit=${opts.limit}` : "";
+    return this.#request(
+      "GET",
+      `/v1/code/sessions${qs}`
+    );
+  }
+  async #credentialNow() {
+    if (!this.#credential) this.#credential = await this.#credentials.get();
+    return this.#credential;
+  }
+  async #request(method, path, retriedAuth = false) {
+    const credential = await this.#credentialNow();
+    const headers = {
+      authorization: `Bearer ${credential.accessToken}`,
+      "anthropic-version": "2023-06-01",
+      "content-type": "application/json",
+      ...credential.orgUuid ? { "x-organization-uuid": credential.orgUuid } : {}
+    };
+    const res = await this.#fetch(`${this.#baseUrl}${path}`, { method, headers });
+    if (res.status === 401 && !retriedAuth) {
+      this.#credential = null;
+      return this.#request(method, path, true);
+    }
+    if (res.status === 401) {
+      throw new Error(`claude code cloud: unauthorized (401) \u2014 ${UNAUTHORIZED_HINT}`);
+    }
+    if (!res.ok) {
+      throw new Error(
+        `claude code cloud: ${method} ${path} failed: HTTP ${res.status}`
+      );
+    }
+    return await res.json();
+  }
+};
+
+// src/cli.ts
+var CLAUDE_CODE_CLOUD_TOGGLES = [
+  "CLAUDE_CODE_USE_BEDROCK",
+  "CLAUDE_CODE_USE_VERTEX",
+  "CLAUDE_CODE_USE_FOUNDRY",
+  "CLAUDE_CODE_USE_ANTHROPIC_AWS",
+  "CLAUDE_CODE_USE_MANTLE",
+  "CLAUDE_CODE_USE_GATEWAY"
+];
+var CLAUDE_CODE_GATEWAY_ENV_UNSET = [
+  ...ANTHROPIC_CORE_SCRUB_ENV,
+  ...CLAUDE_CODE_CLOUD_TOGGLES
+];
+function cloudChildEnv(base = process.env) {
+  const out = {};
+  const drop = new Set(CLAUDE_CODE_GATEWAY_ENV_UNSET);
+  for (const [key, value] of Object.entries(base)) {
+    if (value === void 0 || drop.has(key)) continue;
+    out[key] = value;
+  }
+  return out;
+}
+var DEFAULT_RUN_TIMEOUT_MS = 6e4;
+function defaultCloudCliRunner() {
+  return {
+    run(cmd, args, opts) {
+      return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+          cwd: opts.cwd,
+          env: opts.env,
+          stdio: [opts.stdin === "ignore" ? "ignore" : "inherit", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        const timer = setTimeout(() => {
+          child.kill("SIGKILL");
+          reject(
+            new Error(
+              `claude code cloud: \`${cmd} ${args.join(" ")}\` timed out after ${opts.timeoutMs ?? DEFAULT_RUN_TIMEOUT_MS}ms`
+            )
+          );
+        }, opts.timeoutMs ?? DEFAULT_RUN_TIMEOUT_MS);
+        timer.unref?.();
+        child.stdout?.on("data", (d) => stdout += d.toString());
+        child.stderr?.on("data", (d) => stderr += d.toString());
+        child.on("error", (err) => {
+          clearTimeout(timer);
+          reject(err);
+        });
+        child.on("close", (code) => {
+          clearTimeout(timer);
+          resolve({ code: code ?? -1, stdout, stderr });
+        });
+      });
+    },
+    runPty(cmd, args, opts) {
+      let resolveResult;
+      let rejectResult;
+      const result = new Promise((res, rej) => {
+        resolveResult = res;
+        rejectResult = rej;
+      });
+      let proc = null;
+      const pendingWrites = [];
+      void import('node-pty').then((mod) => {
+        const pty = mod.default ?? mod;
+        if (typeof pty.spawn !== "function") throw new Error("node-pty has no spawn");
+        const p = pty.spawn(cmd, args, {
+          name: "xterm-256color",
+          cols: 120,
+          rows: 40,
+          cwd: opts.cwd,
+          env: opts.env
+        });
+        proc = p;
+        for (const data of pendingWrites) p.write(data);
+        pendingWrites.length = 0;
+        let output = "";
+        let answeredTrustPrompt = false;
+        p.onData((chunk) => {
+          output += chunk;
+          opts.onData?.(chunk);
+          if (!answeredTrustPrompt && /Yes, I trust this folder/.test(output)) {
+            answeredTrustPrompt = true;
+            p.write("\x1B[B\r");
+          }
+        });
+        const timer = setTimeout(() => {
+          try {
+            p.kill("SIGKILL");
+          } catch {
+          }
+          rejectResult(
+            new Error(
+              `claude code cloud: \`${cmd} ${args.join(" ")}\` timed out after ${opts.timeoutMs ?? 12e4}ms under the PTY`
+            )
+          );
+        }, opts.timeoutMs ?? 12e4);
+        timer.unref?.();
+        p.onExit(({ exitCode }) => {
+          clearTimeout(timer);
+          resolveResult({ code: exitCode, output });
+        });
+      }).catch((err) => {
+        rejectResult(
+          new Error(
+            `claude code cloud: \`claude --cloud\` needs a real PTY and node-pty is not available (${err instanceof Error ? err.message : String(err)}) \u2014 install it (npm i node-pty) to use managed cloud sessions`
+          )
+        );
+      });
+      return {
+        write: (data) => {
+          if (proc) proc.write(data);
+          else pendingWrites.push(data);
+        },
+        result
+      };
+    }
+  };
+}
+function parseAuthStatus(stdout) {
+  const trimmed = stdout.trim();
+  const start = trimmed.indexOf("{");
+  const end = trimmed.lastIndexOf("}");
+  if (start === -1 || end === -1 || end < start) {
+    throw new Error(
+      "claude code cloud: could not parse `claude auth status` output \u2014 run `claude auth login`"
+    );
+  }
+  const parsed = JSON.parse(trimmed.slice(start, end + 1));
+  return { loggedIn: parsed.loggedIn === true, authMethod: parsed.authMethod };
+}
+async function preflightAuth(runner, opts) {
+  let result;
+  try {
+    result = await runner.run("claude", ["auth", "status"], {
+      cwd: opts.cwd,
+      env: opts.env,
+      timeoutMs: 15e3,
+      stdin: "ignore"
+    });
+  } catch (err) {
+    throw new Error(
+      `claude code cloud: could not run \`claude auth status\` \u2014 is the claude CLI installed and on PATH? (${err instanceof Error ? err.message : String(err)})`
+    );
+  }
+  if (result.code !== 0 && !result.stdout.trim()) {
+    throw new Error(
+      "claude code cloud: `claude auth status` failed \u2014 the claude CLI is not usable; run `claude auth login`"
+    );
+  }
+  const status = parseAuthStatus(result.stdout);
+  if (!status.loggedIn) {
+    throw new Error(
+      "claude code cloud: not logged in \u2014 cloud sessions need a claude.ai sign-in; run `claude auth login`"
+    );
+  }
+  if (status.authMethod === "api_key") {
+    throw new Error(
+      "claude code cloud: authenticated by API key \u2014 cloud sessions need a claude.ai sign-in; run `claude auth login`"
+    );
+  }
+  return status;
+}
+function parseCloudStartOutput(output) {
+  let sessionId;
+  let url;
+  let title;
+  const resume = output.match(/Resume with:\s*claude\s+--teleport\s+(session_[A-Za-z0-9_-]+)/);
+  if (resume?.[1]) sessionId = resume[1];
+  const view = output.match(/View:\s*(https?:\/\/\S+)/);
+  if (view?.[1]) {
+    url = view[1];
+    if (!sessionId) {
+      const fromUrl = url.match(/\/session_([A-Za-z0-9_-]+)/);
+      if (fromUrl?.[1]) sessionId = `session_${fromUrl[1]}`;
+    }
+  }
+  const created = output.match(/Created cloud session:\s*(.+)/);
+  if (created?.[1]) title = created[1].trim();
+  if (!sessionId) return null;
+  return {
+    sessionId,
+    url: url ?? `https://claude.ai/code/${sessionId}`,
+    ...title ? { title } : {}
+  };
+}
+async function startCloudSession(prompt, opts) {
+  const runner = opts.runner ?? defaultCloudCliRunner();
+  const env = cloudChildEnv(opts.env ?? process.env);
+  if (!opts.skipPreflight) await preflightAuth(runner, { cwd: opts.cwd, env });
+  const pty = runner.runPty("claude", ["--cloud", prompt], {
+    cwd: opts.cwd,
+    env,
+    timeoutMs: opts.timeoutMs ?? 12e4
+  });
+  const { code, output } = await pty.result;
+  if (code !== 0) {
+    throw new Error(
+      `claude code cloud: \`claude --cloud\` exited ${code}: ${output.trim().split("\n").slice(-5).join("\n").trim()}`
+    );
+  }
+  const started = parseCloudStartOutput(output);
+  if (!started) {
+    throw new Error(
+      "claude code cloud: could not parse a cloud session id from `claude --cloud` output"
+    );
+  }
+  return started;
+}
+async function sendPrompt(sessionId, text, opts) {
+  const runner = opts.runner ?? defaultCloudCliRunner();
+  const env = cloudChildEnv(opts.env ?? process.env);
+  if (!opts.skipPreflight) await preflightAuth(runner, { cwd: opts.cwd, env });
+  const result = await runner.run(
+    "claude",
+    ["-p", text, "--cloud", toCliSessionId(sessionId)],
+    {
+      cwd: opts.cwd,
+      env,
+      stdin: "ignore",
+      timeoutMs: opts.timeoutMs ?? 6e4
+    }
+  );
+  if (result.code !== 0) {
+    throw new Error(
+      `claude code cloud: \`claude -p --cloud\` exited ${result.code}: ${(result.stderr || result.stdout).trim().split("\n").slice(-5).join("\n").trim()}`
+    );
+  }
+  return { stdout: result.stdout };
+}
+var CLOUD_SESSION_META_FILE_ENV = "AGENTPROTO_CLOUD_SESSION_META_FILE";
+var CLOUD_VENDOR_SLUG = "anthropic";
+async function readExisting(path) {
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+    const p = parsed;
+    if (typeof p["vendor"] !== "string" || p["vendor"].length === 0) return void 0;
+    if (typeof p["sessionId"] !== "string" || p["sessionId"].length === 0) return void 0;
+    return {
+      vendor: p["vendor"],
+      sessionId: p["sessionId"],
+      ...typeof p["url"] === "string" && p["url"].length > 0 ? { url: p["url"] } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function writeCloudSessionMeta(meta, opts = {}) {
+  const env = opts.env ?? process.env;
+  const path = env[CLOUD_SESSION_META_FILE_ENV];
+  if (!path) return null;
+  try {
+    const existing = await readExisting(path);
+    const url = meta.url ?? (existing?.sessionId === meta.sessionId ? existing.url : void 0);
+    const payload = JSON.stringify({
+      vendor: meta.vendor,
+      sessionId: meta.sessionId,
+      ...url !== void 0 ? { url } : {}
+    });
+    await mkdir(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.tmp`;
+    await writeFile(tmp, payload, "utf8");
+    await rename(tmp, path);
+    return path;
+  } catch (err) {
+    process.stderr.write(
+      `[claude-code-cloud] could not write the cloud session meta file (${CLOUD_SESSION_META_FILE_ENV}): ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+var execFileAsync2 = promisify(execFile);
+var defaultGitRunner = async (args, cwd) => {
+  try {
+    const { stdout, stderr } = await execFileAsync2("git", args, { cwd });
+    return { code: 0, stdout, stderr };
+  } catch (err) {
+    const e = err;
+    return {
+      code: typeof e.code === "number" ? e.code : 1,
+      stdout: e.stdout ?? "",
+      stderr: e.stderr ?? ""
+    };
+  }
+};
+async function validateRepoSource(cwd, git = defaultGitRunner) {
+  const inside = await git(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside.code !== 0 || inside.stdout.trim() !== "true") {
+    throw new Error(
+      `claude code cloud: ${cwd} is not a git checkout \u2014 managed cloud agents run on a git remote and ref (AIP-66 \xA73)`
+    );
+  }
+  const status = await git(["status", "--porcelain"], cwd);
+  if (status.code !== 0) {
+    throw new Error(
+      `claude code cloud: could not read the working tree status in ${cwd} (${status.stderr.trim() || `git status exited ${status.code}`})`
+    );
+  }
+  if (status.stdout.trim().length > 0) {
+    throw new Error(
+      `claude code cloud: the working tree in ${cwd} is dirty \u2014 commit or stash first; the vendor refuses to upload uncommitted files (AIP-66 \xA73)`
+    );
+  }
+  const remote = await git(["remote", "get-url", "origin"], cwd);
+  if (remote.code !== 0 || !remote.stdout.trim()) {
+    throw new Error(
+      `claude code cloud: ${cwd} has no origin remote \u2014 a managed cloud agent runs on the repo's remote, not a local path (AIP-66 \xA73)`
+    );
+  }
+  const head = await git(["rev-parse", "HEAD"], cwd);
+  if (head.code !== 0 || !head.stdout.trim()) {
+    throw new Error(
+      `claude code cloud: could not resolve HEAD in ${cwd} (${head.stderr.trim() || `git rev-parse HEAD exited ${head.code}`})`
+    );
+  }
+  const contains = await git(["branch", "-r", "--contains", "HEAD"], cwd);
+  if (contains.code !== 0 || !contains.stdout.trim()) {
+    throw new Error(
+      `claude code cloud: HEAD in ${cwd} is not reachable from origin \u2014 push the commit before starting a cloud session (AIP-66 \xA73)`
+    );
+  }
+}
+
+// src/acp-server.ts
+var POLL_INITIAL_MS = 2e3;
+var POLL_MAX_MS = 1e4;
+var MAX_LIST_EVENTS_FAILURES = 5;
+var OBSERVE_PAGES_LIMIT = 20;
+var NETWORK_ERROR_CODES = /^(ECONNABORTED|ECONNREFUSED|ECONNRESET|EHOSTUNREACH|ENETUNREACH|EAI_AGAIN|ENOTFOUND|EPIPE|ETIMEDOUT|UND_ERR)/;
+function isTransientListEventsError(err) {
+  if (!(err instanceof Error)) return false;
+  if (/\bHTTP 5\d\d\b/.test(err.message)) return true;
+  if (/fetch failed|network error|socket hang up/i.test(err.message)) return true;
+  let cause = err;
+  for (let depth = 0; depth < 4 && cause; depth += 1) {
+    const code = cause.code;
+    if (typeof code === "string" && NETWORK_ERROR_CODES.test(code)) return true;
+    cause = cause.cause;
+  }
+  return false;
+}
+function defaultSleep(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+function defaultDeps() {
+  const runner = defaultCloudCliRunner();
+  const credentials = keychainCredentialSource();
+  return {
+    api: new SessionsApi({ credentials }),
+    cli: {
+      startCloudSession: (prompt, opts) => startCloudSession(prompt, {
+        cwd: opts.cwd,
+        runner,
+        env: process.env
+      }),
+      sendPrompt: (id, text, opts) => sendPrompt(id, text, {
+        cwd: opts.cwd,
+        runner,
+        env: process.env
+      })
+    },
+    validateRepo: (cwd) => validateRepoSource(cwd)
+  };
+}
+function resultEventUpdates(payload) {
+  const p = payload ?? {};
+  const hasUsage = p.usage != null || typeof p.total_cost_usd === "number";
+  if (!hasUsage) return [];
+  const normalized = {
+    ...p,
+    type: "result",
+    modelUsage: p.modelUsage ?? {},
+    usage: p.usage ?? { input_tokens: 0, output_tokens: 0 }
+  };
+  return sdkMessageToUpdates(normalized).filter(
+    (u) => u.sessionUpdate === "usage_update"
+  );
+}
+function resultStopReason(payload) {
+  const p = payload ?? {};
+  if (p.is_error === true) return "refusal";
+  if (p.subtype !== void 0 && p.subtype !== "success") return "refusal";
+  return "end_turn";
+}
+function errorResultText(payload) {
+  const p = payload ?? {};
+  if (typeof p.result === "string" && p.result.trim()) return p.result;
+  return null;
+}
+var ClaudeCloudAcpAgent = class {
+  #conn;
+  #api;
+  #cli;
+  #validateRepo;
+  #sleep;
+  #pollInitialMs;
+  #pollMaxMs;
+  #sessions = /* @__PURE__ */ new Map();
+  constructor(conn, deps = {}) {
+    const defaults = defaultDeps();
+    this.#conn = conn;
+    this.#api = deps.api ?? defaults.api;
+    this.#cli = deps.cli ?? defaults.cli;
+    this.#validateRepo = deps.validateRepo ?? defaults.validateRepo;
+    this.#sleep = deps.sleep ?? defaultSleep;
+    this.#pollInitialMs = deps.pollInitialMs ?? POLL_INITIAL_MS;
+    this.#pollMaxMs = deps.pollMaxMs ?? POLL_MAX_MS;
+  }
+  async initialize(_params) {
+    return {
+      protocolVersion: PROTOCOL_VERSION,
+      agentCapabilities: {
+        // Re-attach rides ACP `session/load` with the vendor session id the
+        // host persisted on `meta.cloud.sessionId` (AIP-66 §5) — that call
+        // ADOPTS the existing cloud session, it never starts a new one.
+        loadSession: true
+      }
+    };
+  }
+  async authenticate() {
+  }
+  async newSession(params) {
+    if (params.mcpServers && params.mcpServers.length > 0) {
+      throw new Error(
+        "claude code cloud: mcpServers is not supported for managed cloud agents (AIP-66 \xA74) \u2014 the vendor owns the harness"
+      );
+    }
+    await this.#validateRepo(params.cwd);
+    const id = crypto.randomUUID();
+    this.#sessions.set(id, {
+      id,
+      cwd: params.cwd,
+      vendorSessionId: null,
+      vendorUrl: null,
+      lastSeq: 0,
+      turnBaseline: 0,
+      promptInFlight: false
+    });
+    return { sessionId: id };
+  }
+  /**
+   * AIP-66 §5 re-attach: ADOPT the vendor session id the host persisted on
+   * `meta.cloud.sessionId` as this ACP session's vendor session. No vendor
+   * side effect happens here — the next `session/prompt` goes through
+   * `sendPrompt` (`claude -p … --cloud <id>`), never `startCloudSession`,
+   * so a resumed relay can never replace the vendor's session with a new
+   * one. The adopted id is also reported back to the host's meta file so a
+   * re-attach against a fresh config dir still carries the §5 mapping.
+   *
+   * Fails closed on an id the vendor could never own (e.g. the ACP uuid of
+   * a spawn whose vendor id was never learned): no session is started in
+   * its place.
+   */
+  async loadSession(params) {
+    if (params.mcpServers && params.mcpServers.length > 0) {
+      throw new Error(
+        "claude code cloud: mcpServers is not supported for managed cloud agents (AIP-66 \xA74) \u2014 the vendor owns the harness"
+      );
+    }
+    let vendorSessionId;
+    try {
+      vendorSessionId = toCliSessionId(params.sessionId);
+    } catch {
+      throw new Error(
+        `claude code cloud: session/load needs the vendor session id, got ${JSON.stringify(params.sessionId)} \u2014 expected session_<id> or cse_<id> (AIP-66 \xA75). That id was never learned onto meta.cloud.sessionId, so there is no vendor session to re-attach to \u2014 and this relay will not start a replacement.`
+      );
+    }
+    await this.#validateRepo(params.cwd);
+    const session = {
+      id: vendorSessionId,
+      cwd: params.cwd,
+      vendorSessionId,
+      vendorUrl: null,
+      lastSeq: 0,
+      turnBaseline: 0,
+      promptInFlight: false
+    };
+    this.#sessions.set(vendorSessionId, session);
+    await this.#seedHistory(session, vendorSessionId);
+    await writeCloudSessionMeta({ vendor: CLOUD_VENDOR_SLUG, sessionId: vendorSessionId });
+    return {};
+  }
+  /** Seed `lastSeq` from the vendor's newest events page. Best effort: a
+   *  failed seed degrades to (at worst) an early end on an older `result` —
+   *  it must never turn a re-attach into a failed load, which AIP-66 §5
+   *  forbids replacing with a fresh start anyway.
+   *
+   *  ONE newest-page GET with no cursor: it returns the newest page (newest
+   *  first), so its max `sequence_num` is the history high-water. No
+   *  backward paging is needed — `lastSeq` only has to be high enough that
+   *  the first post-attach poll projects nothing already in the history. */
+  async #seedHistory(session, vendorSessionId) {
+    try {
+      session.lastSeq = await this.#highWaterSeq(vendorSessionId);
+    } catch (err) {
+      process.stderr.write(
+        `[claude-code-cloud] session/load: could not seed the vendor's existing event high-water (${err instanceof Error ? err.message : String(err)})
+`
+      );
+    }
+  }
+  /** Max `sequence_num` on the session's newest events page (0 when the
+   *  page is empty). One newest-page GET, no cursor. */
+  async #highWaterSeq(vendorSessionId) {
+    const res = await this.#api.listEvents(vendorSessionId, {});
+    let max = 0;
+    for (const event of res.data ?? []) {
+      const seq = eventSequence(event);
+      if (seq !== null && seq > max) max = seq;
+    }
+    return max;
+  }
+  /**
+   * Read every event newer than `lastSeq`, in ascending seq order, walking
+   * the API's cursor BACKWARD as far as needed. The API serves the NEWEST
+   * page with no cursor and pages toward OLDER events via `?cursor=<n>`
+   * (sessions-api.ts), so catching up across a >1-page gap means following
+   * `resume_cursor` and collecting the seqs above `lastSeq` until a page
+   * reaches already-projected history. Capped at {@link OBSERVE_PAGES_LIMIT}
+   * pages per call.
+   */
+  async #collectNewEvents(vendorSessionId, lastSeq) {
+    const collected = [];
+    let cursor;
+    for (let page = 0; page < OBSERVE_PAGES_LIMIT; page += 1) {
+      const res = await this.#api.listEvents(
+        vendorSessionId,
+        cursor ? { cursor } : {}
+      );
+      const events = res.data ?? [];
+      let oldest = null;
+      for (const event of events) {
+        const seq = eventSequence(event);
+        if (seq === null) continue;
+        if (oldest === null || seq < oldest) oldest = seq;
+        if (seq > lastSeq) collected.push({ seq, event });
+      }
+      if (events.length === 0 || oldest === null || oldest <= lastSeq + 1) break;
+      const next = res.resume_cursor ?? res.next_cursor;
+      if (!next || next === cursor) break;
+      cursor = next;
+    }
+    collected.sort((a, b) => a.seq - b.seq);
+    return collected;
+  }
+  async prompt(params) {
+    const session = this.#sessions.get(params.sessionId);
+    if (!session) throw new Error(`unknown session ${params.sessionId}`);
+    if (session.promptInFlight) {
+      throw new Error(
+        "claude code cloud: a turn is already in flight \u2014 session/cancel is unsupported (AIP-66 \xA76)"
+      );
+    }
+    session.promptInFlight = true;
+    try {
+      const text = promptText(params);
+      if (!session.vendorSessionId) {
+        const started = await this.#cli.startCloudSession(text, {
+          cwd: session.cwd
+        });
+        session.vendorSessionId = started.sessionId;
+        session.vendorUrl = started.url;
+        await writeCloudSessionMeta({
+          vendor: CLOUD_VENDOR_SLUG,
+          sessionId: started.sessionId,
+          url: started.url
+        });
+        await this.#conn.sessionUpdate({
+          sessionId: session.id,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: {
+              type: "text",
+              text: `[claude-code-cloud] ${started.title ? `${started.title} \u2014 ` : ""}${started.url}`
+            }
+          }
+        });
+        session.turnBaseline = 0;
+      } else {
+        session.turnBaseline = await this.#highWaterSeq(session.vendorSessionId);
+        await this.#cli.sendPrompt(session.vendorSessionId, text, {
+          cwd: session.cwd
+        });
+      }
+      return await this.#observeTurn(session);
+    } finally {
+      session.promptInFlight = false;
+    }
+  }
+  /** Read events until a NEW `result` event ends the turn (AIP-66 §6). */
+  async #observeTurn(session) {
+    const vendorId = session.vendorSessionId;
+    if (!vendorId) throw new Error("claude code cloud: no vendor session");
+    let delay = this.#pollInitialMs;
+    let failures = 0;
+    for (; ; ) {
+      let fresh;
+      try {
+        fresh = await this.#collectNewEvents(vendorId, session.lastSeq);
+      } catch (err) {
+        if (!isTransientListEventsError(err) || failures + 1 >= MAX_LIST_EVENTS_FAILURES) {
+          throw err;
+        }
+        failures += 1;
+        await this.#sleep(delay);
+        delay = Math.min(delay * 2, this.#pollMaxMs);
+        continue;
+      }
+      failures = 0;
+      let stopReason = null;
+      for (const { seq, event } of fresh) {
+        session.lastSeq = Math.max(session.lastSeq, seq);
+        if (event.event_type === "result") {
+          if (resultStopReason(event.payload) === "refusal") {
+            const errText = errorResultText(event.payload);
+            if (errText) {
+              await this.#send(session.id, {
+                sessionUpdate: "agent_message_chunk",
+                content: { type: "text", text: errText }
+              });
+            }
+          }
+          for (const update of resultEventUpdates(event.payload)) {
+            await this.#send(session.id, update);
+          }
+          if (seq > session.turnBaseline) {
+            stopReason = resultStopReason(event.payload);
+          }
+        } else if (event.event_type === "user") {
+          for (const update of sdkMessageToUpdates(
+            event.payload
+          )) {
+            if (update.sessionUpdate === "agent_message_chunk") continue;
+            await this.#send(session.id, update);
+          }
+        } else if (event.event_type === "assistant") {
+          for (const update of sdkMessageToUpdates(
+            event.payload
+          )) {
+            await this.#send(session.id, update);
+          }
+        }
+      }
+      if (stopReason) return { stopReason };
+      await this.#sleep(delay);
+      delay = Math.min(delay * 2, this.#pollMaxMs);
+    }
+  }
+  async #send(sessionId, update) {
+    await this.#conn.sessionUpdate({ sessionId, update });
+  }
+  /** Unsupported: the vendor exposes no interrupt verb (AIP-66 §6). Throwing
+   *  reports it — the in-flight poll loop is NOT aborted (we cannot stop the
+   *  cloud turn; lying "cancelled" would violate §6's end-on-vendor-event
+   *  rule). */
+  async cancel(_params) {
+    throw new Error(
+      "claude code cloud: session/cancel is unsupported \u2014 the vendor exposes no interrupt verb for cloud sessions (AIP-66 \xA76)"
+    );
+  }
+  /** No runtime-configurable options (no model menu — the vendor picks the
+   *  model). Empty set so a host that tries to set one doesn't error. */
+  async setSessionConfigOption(_params) {
+    return { configOptions: [] };
+  }
+  /** No agent-specific modes; accept and ignore. */
+  async setSessionMode(_params) {
+    return {};
+  }
+};
+function runAcpOverStdio(deps = {}) {
+  const toClient = Writable.toWeb(process.stdout);
+  const fromClient = Readable.toWeb(
+    process.stdin
+  );
+  const stream = ndJsonStream(toClient, fromClient);
+  return new AgentSideConnection(
+    (conn) => new ClaudeCloudAcpAgent(conn, deps),
+    stream
+  );
+}
+function main() {
+  runAcpOverStdio();
+}
+
+export { CLAUDE_CODE_GATEWAY_ENV_UNSET, CLOUD_SESSION_META_FILE_ENV, CLOUD_VENDOR_SLUG, ClaudeCloudAcpAgent, MAX_LIST_EVENTS_FAILURES, OBSERVE_PAGES_LIMIT, POLL_INITIAL_MS, POLL_MAX_MS, SessionsApi, cloudChildEnv, defaultCloudCliRunner, defaultGitRunner, envCredentialSource, isTransientListEventsError, keychainCredentialSource, main, normalizeSessionId, parseAuthStatus, parseCloudStartOutput, preflightAuth, resultEventUpdates, resultStopReason, runAcpOverStdio, sendPrompt, startCloudSession, toCliSessionId, validateRepoSource, writeCloudSessionMeta };
+//# sourceMappingURL=chunk-RSQRK7X6.mjs.map
+//# sourceMappingURL=chunk-RSQRK7X6.mjs.map