openpond 0.0.30-bootstrap.0

package/dist/chunks/chunk-XSAXENQD.js

@@ -0,0 +1,4167 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  DEFAULT_OPENPOND_API_BASE_URL,
+  DEFAULT_OPENPOND_WEB_BASE_URL,
+  mapUiBaseToApiBase,
+  resolveBaseUrl,
+  resolveSandboxApiUrlOption
+} from "./chunk-5G4E547X.js";
+import {
+  parseBooleanOption
+} from "./chunk-3Y4EL3P6.js";
+
+// ../../packages/cloud/src/api/core.ts
+var DEFAULT_API_TIMEOUT_MS = 3e4;
+var DEFAULT_API_RESPONSE_BYTES = 8 * 1024 * 1024;
+var LONG_STREAM_API_OPTIONS = { timeoutMs: 15 * 60 * 1e3, maxResponseBytes: 64 * 1024 * 1024 };
+var ApiTimeoutError = class extends Error {
+  constructor(timeoutMs, requestUrl) {
+    super(`API request timed out after ${timeoutMs}ms: ${requestUrl}`);
+    this.timeoutMs = timeoutMs;
+    this.requestUrl = requestUrl;
+    this.name = "ApiTimeoutError";
+  }
+  timeoutMs;
+  requestUrl;
+  code = "OPENPOND_API_TIMEOUT";
+};
+var ApiResponseTooLargeError = class extends Error {
+  constructor(maximumBytes, requestUrl) {
+    super(`API response exceeded ${maximumBytes} bytes: ${requestUrl}`);
+    this.maximumBytes = maximumBytes;
+    this.requestUrl = requestUrl;
+    this.name = "ApiResponseTooLargeError";
+  }
+  maximumBytes;
+  requestUrl;
+  code = "OPENPOND_API_RESPONSE_TOO_LARGE";
+};
+async function apiFetch(baseUrl, token, requestPath, options = {}) {
+  const { timeoutMs = DEFAULT_API_TIMEOUT_MS, maxResponseBytes = DEFAULT_API_RESPONSE_BYTES, ...init } = options;
+  const headers = new Headers(init.headers || {});
+  headers.set("Content-Type", "application/json");
+  const apiKey = process.env.OPENPOND_API_KEY;
+  const trimmedToken = token?.trim() || "";
+  const tokenIsApiKey = trimmedToken.startsWith("opk_");
+  const effectiveApiKey = apiKey || (tokenIsApiKey ? trimmedToken : null);
+  if (effectiveApiKey && !headers.has("openpond-api-key")) headers.set("openpond-api-key", effectiveApiKey);
+  if (token) {
+    headers.set("Authorization", tokenIsApiKey ? `ApiKey ${trimmedToken}` : `Bearer ${token}`);
+  } else if (apiKey && !headers.has("Authorization")) {
+    headers.set("Authorization", `ApiKey ${apiKey}`);
+  }
+  const requestUrl = `${baseUrl}${requestPath}`;
+  const timeoutController = new AbortController();
+  const timeoutError = new ApiTimeoutError(timeoutMs, requestUrl);
+  const timer = timeoutMs > 0 ? setTimeout(() => timeoutController.abort(timeoutError), timeoutMs) : null;
+  timer?.unref?.();
+  const signal = composedSignal(init.signal, timeoutController.signal, timeoutMs);
+  const cleanup = () => {
+    if (timer) clearTimeout(timer);
+  };
+  try {
+    const response = await fetch(requestUrl, { ...init, headers, signal });
+    return boundedResponse(response, {
+      cleanup,
+      maximumBytes: maxResponseBytes,
+      requestUrl,
+      timeoutController,
+      timeoutError
+    });
+  } catch (error) {
+    cleanup();
+    if (timeoutController.signal.aborted) throw timeoutError;
+    throw error;
+  }
+}
+async function readApiJson(response, label) {
+  let payload;
+  try {
+    const text = await response.text();
+    payload = text ? JSON.parse(text) : {};
+  } catch (error) {
+    if (error instanceof ApiTimeoutError || error instanceof ApiResponseTooLargeError) throw error;
+    payload = {};
+  }
+  if (!response.ok) {
+    const message = typeof payload.message === "string" ? payload.message : typeof payload.error === "string" ? payload.error : "";
+    throw new Error(`${label} failed: ${response.status}${message ? ` ${message}` : ""}`);
+  }
+  return payload;
+}
+function boundedResponse(response, input3) {
+  if (!response.body) {
+    input3.cleanup();
+    return response;
+  }
+  const contentLength = Number(response.headers.get("content-length"));
+  if (input3.maximumBytes > 0 && Number.isFinite(contentLength) && contentLength > input3.maximumBytes) {
+    input3.cleanup();
+    void response.body.cancel();
+    throw new ApiResponseTooLargeError(input3.maximumBytes, input3.requestUrl);
+  }
+  const reader = response.body.getReader();
+  let receivedBytes = 0;
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const result = await reader.read();
+        if (result.done) {
+          input3.cleanup();
+          controller.close();
+          return;
+        }
+        receivedBytes += result.value.byteLength;
+        if (input3.maximumBytes > 0 && receivedBytes > input3.maximumBytes) {
+          input3.cleanup();
+          await reader.cancel();
+          controller.error(new ApiResponseTooLargeError(input3.maximumBytes, input3.requestUrl));
+          return;
+        }
+        controller.enqueue(result.value);
+      } catch (error) {
+        input3.cleanup();
+        controller.error(input3.timeoutController.signal.aborted ? input3.timeoutError : error);
+      }
+    },
+    async cancel(reason) {
+      input3.cleanup();
+      await reader.cancel(reason);
+    }
+  });
+  return new Response(body, {
+    headers: response.headers,
+    status: response.status,
+    statusText: response.statusText
+  });
+}
+function composedSignal(callerSignal, timeoutSignal, timeoutMs) {
+  if (timeoutMs <= 0) return callerSignal ?? void 0;
+  return callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal;
+}
+
+// ../../packages/cloud/src/api/deployments.ts
+async function deployApp(baseUrl, token, appId, input3) {
+  const environment = input3?.environment ?? "production";
+  const response = await apiFetch(
+    baseUrl,
+    token,
+    `/v4/apps/${appId}/deployments`,
+    {
+      method: "POST",
+      body: JSON.stringify({
+        environment,
+        ...input3?.commitSha ? { commitSha: input3.commitSha } : {},
+        ...input3?.branch ? { branch: input3.branch } : {}
+      })
+    }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Deploy failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function getDeploymentLogs(apiBase, token, deploymentId) {
+  const response = await apiFetch(
+    apiBase,
+    token,
+    `/apps/deployments/${deploymentId}/logs`,
+    { method: "GET" }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Deployment logs failed: ${response.status} ${text}`);
+  }
+  const payload = await response.json().catch(() => ({}));
+  const logs = Array.isArray(payload.logs) ? payload.logs : [];
+  return logs.map((log) => {
+    const createdAt = typeof log.createdAt === "string" ? log.createdAt : log.createdAt instanceof Date ? log.createdAt.toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      id: typeof log.id === "string" ? log.id : `${Math.random()}`,
+      type: typeof log.type === "string" ? log.type : void 0,
+      message: typeof log.message === "string" ? log.message : "",
+      createdAt
+    };
+  });
+}
+async function getDeploymentStatus(apiBase, token, deploymentId) {
+  const response = await apiFetch(
+    apiBase,
+    token,
+    `/apps/deployments/${deploymentId}/status`,
+    { method: "GET" }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Deployment status failed: ${response.status} ${text}`);
+  }
+  const payload = await response.json().catch(() => ({}));
+  return { status: payload.deployment?.status };
+}
+async function getLatestDeploymentForApp(apiBase, token, appId, options) {
+  const params = new URLSearchParams();
+  if (options?.status && options.status.length > 0) {
+    params.set("status", options.status.join(","));
+  }
+  if (options?.createdAfter) {
+    params.set("createdAfter", options.createdAfter);
+  }
+  if (options?.branch) {
+    params.set("branch", options.branch);
+  }
+  const query = params.toString();
+  const response = await apiFetch(
+    apiBase,
+    token,
+    `/apps/${appId}/deployments/latest${query ? `?${query}` : ""}`,
+    { method: "GET" }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(
+      `Latest deployment lookup failed: ${response.status} ${text}`
+    );
+  }
+  const payload = await response.json().catch(() => ({}));
+  if (!payload.deployment) return null;
+  return {
+    id: payload.deployment.id,
+    status: payload.deployment.status
+  };
+}
+async function getDeploymentDetail(apiBase, token, deploymentId) {
+  const response = await apiFetch(
+    apiBase,
+    token,
+    `/apps/deployments/${deploymentId}`,
+    { method: "GET" }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Deployment fetch failed: ${response.status} ${text}`);
+  }
+  const payload = await response.json().catch(() => ({}));
+  return payload.deployment ?? null;
+}
+
+// ../../packages/cloud/src/api.ts
+var DEFAULT_OPENPOND_API_HOST = new URL(DEFAULT_OPENPOND_API_BASE_URL).hostname;
+var DEFAULT_OPENPOND_WEB_HOST = new URL(DEFAULT_OPENPOND_WEB_BASE_URL).hostname;
+async function listApps(apiBase, token, options) {
+  const params = new URLSearchParams();
+  if (options?.handle) {
+    params.set("handle", options.handle);
+  }
+  if (typeof options?.limit === "number" && Number.isFinite(options.limit)) {
+    params.set("limit", String(Math.max(1, Math.floor(options.limit))));
+  }
+  if (typeof options?.offset === "number" && Number.isFinite(options.offset)) {
+    params.set("offset", String(Math.max(0, Math.floor(options.offset))));
+  }
+  if (typeof options?.includeScheduled === "boolean") {
+    params.set("includeScheduled", options.includeScheduled ? "true" : "false");
+  }
+  const query = params.toString();
+  const response = await apiFetch(
+    apiBase,
+    token,
+    `/apps/list${query ? `?${query}` : ""}`,
+    { method: "GET" }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Apps list failed: ${response.status} ${text}`);
+  }
+  const payload = await response.json().catch(() => ({}));
+  return Array.isArray(payload.apps) ? payload.apps : [];
+}
+async function createRepo(apiBase, apiKey, input3) {
+  const response = await apiFetch(apiBase, apiKey, "/apps/repo/create", {
+    method: "POST",
+    body: JSON.stringify(input3)
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Repo create failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function updateAppCodeVisibility(apiBase, apiKey, appId, codeVisibility) {
+  const response = await apiFetch(
+    apiBase,
+    apiKey,
+    `/apps/${encodeURIComponent(appId)}/code-visibility`,
+    {
+      method: "PATCH",
+      body: JSON.stringify({ codeVisibility })
+    }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(
+      `Code visibility update failed: ${response.status} ${text}`
+    );
+  }
+  return await response.json();
+}
+async function createHeadlessApps(baseUrl, token, items, teamId) {
+  const response = await apiFetch(baseUrl, token, "/v4/apps/headless", {
+    method: "POST",
+    body: JSON.stringify({ items, ...teamId ? { teamId } : {} })
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Headless create failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function getTemplateStatus(apiBase, token, appId) {
+  const response = await apiFetch(
+    apiBase,
+    token,
+    `/v4/apps/${appId}/template/status`,
+    { method: "GET" }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Template status failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function listTemplateBranches(apiBase, token, appId) {
+  const response = await apiFetch(
+    apiBase,
+    token,
+    `/v4/apps/${appId}/template/branches`,
+    { method: "GET" }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Template branches failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function deployLatestTemplate(apiBase, token, appId, input3) {
+  const response = await apiFetch(
+    apiBase,
+    token,
+    `/v4/apps/${appId}/template/deploy-latest`,
+    {
+      method: "POST",
+      body: JSON.stringify(input3)
+    }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Template deploy failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function updateAppEnvironment(apiBase, token, appId, input3) {
+  const response = await apiFetch(
+    apiBase,
+    token,
+    `/v4/apps/${appId}/environment`,
+    {
+      method: "POST",
+      body: JSON.stringify(input3)
+    }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Environment update failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function getAppEnvironment(apiBase, token, appId) {
+  const response = await apiFetch(
+    apiBase,
+    token,
+    `/v4/apps/${appId}/environment`,
+    {
+      method: "GET"
+    }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Environment get failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function listUserTools(baseUrl, token) {
+  const response = await apiFetch(baseUrl, token, "/apps/tools", {
+    method: "GET"
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Tools lookup failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function createAgentFromPrompt(baseUrl, token, payload) {
+  return apiFetch(baseUrl, token, "/apps/agent/create", {
+    method: "POST",
+    body: JSON.stringify(payload)
+  });
+}
+async function getUserPerformance(baseUrl, token, options) {
+  const params = new URLSearchParams();
+  if (options?.appId) {
+    params.set("appId", options.appId);
+  }
+  const qs = params.toString();
+  const response = await apiFetch(
+    baseUrl,
+    token,
+    `/apps/performance${qs ? `?${qs}` : ""}`,
+    {
+      method: "GET"
+    }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Performance lookup failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function getAppRuntimeSummary(baseUrl, token, appId) {
+  const params = new URLSearchParams({ appId });
+  const response = await apiFetch(
+    baseUrl,
+    token,
+    `/apps/summary?${params.toString()}`,
+    {
+      method: "GET"
+    }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Summary lookup failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function getOpenPondAccount(baseUrl, token) {
+  const response = await apiFetch(baseUrl, token, "/account", {
+    method: "GET"
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Account lookup failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function checkOpenPondApiHealth(baseUrl, token) {
+  const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const started = Date.now();
+  const normalizedBase = baseUrl.replace(/\/$/, "");
+  try {
+    const response = await fetch(`${normalizedBase}/health`, {
+      method: "GET",
+      headers: { Accept: "application/json" }
+    });
+    const latencyMs = Date.now() - started;
+    const payload = await response.json().catch(() => ({}));
+    let authenticated = null;
+    let account = null;
+    if (token?.trim()) {
+      try {
+        const accountPayload = await getOpenPondAccount(normalizedBase, token);
+        authenticated = true;
+        account = accountPayload.account;
+      } catch {
+        authenticated = false;
+      }
+    }
+    return {
+      reachable: response.ok,
+      authenticated,
+      apiBase: normalizedBase,
+      latencyMs,
+      status: response.status,
+      service: typeof payload.service === "string" ? payload.service : null,
+      checkedAt,
+      account,
+      ...response.ok ? {} : { error: response.statusText || `HTTP ${response.status}` }
+    };
+  } catch (error) {
+    return {
+      reachable: false,
+      authenticated: token?.trim() ? false : null,
+      apiBase: normalizedBase,
+      latencyMs: Date.now() - started,
+      status: null,
+      service: null,
+      checkedAt,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function runAssistantMode(baseUrl, token, payload) {
+  const response = await apiFetch(baseUrl, token, "/apps/assistant/run", {
+    method: "POST",
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Assistant run failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function executeUserTool(baseUrl, token, body) {
+  const response = await apiFetch(baseUrl, token, "/apps/tools/execute", {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+  const text = await response.text().catch(() => "");
+  let payload = null;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = text;
+  }
+  if (!response.ok) {
+    return {
+      ok: false,
+      status: response.status,
+      error: payload && typeof payload === "object" && "error" in payload ? String(payload.error) : text || response.statusText
+    };
+  }
+  return {
+    ok: true,
+    status: response.status,
+    data: payload
+  };
+}
+async function submitPositionsTx(baseUrl, token, params) {
+  const qs = params.query && Object.keys(params.query).length > 0 ? `?${new URLSearchParams(params.query).toString()}` : "";
+  const response = await apiFetch(baseUrl, token, `/apps/positions/tx${qs}`, {
+    method: params.method,
+    body: params.method === "POST" && params.body !== void 0 ? JSON.stringify(params.body) : void 0
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Positions request failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function submitBacktestRun(baseUrl, token, body) {
+  const response = await apiFetch(baseUrl, token, "/apps/backtests/run", {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Backtest run failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function submitBacktestTx(baseUrl, token, params) {
+  const qs = params.query && Object.keys(params.query).length > 0 ? `?${new URLSearchParams(params.query).toString()}` : "";
+  const response = await apiFetch(baseUrl, token, `/apps/backtests/tx${qs}`, {
+    method: params.method,
+    body: params.method === "POST" && params.body !== void 0 ? JSON.stringify(params.body) : void 0
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Backtests request failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function submitBacktestDetail(baseUrl, token, query) {
+  const qs = new URLSearchParams(query).toString();
+  const response = await apiFetch(
+    baseUrl,
+    token,
+    `/apps/backtests/detail?${qs}`,
+    {
+      method: "GET"
+    }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Backtest detail failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+function normalizeToolPathSegment(toolName) {
+  const trimmed = toolName.trim().replace(/^\/+/, "");
+  return encodeURIComponent(trimmed || "tool");
+}
+function resolveWorkerBaseUrl(baseUrl) {
+  const trimmed = baseUrl.replace(/\/$/, "");
+  const workerEnv = process.env.OPENPOND_TOOL_URL;
+  if (workerEnv) {
+    return workerEnv.replace(/\/$/, "");
+  }
+  try {
+    const url = new URL(trimmed);
+    const host = url.hostname.toLowerCase();
+    const mappedHost = (() => {
+      if (host === "apps.openpond.live") {
+        return null;
+      }
+      if (host === DEFAULT_OPENPOND_API_HOST || host === DEFAULT_OPENPOND_WEB_HOST || host === "openpond.live" || host === "www.openpond.live") {
+        return "https://apps.openpond.live";
+      }
+      return null;
+    })();
+    if (mappedHost) {
+      return mappedHost;
+    }
+    const isLocal = host === "localhost" || host === "127.0.0.1";
+    const port = url.port || (url.protocol === "https:" ? "443" : "80");
+    if (isLocal && port === "3000") {
+      return trimmed;
+    }
+  } catch {
+  }
+  return trimmed;
+}
+async function executeHostedTool(baseUrl, token, payload) {
+  const workerBase = resolveWorkerBaseUrl(baseUrl);
+  const toolPath = normalizeToolPathSegment(payload.toolName);
+  const deploymentPrefix = payload.deploymentId ? `/${payload.appId}/deployments/${payload.deploymentId}` : `/${payload.appId}`;
+  const requestPath = `${deploymentPrefix}/${toolPath}`;
+  const headers = new Headers(payload.headers || {});
+  const method = payload.method ?? "POST";
+  const body = payload.body === void 0 || method === "GET" ? void 0 : JSON.stringify(payload.body);
+  const response = await apiFetch(workerBase, token, requestPath, {
+    method,
+    body,
+    headers
+  });
+  const text = await response.text().catch(() => "");
+  let data = null;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+    data = text;
+  }
+  const dataOk = data && typeof data === "object" && "ok" in data ? Boolean(data.ok) : true;
+  const ok = response.ok && dataOk;
+  const status = data && typeof data === "object" && "status" in data ? Number(data.status) || response.status : response.status;
+  const error = data && typeof data === "object" && "error" in data ? String(data.error) : response.ok ? void 0 : text || response.statusText;
+  const payloadData = data && typeof data === "object" && "data" in data ? data.data : data;
+  return { ok, status, data: payloadData, error };
+}
+
+// ../../packages/cloud/src/config.ts
+import { promises as fs2 } from "node:fs";
+import path2 from "node:path";
+
+// ../../packages/cloud/src/private-json-file.ts
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var LOCK_WAIT_TIMEOUT_MS = 1e4;
+var STALE_LOCK_MS = 6e4;
+function openPondConfigDirectory() {
+  const override = process.env.OPENPOND_CONFIG_DIR?.trim();
+  return override || path.join(os.homedir(), ".openpond");
+}
+async function writePrivateJsonFile(filePath, value) {
+  await withPrivateJsonFileLock(filePath, () => writePrivateJsonFileUnlocked(filePath, value));
+}
+async function updatePrivateJsonFile(filePath, fallback, update) {
+  return withPrivateJsonFileLock(filePath, async () => {
+    const current = await readJsonFile(filePath, fallback);
+    const next = await update(current);
+    await writePrivateJsonFileUnlocked(filePath, next);
+    return next;
+  });
+}
+async function writePrivateJsonFileUnlocked(filePath, value) {
+  const directory = path.dirname(filePath);
+  await fs.mkdir(directory, { recursive: true, mode: 448 });
+  await fs.chmod(directory, 448).catch(() => void 0);
+  const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await fs.writeFile(temporaryPath, JSON.stringify(value, null, 2), {
+      encoding: "utf-8",
+      mode: 384
+    });
+    await fs.rename(temporaryPath, filePath);
+    await fs.chmod(filePath, 384).catch(() => void 0);
+  } finally {
+    await fs.rm(temporaryPath, { force: true }).catch(() => void 0);
+  }
+}
+async function withPrivateJsonFileLock(filePath, operation) {
+  const directory = path.dirname(filePath);
+  await fs.mkdir(directory, { recursive: true, mode: 448 });
+  await fs.chmod(directory, 448).catch(() => void 0);
+  const lockPath = `${filePath}.lock`;
+  const deadline = Date.now() + LOCK_WAIT_TIMEOUT_MS;
+  while (true) {
+    try {
+      await fs.mkdir(lockPath, { mode: 448 });
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      await removeStaleLock(lockPath);
+      if (Date.now() >= deadline) throw new Error(`Timed out waiting for private file lock: ${filePath}`);
+      await new Promise((resolve) => setTimeout(resolve, 20 + Math.floor(Math.random() * 30)));
+    }
+  }
+  try {
+    return await operation();
+  } finally {
+    await fs.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+async function readJsonFile(filePath, fallback) {
+  try {
+    return JSON.parse(await fs.readFile(filePath, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return fallback();
+    throw error;
+  }
+}
+async function removeStaleLock(lockPath) {
+  const stats = await fs.stat(lockPath).catch(() => null);
+  if (stats && Date.now() - stats.mtimeMs > STALE_LOCK_MS) {
+    await fs.rm(lockPath, { recursive: true, force: true });
+  }
+}
+
+// ../../packages/cloud/src/config.ts
+var GLOBAL_CONFIG_FILENAME = "config.json";
+var DEFAULT_ACCOUNT_HANDLE = "default";
+var ACCOUNT_SCOPED_KEYS = [
+  "apiKey",
+  "baseUrl",
+  "apiBaseUrl",
+  "chatApiBaseUrl",
+  "token",
+  "appId",
+  "conversationId"
+];
+function getGlobalConfigPath() {
+  return path2.join(openPondConfigDirectory(), GLOBAL_CONFIG_FILENAME);
+}
+async function loadConfigFile(filePath) {
+  try {
+    const raw = await fs2.readFile(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    if (error instanceof SyntaxError) {
+      throw new Error(`OpenPond config is malformed JSON: ${filePath}`, { cause: error });
+    }
+    throw error;
+  }
+}
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function normalizeHandle(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeBaseUrl(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  return trimmed.replace(/\/$/, "");
+}
+function requireHandle(value) {
+  const handle = normalizeHandle(value);
+  if (!handle) {
+    throw new Error("profile handle must be non-empty");
+  }
+  return handle;
+}
+function requireApiKey(value) {
+  if (typeof value !== "string") {
+    throw new Error("apiKey must be a non-empty string");
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error("apiKey must be a non-empty string");
+  }
+  return trimmed;
+}
+function handleEquals(left, right) {
+  const normalizedLeft = normalizeHandle(left);
+  const normalizedRight = normalizeHandle(right);
+  return Boolean(
+    normalizedLeft && normalizedRight && normalizedLeft.toLowerCase() === normalizedRight.toLowerCase()
+  );
+}
+function findAccountIndex(accounts, handle, baseUrl) {
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  return accounts.findIndex((candidate) => {
+    if (!handleEquals(candidate.handle, handle)) return false;
+    if (!normalizedBaseUrl) return true;
+    return normalizeBaseUrl(candidate.baseUrl) === normalizedBaseUrl;
+  });
+}
+function selectorFromAccount(account) {
+  const handle = normalizeHandle(account.handle) ?? DEFAULT_ACCOUNT_HANDLE;
+  const baseUrl = normalizeBaseUrl(account.baseUrl);
+  return baseUrl ? { handle, baseUrl } : { handle };
+}
+function sanitizeActiveProfile(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const input3 = value;
+  const handle = normalizeHandle(
+    typeof input3.handle === "string" ? input3.handle : void 0
+  );
+  if (!handle) return null;
+  const baseUrl = normalizeBaseUrl(
+    typeof input3.baseUrl === "string" ? input3.baseUrl : void 0
+  );
+  return baseUrl ? { handle, baseUrl } : { handle };
+}
+function sanitizeLocalOpenPondProfile(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const input3 = value;
+  const repoPath = typeof input3.repoPath === "string" ? input3.repoPath.trim() : "";
+  const profile = typeof input3.profile === "string" && input3.profile.trim() ? input3.profile.trim() : "default";
+  if (!repoPath) return void 0;
+  const out = {
+    repoPath,
+    profile,
+    mode: "local"
+  };
+  if (input3.lastCheck && typeof input3.lastCheck === "object" && !Array.isArray(input3.lastCheck)) {
+    const check = input3.lastCheck;
+    const command = check.command;
+    const status = check.status;
+    const checkedAt = check.checkedAt;
+    if ((command === "inspect" || command === "build" || command === "validate" || command === "eval" || command === "run") && (status === "passed" || status === "failed") && typeof checkedAt === "string") {
+      out.lastCheck = {
+        command,
+        status,
+        checkedAt,
+        ...typeof check.exitCode === "number" || check.exitCode === null ? { exitCode: check.exitCode } : {},
+        ...typeof check.sourceHead === "string" || check.sourceHead === null ? { sourceHead: check.sourceHead } : {}
+      };
+    }
+  }
+  if (input3.lastPush && typeof input3.lastPush === "object" && !Array.isArray(input3.lastPush)) {
+    const push = input3.lastPush;
+    const status = push.status;
+    const pushedAt = push.pushedAt;
+    if ((status === "pushed" || status === "failed") && typeof pushedAt === "string") {
+      out.lastPush = {
+        status,
+        pushedAt,
+        ...typeof push.teamId === "string" || push.teamId === null ? { teamId: push.teamId } : {},
+        ...typeof push.projectId === "string" || push.projectId === null ? { projectId: push.projectId } : {},
+        ...typeof push.localHead === "string" || push.localHead === null ? { localHead: push.localHead } : {},
+        ...typeof push.hostedHead === "string" || push.hostedHead === null ? { hostedHead: push.hostedHead } : {},
+        ...typeof push.sourceRef === "string" || push.sourceRef === null ? { sourceRef: push.sourceRef } : {},
+        ...push.promotionStatus === "uploaded" || push.promotionStatus === "hosted_source_materialized" || push.promotionStatus === "hosted_source_materialize_failed" || push.promotionStatus === "hosted_source_check_pending" || push.promotionStatus === "hosted_source_check_failed" || push.promotionStatus === "hosted_source_published" || push.promotionStatus === "hosted_source_publish_failed" || push.promotionStatus === "hosted_run_pending" || push.promotionStatus === "hosted_run_passed" || push.promotionStatus === "hosted_run_failed" || push.promotionStatus === null ? { promotionStatus: push.promotionStatus } : {},
+        ...push.hostedRunStatus === "not_started" || push.hostedRunStatus === "running" || push.hostedRunStatus === "passed" || push.hostedRunStatus === "failed" || push.hostedRunStatus === null ? { hostedRunStatus: push.hostedRunStatus } : {},
+        ...typeof push.localGoalId === "string" || push.localGoalId === null ? { localGoalId: push.localGoalId } : {},
+        ...typeof push.hostedGoalId === "string" || push.hostedGoalId === null ? { hostedGoalId: push.hostedGoalId } : {},
+        ...typeof push.hostedRunAgentId === "string" || push.hostedRunAgentId === null ? { hostedRunAgentId: push.hostedRunAgentId } : {},
+        ...typeof push.hostedRunId === "string" || push.hostedRunId === null ? { hostedRunId: push.hostedRunId } : {},
+        ...typeof push.hostedRunAt === "string" || push.hostedRunAt === null ? { hostedRunAt: push.hostedRunAt } : {},
+        ...sanitizeHostedMaterializationStatus(push.hostedSourceMaterialization) ? { hostedSourceMaterialization: sanitizeHostedMaterializationStatus(push.hostedSourceMaterialization) } : {},
+        ...sanitizeHostedSourceCheckStatus(push.hostedSourceCheck) ? { hostedSourceCheck: sanitizeHostedSourceCheckStatus(push.hostedSourceCheck) } : {},
+        ...sanitizeHostedPublishStatus(push.hostedPublish) ? { hostedPublish: sanitizeHostedPublishStatus(push.hostedPublish) } : {},
+        ...sanitizeHostedRunSummary(push.hostedRun) ? { hostedRun: sanitizeHostedRunSummary(push.hostedRun) } : {},
+        ...typeof push.error === "string" || push.error === null ? { error: push.error } : {}
+      };
+    }
+  }
+  return out;
+}
+function sanitizeHostedMaterializationStatus(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const input3 = value;
+  const status = stringField(input3.status);
+  if (!status) return null;
+  return {
+    status,
+    ...nullableStringProp(input3, "agentId"),
+    ...nullableStringProp(input3, "runtimeAgentId"),
+    ...nullableStringProp(input3, "projectId"),
+    ...nullableStringProp(input3, "sourceRoot"),
+    ...nullableStringProp(input3, "sourceRef"),
+    ...nullableStringProp(input3, "sourceCommitSha"),
+    ...nullableStringProp(input3, "manifestHash"),
+    ...nullableStringProp(input3, "manifestPath"),
+    ...nullableStringProp(input3, "manifestSyncedAt"),
+    ...nullableNumberProp(input3, "fileCount"),
+    ...nullableNumberProp(input3, "totalBytes"),
+    ...nullableStringProp(input3, "generatedManifestPath"),
+    ...nullableBooleanProp(input3, "synthesizedOpenPondYaml"),
+    ...nullableStringProp(input3, "uploadMetadataPath"),
+    ...stringArrayProp(input3, "setupCommands"),
+    ...stringArrayProp(input3, "validationCommands"),
+    ...nullableStringProp(input3, "materializedAt"),
+    ...nullableStringProp(input3, "error")
+  };
+}
+function sanitizeHostedSourceCheckStatus(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const input3 = value;
+  const status = stringField(input3.status);
+  if (!status) return null;
+  return {
+    status,
+    ...nullableStringProp(input3, "agentId"),
+    ...nullableStringProp(input3, "workItemId"),
+    ...nullableStringProp(input3, "deployPlanStatus"),
+    ...nullableBooleanProp(input3, "canRun"),
+    ...nullableBooleanProp(input3, "canDeploy"),
+    ...nullableStringProp(input3, "sourceRef"),
+    ...nullableStringProp(input3, "sourceCommitSha"),
+    ...nullableStringProp(input3, "manifestHash"),
+    ...nullableStringProp(input3, "manifestPath"),
+    ...stringArrayProp(input3, "setupCommands"),
+    ...stringArrayProp(input3, "validationCommands"),
+    ...stringArrayProp(input3, "requiredChecks"),
+    ...stringArrayProp(input3, "evalNames"),
+    ...stringArrayProp(input3, "blockedReasons"),
+    ...stringArrayProp(input3, "staleReasons"),
+    ...nullableStringProp(input3, "runtimeId"),
+    ...nullableStringProp(input3, "sandboxId"),
+    ...stringArrayProp(input3, "traceArtifactRefs"),
+    ...stringArrayProp(input3, "evalResultArtifactRefs"),
+    ...stringArrayProp(input3, "validatorArtifactRefs"),
+    ...nullableStringProp(input3, "checkedAt"),
+    ...nullableStringProp(input3, "error")
+  };
+}
+function sanitizeHostedPublishStatus(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const input3 = value;
+  const status = stringField(input3.status);
+  if (!status) return null;
+  return {
+    status,
+    ...nullableStringProp(input3, "agentId"),
+    ...nullableStringProp(input3, "snapshotId"),
+    ...nullableStringProp(input3, "sourceRef"),
+    ...nullableStringProp(input3, "sourceCommitSha"),
+    ...nullableStringProp(input3, "manifestHash"),
+    ...nullableStringProp(input3, "manifestPath"),
+    ...nullableStringProp(input3, "buildStatus"),
+    ...nullableStringProp(input3, "validationStatus"),
+    ...nullableStringProp(input3, "evalStatus"),
+    ...nullableStringProp(input3, "publishedAt"),
+    ...nullableStringProp(input3, "error")
+  };
+}
+function sanitizeHostedRunSummary(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const input3 = value;
+  const status = stringField(input3.status);
+  if (!status) return null;
+  return {
+    status,
+    ...nullableStringProp(input3, "agentId"),
+    ...nullableStringProp(input3, "runId"),
+    ...nullableStringProp(input3, "runtimeId"),
+    ...nullableStringProp(input3, "sandboxId"),
+    ...nullableStringProp(input3, "sourceRef"),
+    ...nullableStringProp(input3, "sourceCommitSha"),
+    ...nullableStringProp(input3, "manifestHash"),
+    ...nullableStringProp(input3, "setupGateStatus"),
+    ...stringArrayProp(input3, "setupRequirementRefs"),
+    ...stringArrayProp(input3, "artifactRefs"),
+    ...stringArrayProp(input3, "traceArtifactRefs"),
+    ...stringArrayProp(input3, "evalArtifactRefs"),
+    ...nullableStringProp(input3, "startedAt"),
+    ...nullableStringProp(input3, "completedAt"),
+    ...nullableStringProp(input3, "error")
+  };
+}
+function nullableStringProp(input3, key) {
+  const value = input3[key];
+  return typeof value === "string" || value === null ? { [key]: value } : {};
+}
+function nullableBooleanProp(input3, key) {
+  const value = input3[key];
+  return typeof value === "boolean" || value === null ? { [key]: value } : {};
+}
+function nullableNumberProp(input3, key) {
+  const value = input3[key];
+  return typeof value === "number" || value === null ? { [key]: value } : {};
+}
+function stringArrayProp(input3, key) {
+  const value = input3[key];
+  if (!Array.isArray(value)) return {};
+  const strings = value.filter((item) => typeof item === "string");
+  return { [key]: strings };
+}
+function stringField(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function accountMatchesSelector(account, selector) {
+  if (!handleEquals(account.handle, selector.handle)) return false;
+  const selectorBaseUrl = normalizeBaseUrl(selector.baseUrl);
+  if (selectorBaseUrl) {
+    return normalizeBaseUrl(account.baseUrl) === selectorBaseUrl;
+  }
+  return !normalizeBaseUrl(account.baseUrl);
+}
+function findAccountIndexForSelector(accounts, selector, options = {}) {
+  const normalizedBaseUrl = normalizeBaseUrl(selector.baseUrl);
+  if (normalizedBaseUrl) {
+    return findAccountIndex(accounts, selector.handle, normalizedBaseUrl);
+  }
+  const noBaseIdx = accounts.findIndex(
+    (account) => accountMatchesSelector(account, selector)
+  );
+  if (noBaseIdx !== -1) return noBaseIdx;
+  const matches = accounts.map((account, index) => ({ account, index })).filter(({ account }) => handleEquals(account.handle, selector.handle));
+  if (matches.length > 1 && options.requireUnambiguous) {
+    throw new Error(
+      `multiple profiles found for ${selector.handle}; pass --base-url to select one`
+    );
+  }
+  return matches[0]?.index ?? -1;
+}
+function sanitizeSession(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const input3 = value;
+  const out = {};
+  if (typeof input3.token === "string") out.token = input3.token;
+  if (typeof input3.appId === "string" || input3.appId === null) {
+    out.appId = input3.appId;
+  }
+  if (typeof input3.conversationId === "string" || input3.conversationId === null) {
+    out.conversationId = input3.conversationId;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function sanitizeAccount(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const input3 = value;
+  const handle = normalizeHandle(
+    typeof input3.handle === "string" ? input3.handle : void 0
+  );
+  if (!handle) return null;
+  const out = { handle };
+  if (typeof input3.apiKey === "string") out.apiKey = input3.apiKey;
+  if (typeof input3.baseUrl === "string") out.baseUrl = input3.baseUrl;
+  if (typeof input3.apiBaseUrl === "string") out.apiBaseUrl = input3.apiBaseUrl;
+  if (typeof input3.chatApiBaseUrl === "string")
+    out.chatApiBaseUrl = input3.chatApiBaseUrl;
+  if (typeof input3.environment === "string")
+    out.environment = input3.environment;
+  const session = sanitizeSession(input3.session);
+  if (session) out.session = session;
+  return out;
+}
+function extractLegacySession(raw) {
+  const session = {};
+  if (typeof raw.token === "string") session.token = raw.token;
+  if (typeof raw.appId === "string" || raw.appId === null) {
+    session.appId = raw.appId;
+  }
+  if (typeof raw.conversationId === "string" || raw.conversationId === null) {
+    session.conversationId = raw.conversationId;
+  }
+  return Object.keys(session).length > 0 ? session : void 0;
+}
+function extractLegacyAccount(raw, handle) {
+  const out = { handle };
+  if (typeof raw.apiKey === "string") out.apiKey = raw.apiKey;
+  if (typeof raw.baseUrl === "string") out.baseUrl = raw.baseUrl;
+  if (typeof raw.apiBaseUrl === "string") out.apiBaseUrl = raw.apiBaseUrl;
+  if (typeof raw.chatApiBaseUrl === "string")
+    out.chatApiBaseUrl = raw.chatApiBaseUrl;
+  const session = extractLegacySession(raw);
+  if (session) out.session = session;
+  return out;
+}
+function normalizeGlobalConfig(raw) {
+  const normalized = {};
+  if (raw.goalStorageLocation === "global" || raw.goalStorageLocation === "workspace") {
+    normalized.goalStorageLocation = raw.goalStorageLocation;
+  }
+  if (typeof raw.lspEnabled === "boolean")
+    normalized.lspEnabled = raw.lspEnabled;
+  if (raw.executionMode === "local" || raw.executionMode === "hosted") {
+    normalized.executionMode = raw.executionMode;
+  }
+  if (raw.mode === "general" || raw.mode === "builder") {
+    normalized.mode = raw.mode;
+  }
+  const openpondProfile = sanitizeLocalOpenPondProfile(raw.openpondProfile);
+  if (openpondProfile) {
+    normalized.openpondProfile = openpondProfile;
+  }
+  const accounts = [];
+  const sourceAccounts = Array.isArray(raw.accounts) ? raw.accounts : [];
+  for (const candidate of sourceAccounts) {
+    const account = sanitizeAccount(candidate);
+    if (!account) continue;
+    if (findAccountIndex(accounts, account.handle, account.baseUrl) !== -1)
+      continue;
+    accounts.push(account);
+  }
+  if (accounts.length === 0) {
+    const legacyHandle = sanitizeActiveProfile(raw.activeProfile)?.handle || DEFAULT_ACCOUNT_HANDLE;
+    accounts.push(extractLegacyAccount(raw, legacyHandle));
+  }
+  const requested = sanitizeActiveProfile(raw.activeProfile);
+  const activeIdx = requested ? findAccountIndexForSelector(accounts, requested) : -1;
+  const activeAccount = accounts[activeIdx === -1 ? 0 : activeIdx];
+  normalized.accounts = accounts;
+  normalized.activeProfile = selectorFromAccount(activeAccount);
+  return normalized;
+}
+function resolveRequestedProfile(global, explicitAccount, explicitBaseUrl) {
+  const accounts = global.accounts ?? [];
+  const requestedBaseUrl = normalizeBaseUrl(
+    explicitBaseUrl ?? process.env.OPENPOND_BASE_URL
+  );
+  const explicit = normalizeHandle(explicitAccount);
+  if (explicit) {
+    return requestedBaseUrl ? { handle: explicit, baseUrl: requestedBaseUrl } : { handle: explicit };
+  }
+  const envAccount = normalizeHandle(process.env.OPENPOND_ACCOUNT);
+  if (envAccount) {
+    return requestedBaseUrl ? { handle: envAccount, baseUrl: requestedBaseUrl } : { handle: envAccount };
+  }
+  const activeProfile = sanitizeActiveProfile(global.activeProfile);
+  if (activeProfile) {
+    return requestedBaseUrl ? { handle: activeProfile.handle, baseUrl: requestedBaseUrl } : activeProfile;
+  }
+  return accounts[0] ? selectorFromAccount(accounts[0]) : { handle: DEFAULT_ACCOUNT_HANDLE };
+}
+function ensureAccount(accounts, handle, baseUrl) {
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  if (normalizedBaseUrl) {
+    const idx = findAccountIndex(accounts, handle, normalizedBaseUrl);
+    if (idx !== -1) {
+      return accounts[idx];
+    }
+  } else {
+    const matches = accounts.filter(
+      (account) => handleEquals(account.handle, handle)
+    );
+    if (matches.length > 1) {
+      throw new Error(
+        `multiple profiles found for ${handle}; pass --base-url to select one`
+      );
+    }
+    if (matches.length === 1) {
+      return matches[0];
+    }
+  }
+  const next = { handle };
+  if (normalizedBaseUrl) {
+    next.baseUrl = normalizedBaseUrl;
+  }
+  accounts.push(next);
+  return next;
+}
+function cleanupAccount(account) {
+  if (account.session && Object.keys(account.session).length === 0) {
+    delete account.session;
+  }
+}
+function applyScopedKey(account, key, value, options) {
+  const shouldDelete = value === null || value === void 0 && options.undefinedDeletes;
+  switch (key) {
+    case "apiKey": {
+      if (shouldDelete) {
+        delete account.apiKey;
+        return;
+      }
+      if (typeof value === "string") {
+        account.apiKey = value;
+      }
+      return;
+    }
+    case "baseUrl": {
+      if (shouldDelete) {
+        delete account.baseUrl;
+        return;
+      }
+      if (typeof value === "string") {
+        account.baseUrl = value;
+      }
+      return;
+    }
+    case "apiBaseUrl": {
+      if (shouldDelete) {
+        delete account.apiBaseUrl;
+        return;
+      }
+      if (typeof value === "string") {
+        account.apiBaseUrl = value;
+      }
+      return;
+    }
+    case "chatApiBaseUrl": {
+      if (shouldDelete) {
+        delete account.chatApiBaseUrl;
+        return;
+      }
+      if (typeof value === "string") {
+        account.chatApiBaseUrl = value;
+      }
+      return;
+    }
+    case "token":
+    case "appId":
+    case "conversationId": {
+      if (!account.session) account.session = {};
+      if (shouldDelete) {
+        delete account.session[key];
+        cleanupAccount(account);
+        return;
+      }
+      if (typeof value === "string" || value === null) {
+        account.session[key] = value;
+      }
+      cleanupAccount(account);
+      return;
+    }
+  }
+}
+function applyAccountPatch(global, source, options) {
+  const hasScopedPatch = ACCOUNT_SCOPED_KEYS.some((key) => hasOwn(source, key));
+  if (!hasScopedPatch) return false;
+  const accounts = global.accounts ?? [];
+  const selector = sanitizeActiveProfile(source.activeProfile) ?? resolveRequestedProfile(global);
+  const requestedBaseUrl = normalizeBaseUrl(
+    hasOwn(source, "baseUrl") ? source.baseUrl ?? null : selector.baseUrl ?? process.env.OPENPOND_BASE_URL
+  );
+  const account = ensureAccount(accounts, selector.handle, requestedBaseUrl);
+  for (const key of ACCOUNT_SCOPED_KEYS) {
+    if (!hasOwn(source, key)) continue;
+    applyScopedKey(
+      account,
+      key,
+      source[key],
+      options
+    );
+  }
+  global.accounts = accounts;
+  global.activeProfile = selectorFromAccount(account);
+  return true;
+}
+function applyTopLevelPatch(global, source) {
+  if (hasOwn(source, "goalStorageLocation")) {
+    if (source.goalStorageLocation === "global" || source.goalStorageLocation === "workspace") {
+      global.goalStorageLocation = source.goalStorageLocation;
+    } else if (source.goalStorageLocation === null) {
+      delete global.goalStorageLocation;
+    }
+  }
+  if (hasOwn(source, "lspEnabled")) {
+    if (typeof source.lspEnabled === "boolean") {
+      global.lspEnabled = source.lspEnabled;
+    } else if (source.lspEnabled === null) {
+      delete global.lspEnabled;
+    }
+  }
+  if (hasOwn(source, "executionMode")) {
+    if (source.executionMode === "local" || source.executionMode === "hosted") {
+      global.executionMode = source.executionMode;
+    } else if (source.executionMode === null) {
+      delete global.executionMode;
+    }
+  }
+  if (hasOwn(source, "mode")) {
+    if (source.mode === "general" || source.mode === "builder") {
+      global.mode = source.mode;
+    } else if (source.mode === null) {
+      delete global.mode;
+    }
+  }
+  if (hasOwn(source, "activeProfile")) {
+    const selector = sanitizeActiveProfile(source.activeProfile);
+    if (selector) {
+      const idx = findAccountIndexForSelector(global.accounts ?? [], selector);
+      global.activeProfile = idx === -1 ? selector : selectorFromAccount((global.accounts ?? [])[idx]);
+    } else if (source.activeProfile === null) {
+      delete global.activeProfile;
+    }
+  }
+  if (hasOwn(source, "openpondProfile")) {
+    const profile = sanitizeLocalOpenPondProfile(source.openpondProfile);
+    if (profile) {
+      global.openpondProfile = profile;
+    } else if (source.openpondProfile === null) {
+      delete global.openpondProfile;
+    }
+  }
+}
+async function updateGlobalConfig(update) {
+  try {
+    return await updatePrivateJsonFile(getGlobalConfigPath(), () => ({}), (raw) => {
+      const current = normalizeGlobalConfig(raw);
+      update(current);
+      return current;
+    });
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`OpenPond config is malformed JSON: ${getGlobalConfigPath()}`, { cause: error });
+    }
+    throw error;
+  }
+}
+async function loadGlobalConfig() {
+  const raw = await loadConfigFile(getGlobalConfigPath());
+  return normalizeGlobalConfig(raw);
+}
+async function loadConfig(options = {}) {
+  const global = await loadGlobalConfig();
+  const accounts = global.accounts ?? [];
+  const requested = resolveRequestedProfile(
+    global,
+    options.account,
+    options.baseUrl
+  );
+  const idx = findAccountIndexForSelector(accounts, requested, {
+    requireUnambiguous: true
+  });
+  const account = idx === -1 ? null : accounts[idx];
+  const session = account?.session;
+  return {
+    ...global,
+    activeProfile: account ? selectorFromAccount(account) : requested,
+    apiKey: account?.apiKey,
+    baseUrl: account?.baseUrl,
+    apiBaseUrl: account?.apiBaseUrl,
+    chatApiBaseUrl: account?.chatApiBaseUrl,
+    token: session?.token,
+    appId: session?.appId,
+    conversationId: session?.conversationId
+  };
+}
+async function listConfiguredProfiles() {
+  const global = await loadGlobalConfig();
+  const activeProfile = sanitizeActiveProfile(global.activeProfile);
+  return (global.accounts ?? []).map((account) => {
+    const handle = normalizeHandle(account.handle) ?? DEFAULT_ACCOUNT_HANDLE;
+    return {
+      handle,
+      baseUrl: normalizeBaseUrl(account.baseUrl),
+      apiBaseUrl: normalizeBaseUrl(account.apiBaseUrl),
+      chatApiBaseUrl: normalizeBaseUrl(account.chatApiBaseUrl),
+      environment: account.environment?.trim() || null,
+      isActive: Boolean(
+        activeProfile && accountMatchesSelector({ ...account, handle }, activeProfile)
+      ),
+      hasApiKey: Boolean(account.apiKey?.trim()),
+      hasSessionToken: Boolean(account.session?.token?.trim()),
+      sessionAppId: account.session?.appId ?? null,
+      sessionConversationId: account.session?.conversationId ?? null
+    };
+  });
+}
+async function setActiveProfile(handle, options = {}) {
+  const requestedHandle = requireHandle(handle);
+  const requestedBaseUrl = normalizeBaseUrl(options.baseUrl);
+  let selectedIndex = -1;
+  await updateGlobalConfig((global) => {
+    const accounts = global.accounts ?? [];
+    selectedIndex = findAccountIndexForSelector(
+      accounts,
+      requestedBaseUrl ? { handle: requestedHandle, baseUrl: requestedBaseUrl } : { handle: requestedHandle },
+      { requireUnambiguous: true }
+    );
+    if (selectedIndex === -1) throw new Error(`profile not found: ${requestedHandle}`);
+    global.activeProfile = selectorFromAccount(accounts[selectedIndex]);
+  });
+  const profiles = await listConfiguredProfiles();
+  return profiles.find((profile) => profile.isActive) ?? profiles[selectedIndex];
+}
+async function saveProfileApiKey(input3) {
+  const handle = requireHandle(input3.handle);
+  const apiKey = requireApiKey(input3.apiKey);
+  const baseUrl = normalizeBaseUrl(input3.baseUrl);
+  const apiBaseUrl = normalizeBaseUrl(input3.apiBaseUrl);
+  const chatApiBaseUrl = normalizeBaseUrl(input3.chatApiBaseUrl);
+  let savedSelector = { handle };
+  await updateGlobalConfig((global) => {
+    const accounts = global.accounts ?? [];
+    const account = ensureAccount(accounts, handle, baseUrl);
+    account.apiKey = apiKey;
+    if (baseUrl) account.baseUrl = baseUrl;
+    if (apiBaseUrl) account.apiBaseUrl = apiBaseUrl;
+    else if (input3.apiBaseUrl === null) delete account.apiBaseUrl;
+    if (chatApiBaseUrl) account.chatApiBaseUrl = chatApiBaseUrl;
+    else if (input3.chatApiBaseUrl === null) delete account.chatApiBaseUrl;
+    if (input3.environment === null) delete account.environment;
+    else if (typeof input3.environment === "string" && input3.environment.trim()) {
+      account.environment = input3.environment.trim();
+    }
+    global.accounts = accounts;
+    savedSelector = selectorFromAccount(account);
+    if (input3.setActive !== false) global.activeProfile = savedSelector;
+  });
+  const profiles = await listConfiguredProfiles();
+  const saved = profiles.find((profile) => {
+    if (!handleEquals(profile.handle, savedSelector.handle)) return false;
+    if (!baseUrl) return true;
+    return normalizeBaseUrl(profile.baseUrl) === baseUrl;
+  });
+  if (!saved) {
+    throw new Error(`failed to save profile: ${handle}`);
+  }
+  return saved;
+}
+async function saveGlobalConfig(next) {
+  await updateGlobalConfig((current) => {
+    applyTopLevelPatch(current, next);
+    applyAccountPatch(current, next, { undefinedDeletes: false });
+  });
+}
+
+// src/cli/common/auth.ts
+import { stdin as input, stdout as output } from "node:process";
+import { createInterface } from "node:readline/promises";
+var UI_API_KEY_URL = `${DEFAULT_OPENPOND_WEB_BASE_URL}/settings/api-keys`;
+function resolveApiKey(config) {
+  const envKey = process.env.OPENPOND_API_KEY?.trim();
+  if (envKey) return envKey;
+  const stored = config.apiKey?.trim();
+  if (stored) return stored;
+  const legacy = config.token?.trim();
+  if (legacy && legacy.startsWith("opk_")) return legacy;
+  return null;
+}
+async function promptForApiKey() {
+  if (!input.isTTY || !output.isTTY) {
+    throw new Error(
+      "OpenPond API key is required in non-interactive mode. Set OPENPOND_API_KEY or run `openpond login` in a terminal."
+    );
+  }
+  console.log("Open the OpenPond UI to create an API key:");
+  console.log(UI_API_KEY_URL);
+  const rl = createInterface({ input, output });
+  try {
+    const value = (await rl.question("Paste your OpenPond API key: ")).trim();
+    if (!value) {
+      throw new Error("API key is required");
+    }
+    if (!value.startsWith("opk_")) {
+      console.log("warning: API keys usually start with opk_.");
+    }
+    return value;
+  } finally {
+    rl.close();
+  }
+}
+async function ensureApiKey(config, baseUrl) {
+  const existing = resolveApiKey(config);
+  if (existing) return existing;
+  const apiKey = await promptForApiKey();
+  await saveGlobalConfig({
+    apiKey,
+    baseUrl,
+    activeProfile: config.activeProfile
+  });
+  console.log("saved api key to ~/.openpond/config.json");
+  return apiKey;
+}
+
+// src/cli/common/repo-format.ts
+function resolveRepoUrl(response) {
+  if (response.repoUrl) return response.repoUrl;
+  if (response.gitHost && response.gitOwner && response.gitRepo) {
+    return `https://${response.gitHost}/${response.gitOwner}/${response.gitRepo}.git`;
+  }
+  throw new Error("repoUrl missing from API response");
+}
+function formatTokenizedRepoUrl(repoUrl, token) {
+  const url = new URL(repoUrl);
+  const encodedToken = encodeURIComponent(token);
+  return `${url.protocol}//x-access-token:${encodedToken}@${url.host}${url.pathname}`;
+}
+function formatTokenizedRepoUrlForPrint(repoUrl) {
+  const url = new URL(repoUrl);
+  return `${url.protocol}//x-access-token:$OPENPOND_API_KEY@${url.host}${url.pathname}`;
+}
+function redactToken(value) {
+  return value.replace(/x-access-token:[^@]+@/g, "x-access-token:***@");
+}
+function warnOnRepoHostMismatch(repoUrl) {
+  const envBase = process.env.OPENPOND_BASE_URL;
+  if (!envBase) return;
+  try {
+    const baseHost = new URL(envBase).hostname;
+    const repoHost = new URL(repoUrl).hostname;
+    if (baseHost && repoHost && baseHost !== repoHost) {
+      console.warn(
+        `warning: repo host (${repoHost}) does not match OPENPOND_BASE_URL (${baseHost})`
+      );
+      console.warn(
+        "warning: verify your git host configuration matches OPENPOND_BASE_URL."
+      );
+    }
+  } catch {
+  }
+}
+function parseHandleRepo(value) {
+  const parts = value.split("/").filter(Boolean);
+  if (parts.length !== 2) {
+    throw new Error("expected <handle>/<repo>");
+  }
+  return { handle: parts[0], repo: parts[1] };
+}
+function normalizeRepoName(value) {
+  return (value || "").trim().toLowerCase();
+}
+
+// ../../packages/cloud/src/cache.ts
+import { promises as fs3 } from "node:fs";
+import { createHash } from "node:crypto";
+import path3 from "node:path";
+var CACHE_FILENAME = "cache.json";
+var DEFAULT_CACHE_TTL_MS = 60 * 60 * 1e3;
+function getCachePath() {
+  return path3.join(openPondConfigDirectory(), CACHE_FILENAME);
+}
+function buildCacheKey(apiBase, apiKey) {
+  const credentialHash = createHash("sha256").update(apiKey.trim()).digest("hex");
+  try {
+    const host = new URL(apiBase).host;
+    return `${host}:${credentialHash}`;
+  } catch {
+    return `${apiBase}:${credentialHash}`;
+  }
+}
+function isFresh(updatedAt, ttlMs) {
+  const timestamp = Date.parse(updatedAt);
+  if (Number.isNaN(timestamp)) {
+    return false;
+  }
+  return Date.now() - timestamp < ttlMs;
+}
+async function loadCache() {
+  try {
+    const raw = await fs3.readFile(getCachePath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || !parsed.byKey) {
+      return emptyCacheStore();
+    }
+    return parsed;
+  } catch {
+    return emptyCacheStore();
+  }
+}
+function emptyCacheStore() {
+  return { version: 1, byKey: {} };
+}
+async function getCachedApps(params) {
+  const ttlMs = params.ttlMs ?? DEFAULT_CACHE_TTL_MS;
+  const store = await loadCache();
+  const cacheKey = buildCacheKey(params.apiBase, params.apiKey);
+  const entry = store.byKey[cacheKey]?.apps;
+  if (!entry || !isFresh(entry.updatedAt, ttlMs)) {
+    return null;
+  }
+  return Array.isArray(entry.items) ? entry.items : null;
+}
+async function setCachedApps(params) {
+  await mutateCache((store) => {
+    const cacheKey = buildCacheKey(params.apiBase, params.apiKey);
+    const bucket = store.byKey[cacheKey] || {};
+    bucket.apps = {
+      items: params.apps,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    store.byKey[cacheKey] = bucket;
+  });
+}
+async function getCachedTools(params) {
+  const ttlMs = params.ttlMs ?? DEFAULT_CACHE_TTL_MS;
+  const store = await loadCache();
+  const cacheKey = buildCacheKey(params.apiBase, params.apiKey);
+  const entry = store.byKey[cacheKey]?.tools;
+  if (!entry || !isFresh(entry.updatedAt, ttlMs)) {
+    return null;
+  }
+  return Array.isArray(entry.items) ? entry.items : null;
+}
+async function setCachedTools(params) {
+  await mutateCache((store) => {
+    const cacheKey = buildCacheKey(params.apiBase, params.apiKey);
+    const bucket = store.byKey[cacheKey] || {};
+    bucket.tools = {
+      items: params.tools,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    store.byKey[cacheKey] = bucket;
+  });
+}
+async function mutateCache(mutate) {
+  await updatePrivateJsonFile(getCachePath(), emptyCacheStore, (raw) => {
+    const store = raw && typeof raw === "object" && raw.byKey ? raw : emptyCacheStore();
+    mutate(store);
+    return store;
+  });
+}
+
+// src/cli/common/cache.ts
+async function fetchAppsWithCache(params) {
+  if (!params.forceRefresh) {
+    const cached = await getCachedApps({
+      apiBase: params.apiBase,
+      apiKey: params.apiKey,
+      ttlMs: DEFAULT_CACHE_TTL_MS
+    });
+    if (cached) {
+      return cached;
+    }
+  }
+  const apps = await listApps(params.apiBase, params.apiKey);
+  await setCachedApps({
+    apiBase: params.apiBase,
+    apiKey: params.apiKey,
+    apps
+  });
+  return apps;
+}
+async function fetchToolsWithCache(params) {
+  if (!params.forceRefresh) {
+    const cached = await getCachedTools({
+      apiBase: params.apiBase,
+      apiKey: params.apiKey,
+      ttlMs: DEFAULT_CACHE_TTL_MS
+    });
+    if (cached) {
+      return cached;
+    }
+  }
+  const result = await listUserTools(params.apiBase, params.apiKey);
+  const tools = Array.isArray(result.tools) ? result.tools : [];
+  await setCachedTools({
+    apiBase: params.apiBase,
+    apiKey: params.apiKey,
+    tools
+  });
+  return tools;
+}
+async function resolveAppTarget(apiBase, apiKey, target) {
+  const { handle, repo } = parseHandleRepo(target);
+  const apps = await fetchAppsWithCache({ apiBase, apiKey });
+  const normalizedRepo = normalizeRepoName(repo);
+  const match = apps.find((app) => {
+    if (app.handle && app.handle !== handle) {
+      return false;
+    }
+    const candidates = [app.repo, app.gitRepo, app.id].map(normalizeRepoName);
+    return candidates.includes(normalizedRepo);
+  });
+  if (!match) {
+    throw new Error(`app not found for ${handle}/${repo}`);
+  }
+  return { app: match, handle, repo };
+}
+async function pollDeploymentLogs(params) {
+  const intervalMs = params.intervalMs ?? 5e3;
+  const timeoutMs = params.timeoutMs ?? 4 * 60 * 1e3;
+  const seen = /* @__PURE__ */ new Set();
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const logs = await getDeploymentLogs(
+      params.baseUrl,
+      params.apiKey,
+      params.deploymentId
+    );
+    const newLogs = logs.filter((log) => !seen.has(log.id));
+    for (const log of newLogs) {
+      seen.add(log.id);
+    }
+    for (const log of newLogs) {
+      console.log(`${params.prefix}${log.message}`);
+    }
+    const status = await getDeploymentStatus(
+      params.baseUrl,
+      params.apiKey,
+      params.deploymentId
+    );
+    if (status.status === "failed") {
+      console.log(`${params.prefix}deployment failed`);
+      return;
+    }
+    if (status.status === "running" || status.status === "deployed") {
+      console.log(`${params.prefix}deployment complete`);
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  console.log(`${params.prefix}deployment still in progress`);
+}
+
+// src/cli/common/prompts.ts
+import { stdin as input2, stdout as output2 } from "node:process";
+import { createInterface as createInterface2 } from "node:readline/promises";
+async function readAllStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  }
+  return Buffer.concat(chunks).toString("utf8").replace(/\r?\n$/, "");
+}
+function readMaskedLine(prompt) {
+  return new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    const stderr = process.stderr;
+    let value = "";
+    const wasRaw = stdin.isRaw;
+    function cleanup() {
+      stdin.off("data", onData);
+      if (stdin.setRawMode) stdin.setRawMode(wasRaw);
+      stdin.pause();
+      stderr.write("\n");
+    }
+    function onData(chunk) {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      for (const byte of buffer) {
+        if (byte === 3) {
+          cleanup();
+          reject(new Error("secret prompt cancelled"));
+          return;
+        }
+        if (byte === 13 || byte === 10) {
+          cleanup();
+          resolve(value);
+          return;
+        }
+        if (byte === 127 || byte === 8) {
+          if (value.length > 0) {
+            value = value.slice(0, -1);
+            stderr.write("\b \b");
+          }
+          continue;
+        }
+        value += Buffer.from([byte]).toString("utf8");
+        stderr.write("*");
+      }
+    }
+    stderr.write(prompt);
+    stdin.resume();
+    if (stdin.setRawMode) stdin.setRawMode(true);
+    stdin.on("data", onData);
+  });
+}
+async function promptConfirm(question, defaultValue = false) {
+  const rl = createInterface2({ input: input2, output: output2 });
+  try {
+    const suffix = defaultValue ? "[Y/n]" : "[y/N]";
+    const answer = (await rl.question(`${question} ${suffix} `)).trim().toLowerCase();
+    if (!answer) return defaultValue;
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function promptForPath(defaultPath) {
+  const rl = createInterface2({ input: input2, output: output2 });
+  try {
+    const answer = (await rl.question(`Local path (default: ${defaultPath}): `)).trim();
+    return answer || defaultPath;
+  } finally {
+    rl.close();
+  }
+}
+
+// ../../packages/cloud/src/sandbox/client-handles.ts
+function createSandboxRuntimeNamespace(client) {
+  return {
+    list: (input3 = {}) => client.listSandboxRuntimes(input3),
+    create: (input3) => client.createSandboxRuntime(input3),
+    handle: (runtimeId, initial = null) => client.sandboxRuntime(runtimeId, initial),
+    get: (runtimeId) => client.getSandboxRuntime(runtimeId),
+    createSandbox: (runtimeId, input3 = {}, options = {}) => client.createSandboxRuntimeSandbox(runtimeId, input3, options),
+    updateStatus: (runtimeId, input3) => client.updateSandboxRuntimeStatus(runtimeId, input3),
+    events: (runtimeId) => client.listSandboxRuntimeEvents(runtimeId),
+    event: (runtimeId, input3) => client.emitSandboxRuntimeEvent(runtimeId, input3),
+    checkpoint: (runtimeId, input3 = {}) => client.checkpointSandboxRuntime(runtimeId, input3),
+    promote: (runtimeId, input3, options = {}) => client.promoteSandboxRuntime(runtimeId, input3, options),
+    preserveSource: (runtimeId, input3 = {}, options = {}) => client.preserveSandboxRuntimeSource(runtimeId, input3, options)
+  };
+}
+function createSandboxNamespace(client) {
+  return {
+    list: (input3 = {}) => client.list(input3),
+    create: (input3) => client.create(input3),
+    get: (sandboxId) => client.get(sandboxId),
+    pricing: () => client.pricing(),
+    costs: (input3 = {}) => client.costs(input3)
+  };
+}
+function createSandboxProjectNamespace(client) {
+  return {
+    list: (input3) => client.listProjects(input3),
+    upsert: (input3) => client.upsertProject(input3),
+    upsertGitRemote: (input3) => client.upsertProjectGitRemote(input3),
+    get: (projectId, input3) => client.getProject(projectId, input3),
+    update: (projectId, input3) => client.updateProject(projectId, input3),
+    sync: (projectId, input3) => client.syncProject(projectId, input3),
+    ensureGitRemote: (projectId, input3) => client.ensureProjectGitRemote(projectId, input3),
+    getGitRemote: (projectId, input3) => client.ensureProjectGitRemote(projectId, input3),
+    git: (projectId, input3) => client.ensureProjectGitRemote(projectId, input3),
+    uploadSource: (projectId, input3) => client.uploadProjectSource(projectId, input3),
+    archive: (projectId, input3) => client.archiveProject(projectId, input3)
+  };
+}
+function createSandboxProfileNamespace(client) {
+  return {
+    get: (input3) => client.getHostedProfile(input3),
+    status: (input3) => client.getHostedProfile(input3),
+    ensureHosted: (input3) => client.ensureHostedProfile(input3),
+    push: (input3) => client.pushHostedProfile(input3)
+  };
+}
+function createSandboxAgentNamespace(client) {
+  return {
+    list: (input3) => client.listAgents(input3),
+    upsert: (input3) => client.upsertAgent(input3),
+    get: (agentId, input3) => client.getAgent(agentId, input3),
+    update: (agentId, input3) => client.updateAgent(agentId, input3),
+    archive: (agentId, input3) => client.archiveAgent(agentId, input3),
+    run: (agentId, input3) => client.runAgent(agentId, input3),
+    sourceDeployPlan: (agentId, input3) => client.getAgentSourceDeployPlan(agentId, input3),
+    manifestSnapshots: (agentId, input3) => client.listAgentManifestSnapshots(agentId, input3),
+    requestSourceChecks: (agentId, input3) => client.requestAgentSourceChecks(agentId, input3),
+    publishSource: (agentId, input3) => client.publishAgentSource(agentId, input3),
+    openEditWorkItem: (agentId, input3) => client.openAgentEditWorkItem(agentId, input3)
+  };
+}
+function createSandboxWorkItemNamespace(client) {
+  return {
+    get: (workItemId, input3) => client.getCodingWorkItem(workItemId, input3),
+    chat: (workItemId, input3) => client.sendCodingWorkItemChat(workItemId, input3),
+    activity: (workItemId, input3) => client.listCodingWorkItemActivity(workItemId, input3),
+    status: (workItemId, input3) => client.getCodingWorkItemStatus(workItemId, input3),
+    handleBackground: (workItemId, input3) => client.handleCodingWorkItemInBackground(workItemId, input3),
+    promoteCheckpoint: (workItemId, input3) => client.promoteCodingWorkItemResult(workItemId, "checkpoint", input3),
+    promoteCommit: (workItemId, input3) => client.promoteCodingWorkItemResult(workItemId, "commit", input3),
+    promotePullRequest: (workItemId, input3) => client.promoteCodingWorkItemResult(workItemId, "pr", input3)
+  };
+}
+
+// ../../packages/cloud/src/sandbox/runtime-handle.ts
+function createSandboxRuntimeHandle(client, runtimeId, initial = null) {
+  const currentSandbox = async (input3 = {}, options = {}) => {
+    const runtime = await client.getSandboxRuntime(runtimeId);
+    if (runtime.sandboxId) {
+      return client.get(runtime.sandboxId);
+    }
+    return client.createSandboxRuntimeSandbox(runtimeId, input3, options).then((payload) => payload.sandbox);
+  };
+  const resume = async (input3 = {}, options = {}) => {
+    const runtime = await client.getSandboxRuntime(runtimeId);
+    if (!runtime.sandboxId) {
+      return client.createSandboxRuntimeSandbox(runtimeId, input3, options).then((payload) => payload.sandbox);
+    }
+    const sandbox = await client.get(runtime.sandboxId);
+    if (sandbox.state === "stopped") {
+      return client.start(sandbox.id, options).then((payload) => payload.sandbox);
+    }
+    if (sandbox.state === "archived") {
+      return client.restore(sandbox.id).then((payload) => payload.sandbox);
+    }
+    if (sandbox.state === "deleted" || sandbox.state === "error") {
+      return client.createSandboxRuntimeSandbox(runtimeId, input3, options).then((payload) => payload.sandbox);
+    }
+    return sandbox;
+  };
+  const checkpointHint = (input3 = {}) => client.emitSandboxRuntimeEvent(runtimeId, {
+    type: "workflow.checkpoint_hint",
+    summary: input3.summary ?? input3.reason ?? "Workflow checkpoint hint",
+    payload: {
+      ...input3.payload,
+      reason: input3.reason ?? null
+    },
+    artifactRefs: input3.artifactRefs,
+    lifecycleHint: {
+      kind: "checkpoint",
+      reason: input3.reason ?? null
+    }
+  });
+  const waitForUser = async (input3 = {}) => {
+    await client.emitSandboxRuntimeEvent(runtimeId, {
+      type: "workflow.waiting_for_user",
+      summary: input3.summary ?? input3.reason ?? "Waiting for user",
+      payload: {
+        ...input3.payload,
+        reason: input3.reason ?? null
+      },
+      lifecycleHint: {
+        kind: "waiting_for_user",
+        reason: input3.reason ?? null
+      }
+    });
+    const current = await client.getSandboxRuntime(runtimeId);
+    if (current.status === "waiting_for_user") return current;
+    return client.updateSandboxRuntimeStatus(runtimeId, {
+      status: "waiting_for_user",
+      expectedVersion: current.version,
+      summary: input3.summary ?? input3.reason,
+      metadata: {
+        workflowWaitForUserReason: input3.reason ?? null
+      }
+    });
+  };
+  const keepAlive = (input3 = {}) => {
+    const keepaliveUntil = runtimeKeepaliveUntilIso(input3);
+    return client.emitSandboxRuntimeEvent(runtimeId, {
+      type: "workflow.keepalive",
+      summary: input3.summary ?? input3.reason ?? "Workflow keepalive",
+      payload: {
+        ...input3.payload,
+        reason: input3.reason ?? null,
+        keepaliveUntil
+      },
+      lifecycleHint: {
+        kind: "keepalive",
+        reason: input3.reason ?? null,
+        keepaliveUntil
+      }
+    });
+  };
+  return {
+    id: runtimeId,
+    initial,
+    get: () => client.getSandboxRuntime(runtimeId),
+    sandbox: currentSandbox,
+    resume,
+    createSandbox: (input3 = {}, options = {}) => client.createSandboxRuntimeSandbox(runtimeId, input3, options),
+    status: async (input3) => {
+      if (typeof input3 !== "string") {
+        return client.updateSandboxRuntimeStatus(runtimeId, input3);
+      }
+      const current = await client.getSandboxRuntime(runtimeId);
+      return client.updateSandboxRuntimeStatus(runtimeId, {
+        status: input3,
+        expectedVersion: current.version
+      });
+    },
+    events: () => client.listSandboxRuntimeEvents(runtimeId),
+    event: (input3) => client.emitSandboxRuntimeEvent(runtimeId, input3),
+    recordCommit: (commitSha, input3 = {}) => client.emitSandboxRuntimeEvent(runtimeId, {
+      ...input3,
+      type: input3.type ?? "git.commit",
+      commitSha
+    }),
+    checkpointHint,
+    waitForUser,
+    keepAlive,
+    checkpoint: (input3) => client.checkpointSandboxRuntime(runtimeId, input3),
+    files: {
+      write: async (path4, contents) => client.uploadFile((await resume()).id, path4, contents),
+      read: async (path4) => client.downloadFile((await resume()).id, path4),
+      readResponse: async (input3) => client.downloadFileResponse((await resume()).id, input3),
+      list: async (input3 = {}) => client.listFiles((await resume()).id, input3),
+      delete: async (path4, input3 = {}) => client.deleteFile((await resume()).id, path4, input3),
+      search: async (input3) => client.searchFiles((await resume()).id, input3),
+      stat: async (path4) => client.statFile((await resume()).id, path4),
+      mkdir: async (input3) => client.mkdir((await resume()).id, input3),
+      move: async (input3) => client.moveFile((await resume()).id, input3)
+    },
+    commands: {
+      run: async (command) => client.exec(
+        (await resume()).id,
+        typeof command === "string" ? { command } : command
+      )
+    },
+    ports: {
+      expose: async (port) => client.openPort(
+        (await resume()).id,
+        typeof port === "number" ? { port } : port
+      )
+    },
+    promote: (input3, options = {}) => client.promoteSandboxRuntime(runtimeId, input3, options),
+    preserveSource: (input3 = {}, options = {}) => client.preserveSandboxRuntimeSource(runtimeId, input3, options),
+    archive: async (expectedVersion) => {
+      const version = expectedVersion ?? (await client.getSandboxRuntime(runtimeId)).version;
+      return client.updateSandboxRuntimeStatus(runtimeId, {
+        status: "archived",
+        expectedVersion: version
+      });
+    }
+  };
+}
+function runtimeKeepaliveUntilIso(input3) {
+  if (input3?.until instanceof Date) {
+    return input3.until.toISOString();
+  }
+  if (typeof input3?.until === "string" && input3.until.trim()) {
+    return new Date(input3.until).toISOString();
+  }
+  const seconds = typeof input3?.seconds === "number" && Number.isFinite(input3.seconds) ? Math.max(1, Math.trunc(input3.seconds)) : 60;
+  return new Date(Date.now() + seconds * 1e3).toISOString();
+}
+
+// ../../packages/cloud/src/sandbox/smoke.ts
+async function runSandboxSmoke(client, options = {}) {
+  const runId = `openpond-code-smoke-${Date.now()}`;
+  const expectedExec = `openpond-code-exec-ok:${runId}`;
+  const expectedPreview = `openpond-code-preview-ok:${runId}`;
+  const expectedFile = `openpond-code-file-ok:${runId}`;
+  const previewPort = 4173;
+  let sandboxId = null;
+  let forkSandboxId = null;
+  let deleted = false;
+  let forkDeleted = false;
+  try {
+    const sandbox = await waitForCreateReady(
+      client,
+      await client.create(
+        {
+          repo: options.repo ?? "https://github.com/octocat/Hello-World",
+          resources: {
+            cpu: options.cpu ?? 1,
+            memoryGb: options.memoryGb ?? 1,
+            diskGb: options.diskGb ?? 8
+          },
+          budget: { maxUsd: options.budgetUsd ?? "0.05" },
+          quotas: {
+            maxSpendUsd: options.budgetUsd ?? "0.05",
+            maxDurationSeconds: 600,
+            idleTimeoutSeconds: 600,
+            maxOpenPorts: 2
+          },
+          metadata: {
+            runId,
+            source: "openpond-code-sandbox-smoke"
+          }
+        },
+        { async: true }
+      )
+    );
+    sandboxId = sandbox.id;
+    const expectedRuntimeDriver = options.expectedRuntimeDriver ?? "remote-firecracker";
+    if (sandbox.runtimeDriver !== expectedRuntimeDriver) {
+      throw new Error(
+        `expected ${expectedRuntimeDriver}, got ${sandbox.runtimeDriver}`
+      );
+    }
+    const expectedMppMode = options.expectedMppMode;
+    if (expectedMppMode && sandbox.reservation.mpp?.mode !== expectedMppMode) {
+      throw new Error(
+        `expected ${expectedMppMode} reservation, got ${sandbox.reservation.mpp?.mode ?? "none"}`
+      );
+    }
+    if (!expectedMppMode && !sandbox.reservation.mpp?.mode) {
+      throw new Error("expected sandbox reservation MPP metadata");
+    }
+    const exec = await client.exec(sandbox.id, {
+      command: [
+        `printf '${expectedExec}\\n'`,
+        "test -f README && printf 'repo-clone-ok\\n'",
+        "cat > server.cjs <<'EOF'",
+        "const { createServer } = require('node:http');",
+        `createServer((_request, response) => response.end('${expectedPreview}')).listen(${previewPort}, '0.0.0.0');`,
+        "EOF",
+        "nohup node server.cjs > server.log 2>&1 & sleep 1"
+      ].join("\n"),
+      timeoutSeconds: 120
+    });
+    if (exec.command.status !== "succeeded") {
+      throw new Error(`expected command success, got ${exec.command.status}`);
+    }
+    if (!exec.command.output.includes(expectedExec)) {
+      throw new Error("expected exec marker");
+    }
+    await client.uploadFile(
+      sandbox.id,
+      "openpond-code-smoke.txt",
+      expectedFile
+    );
+    const downloaded = await client.downloadFile(
+      sandbox.id,
+      "openpond-code-smoke.txt"
+    );
+    if (downloaded !== expectedFile) {
+      throw new Error("expected file roundtrip marker");
+    }
+    let snapshotId = null;
+    if (options.snapshot || options.fork) {
+      const snapshotResponse = await client.createSnapshot(sandbox.id, {
+        async: true,
+        name: `openpond-code-smoke-${runId}`,
+        replay: {
+          entrypoints: [
+            {
+              command: "cat openpond-code-smoke.txt",
+              name: "default"
+            }
+          ],
+          retention: {
+            class: "pinned"
+          },
+          safety: {
+            cleanup: "delete",
+            idleTimeoutSeconds: 600,
+            internetEgress: "block",
+            maxDurationSeconds: 600,
+            maxSpendUsd: options.budgetUsd ?? "0.05",
+            publicPreview: false
+          },
+          validation: {
+            commands: [
+              {
+                command: "test -f openpond-code-smoke.txt"
+              }
+            ]
+          }
+        }
+      });
+      const snapshot = snapshotResponse.snapshot ?? (await waitForSnapshotReady(
+        client,
+        sandbox.id,
+        snapshotResponse.snapshotJob?.snapshotId
+      )).snapshot;
+      snapshotId = snapshot.id;
+      if (snapshot.state !== "ready") {
+        throw new Error(`expected ready snapshot, got ${snapshot.state}`);
+      }
+    }
+    if (options.fork) {
+      if (!snapshotId) {
+        throw new Error("expected snapshot id before fork");
+      }
+      const forked = await waitForCreateReady(
+        client,
+        (await client.forkSnapshot(
+          snapshotId,
+          {
+            budget: { maxUsd: options.budgetUsd ?? "0.05" },
+            metadata: {
+              source: "openpond-code-sandbox-smoke-fork",
+              templateSnapshotId: snapshotId
+            }
+          },
+          { async: true }
+        )).sandbox
+      );
+      forkSandboxId = forked.id;
+      const forkExec = await client.exec(forked.id, {
+        command: "cat openpond-code-smoke.txt",
+        timeoutSeconds: 120
+      });
+      if (forkExec.command.status !== "succeeded") {
+        throw new Error(
+          `expected fork command success, got ${forkExec.command.status}`
+        );
+      }
+      if (!forkExec.command.output.includes(expectedFile)) {
+        throw new Error("expected fork snapshot marker");
+      }
+      if (!options.keep) {
+        await deleteSandboxForSmoke(client, forked.id);
+        forkDeleted = true;
+      }
+    }
+    let previewStatus = null;
+    if (options.preview !== false) {
+      const opened = await client.openPort(sandbox.id, {
+        label: "openpond-code-smoke",
+        port: previewPort
+      });
+      const preview = await fetch(opened.preview.url);
+      previewStatus = preview.status;
+      const body = await preview.text();
+      if (preview.status !== 200) {
+        throw new Error(`expected preview HTTP 200, got ${preview.status}`);
+      }
+      if (!body.includes(expectedPreview)) {
+        throw new Error("expected preview marker");
+      }
+    }
+    const { sandbox: readback, receipts } = await stopSandboxForSmoke(
+      client,
+      sandbox.id
+    );
+    if (!options.keep) {
+      await deleteSandboxForSmoke(client, sandbox.id);
+      deleted = true;
+    }
+    return {
+      deleted,
+      execOutput: exec.command.output.trim(),
+      fileRoundtrip: true,
+      forkSandboxId,
+      previewStatus,
+      receiptRefs: receipts.map((receipt) => receipt.mpp.receiptRef ?? null),
+      reservationRef: sandbox.reservation.mpp?.reservationRef ?? null,
+      runId,
+      sandboxId: sandbox.id,
+      snapshotId,
+      state: readback.state
+    };
+  } finally {
+    if (forkSandboxId && !options.keep && !forkDeleted) {
+      await cleanupSandboxBestEffort(client, forkSandboxId);
+    }
+    if (sandboxId && !options.keep && !deleted) {
+      await cleanupSandboxBestEffort(client, sandboxId);
+    }
+  }
+}
+async function stopSandboxForSmoke(client, sandboxId) {
+  try {
+    await client.stop(sandboxId);
+  } catch {
+    await client.stop(sandboxId, { async: true });
+  }
+  const sandbox = await waitForSandboxState(
+    client,
+    sandboxId,
+    /* @__PURE__ */ new Set(["stopped", "deleted"]),
+    "stop"
+  );
+  const receipts = await waitForReceipts(client, sandboxId);
+  if (receipts.length === 0) {
+    throw new Error("expected receipt readback");
+  }
+  return { sandbox, receipts };
+}
+async function deleteSandboxForSmoke(client, sandboxId) {
+  try {
+    const deleted = await client.delete(sandboxId);
+    if (deleted.state === "deleted") {
+      return deleted;
+    }
+    await client.delete(sandboxId, { async: true });
+  } catch {
+    await client.delete(sandboxId, { async: true });
+  }
+  return waitForSandboxState(
+    client,
+    sandboxId,
+    /* @__PURE__ */ new Set(["deleted"]),
+    "delete"
+  );
+}
+async function cleanupSandboxBestEffort(client, sandboxId) {
+  try {
+    await deleteSandboxForSmoke(client, sandboxId);
+  } catch {
+    await client.delete(sandboxId, { async: true }).catch(() => void 0);
+  }
+}
+async function waitForSandboxState(client, sandboxId, targetStates, operation) {
+  const timeoutMs = 5 * 6e4;
+  const pollMs = 3e3;
+  const deadline = Date.now() + timeoutMs;
+  let latest = await client.get(sandboxId);
+  while (Date.now() < deadline) {
+    if (targetStates.has(latest.state)) {
+      return latest;
+    }
+    if (latest.state === "error") {
+      throw new Error(`sandbox ${operation} failed: ${sandboxId}`);
+    }
+    await sleep(pollMs);
+    latest = await client.get(sandboxId);
+  }
+  throw new Error(
+    `sandbox ${operation} did not reach ${[...targetStates].join(
+      "/"
+    )} before timeout: ${sandboxId} (${latest.state})`
+  );
+}
+async function waitForReceipts(client, sandboxId) {
+  const timeoutMs = 2 * 6e4;
+  const pollMs = 3e3;
+  const deadline = Date.now() + timeoutMs;
+  let receipts = await client.receipts(sandboxId);
+  while (Date.now() < deadline) {
+    if (receipts.length > 0) {
+      return receipts;
+    }
+    await sleep(pollMs);
+    receipts = await client.receipts(sandboxId);
+  }
+  return receipts;
+}
+async function waitForCreateReady(client, sandbox) {
+  if (sandbox.state === "running" || sandbox.state === "stopped") {
+    return sandbox;
+  }
+  if (sandbox.state === "error") {
+    throw new Error(
+      `sandbox create failed: ${sandbox.id}
+${sandbox.logs.join("\n")}`
+    );
+  }
+  const timeoutMs = 12 * 6e4;
+  const pollMs = 3e3;
+  const deadline = Date.now() + timeoutMs;
+  let latest = sandbox;
+  while (Date.now() < deadline) {
+    await sleep(pollMs);
+    latest = await client.get(sandbox.id);
+    if (latest.state === "running" || latest.state === "stopped") {
+      return latest;
+    }
+    if (latest.state === "error") {
+      throw new Error(
+        `sandbox create failed: ${latest.id}
+${latest.logs.join("\n")}`
+      );
+    }
+  }
+  throw new Error(
+    `sandbox create did not reach running state before timeout: ${latest.id} (${latest.state})`
+  );
+}
+async function waitForSnapshotReady(client, sandboxId, snapshotId) {
+  if (!snapshotId) {
+    throw new Error("snapshot job did not return snapshot id");
+  }
+  const timeoutMs = 12 * 6e4;
+  const pollMs = 3e3;
+  const deadline = Date.now() + timeoutMs;
+  let latest = await client.get(sandboxId);
+  while (Date.now() < deadline) {
+    const snapshot = latest.snapshots?.find((item) => item.id === snapshotId);
+    if (snapshot?.state === "ready") {
+      return { sandbox: latest, snapshot };
+    }
+    const job = latest.snapshotJobs?.find(
+      (item) => item.snapshotId === snapshotId
+    );
+    if (job?.status === "failed") {
+      throw new Error(`snapshot job failed: ${job.error ?? snapshotId}`);
+    }
+    await sleep(pollMs);
+    latest = await client.get(sandboxId);
+  }
+  throw new Error(
+    `snapshot did not reach ready state before timeout: ${snapshotId}`
+  );
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// ../../packages/cloud/src/sandbox/async-request-options.ts
+function asyncRequestHeaders(options = {}) {
+  return options.async || options.respondAsync ? { Prefer: "respond-async" } : void 0;
+}
+
+// ../../packages/cloud/src/sandbox/stream.ts
+async function streamSandboxEventOutput(params) {
+  const response = await apiFetch(
+    params.sandboxApiUrl,
+    params.apiKey,
+    params.path,
+    { timeoutMs: 0, maxResponseBytes: 0 }
+  );
+  if (!response.body) {
+    return;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffered = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffered += decoder.decode(value, { stream: true });
+      let separatorIndex = buffered.indexOf("\n\n");
+      while (separatorIndex !== -1) {
+        const event = buffered.slice(0, separatorIndex);
+        buffered = buffered.slice(separatorIndex + 2);
+        const output3 = parseProcessOutputEvent(event);
+        if (output3) process.stdout.write(output3);
+        separatorIndex = buffered.indexOf("\n\n");
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function normalizePtyInput(input3) {
+  if (typeof input3 === "string") {
+    return { dataBase64: Buffer.from(input3, "utf-8").toString("base64") };
+  }
+  if (input3 instanceof Uint8Array) {
+    return { dataBase64: Buffer.from(input3).toString("base64") };
+  }
+  return input3;
+}
+function parseProcessOutputEvent(event) {
+  if (!event.includes("event: output")) {
+    return null;
+  }
+  const dataLines = event.split(/\r?\n/).filter((line) => line.startsWith("data: ")).map((line) => line.slice("data: ".length));
+  if (dataLines.length === 0) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(dataLines.join("\n"));
+    return typeof parsed.output === "string" ? parsed.output : null;
+  } catch {
+    return null;
+  }
+}
+
+// ../../packages/cloud/src/sandbox/url.ts
+function normalizeSandboxApiUrl(baseUrlOrApiUrl) {
+  const trimmed = baseUrlOrApiUrl.trim().replace(/\/$/, "");
+  if (!trimmed) {
+    throw new Error("sandbox API URL must be non-empty");
+  }
+  const url = new URL(trimmed);
+  const normalizedPath = url.pathname.replace(/\/$/, "");
+  if (normalizedPath.endsWith("/v1/sandboxes") || normalizedPath.endsWith("/api/sandboxes")) {
+    return `${url.origin}${normalizedPath}`;
+  }
+  if (normalizedPath.endsWith("/v1")) {
+    return `${url.origin}${normalizedPath}/sandboxes`;
+  }
+  if (isOpenPondHostedApiHost(url.hostname)) {
+    return `${url.origin}${normalizedPath}/v1/sandboxes`;
+  }
+  if (url.origin === DEFAULT_OPENPOND_WEB_BASE_URL) {
+    return `${DEFAULT_OPENPOND_API_BASE_URL}/v1/sandboxes`;
+  }
+  return `${url.origin}${normalizedPath}/api/sandboxes`;
+}
+function apiRootUrlFromSandboxApiUrl(sandboxApiUrl) {
+  const suffix = "/sandboxes";
+  if (!sandboxApiUrl.endsWith(suffix)) {
+    throw new Error("sandbox API URL must end with /sandboxes");
+  }
+  return sandboxApiUrl.slice(0, -suffix.length);
+}
+function isOpenPondHostedApiHost(hostname) {
+  return hostname === "api.openpond.ai" || hostname.startsWith("api") && hostname.endsWith(".openpond.ai");
+}
+
+// ../../packages/cloud/src/sandbox/sandbox-instance-client.ts
+var OpenPondSandboxInstanceClient = class {
+  apiKey;
+  apiRootUrl;
+  sandboxApiUrl;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.sandboxApiUrl = normalizeSandboxApiUrl(
+      options.sandboxApiUrl ?? options.baseUrl ?? DEFAULT_OPENPOND_API_BASE_URL
+    );
+    this.apiRootUrl = apiRootUrlFromSandboxApiUrl(this.sandboxApiUrl);
+  }
+  create(input3, options = {}) {
+    return this.request("", {
+      method: "POST",
+      headers: asyncRequestHeaders(options),
+      body: JSON.stringify(input3)
+    }).then((payload) => payload.sandbox);
+  }
+  get(sandboxId) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}`
+    ).then((payload) => payload.sandbox);
+  }
+  exec(sandboxId, input3) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/exec`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  startProcess(sandboxId, input3) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/processes`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  listProcesses(sandboxId) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/processes`
+    );
+  }
+  getProcess(sandboxId, processId, input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.since !== void 0)
+      query.set("since", String(Math.max(0, input3.since)));
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/processes/${encodeURIComponent(
+        processId
+      )}${query.size > 0 ? `?${query.toString()}` : ""}`
+    );
+  }
+  stopProcess(sandboxId, processId) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/processes/${encodeURIComponent(
+        processId
+      )}`,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+  async streamProcessOutput(sandboxId, processId, input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.since !== void 0)
+      query.set("since", String(Math.max(0, input3.since)));
+    await streamSandboxEventOutput({
+      sandboxApiUrl: this.sandboxApiUrl,
+      apiKey: this.apiKey,
+      path: `/${encodeURIComponent(sandboxId)}/processes/${encodeURIComponent(
+        processId
+      )}/stream${query.size > 0 ? `?${query.toString()}` : ""}`
+    });
+  }
+  startPty(sandboxId, input3 = {}) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/pty`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  listPtys(sandboxId) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/pty`
+    );
+  }
+  getPty(sandboxId, ptyId, input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.since !== void 0)
+      query.set("since", String(Math.max(0, input3.since)));
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/pty/${encodeURIComponent(ptyId)}${query.size > 0 ? `?${query.toString()}` : ""}`
+    );
+  }
+  writePtyInput(sandboxId, ptyId, input3) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/pty/${encodeURIComponent(
+        ptyId
+      )}/input`,
+      {
+        method: "POST",
+        body: JSON.stringify(normalizePtyInput(input3))
+      }
+    );
+  }
+  stopPty(sandboxId, ptyId) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/pty/${encodeURIComponent(ptyId)}`,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+  async streamPtyOutput(sandboxId, ptyId, input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.since !== void 0)
+      query.set("since", String(Math.max(0, input3.since)));
+    await streamSandboxEventOutput({
+      sandboxApiUrl: this.sandboxApiUrl,
+      apiKey: this.apiKey,
+      path: `/${encodeURIComponent(sandboxId)}/pty/${encodeURIComponent(
+        ptyId
+      )}/stream${query.size > 0 ? `?${query.toString()}` : ""}`
+    });
+  }
+  uploadFile(sandboxId, path4, contents) {
+    return this.uploadFileBase64(
+      sandboxId,
+      path4,
+      Buffer.from(contents, "utf-8").toString("base64")
+    );
+  }
+  uploadFileBase64(sandboxId, path4, contentsBase64) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/files`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          path: path4,
+          contentsBase64
+        })
+      }
+    );
+  }
+  async downloadFile(sandboxId, path4) {
+    const payload = await this.downloadFileResponse(sandboxId, path4);
+    return Buffer.from(payload.file.contentsBase64, "base64").toString("utf-8");
+  }
+  downloadFileResponse(sandboxId, input3) {
+    const normalized = typeof input3 === "string" ? { path: input3 } : input3;
+    const query = new URLSearchParams({ path: normalized.path });
+    if (normalized.offsetBytes !== void 0) {
+      query.set("offsetBytes", String(normalized.offsetBytes));
+    }
+    if (normalized.maxBytes !== void 0) {
+      query.set("maxBytes", String(normalized.maxBytes));
+    }
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/files?${query.toString()}`
+    );
+  }
+  listFiles(sandboxId, input3 = {}) {
+    const query = new URLSearchParams({ list: "1" });
+    if (input3.path) query.set("path", input3.path);
+    if (input3.recursive !== void 0)
+      query.set("recursive", String(input3.recursive));
+    if (input3.maxEntries !== void 0)
+      query.set("maxEntries", String(input3.maxEntries));
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/files?${query.toString()}`
+    );
+  }
+  deleteFile(sandboxId, path4, input3 = {}) {
+    const query = new URLSearchParams({ path: path4 });
+    if (input3.recursive !== void 0)
+      query.set("recursive", String(input3.recursive));
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/files?${query.toString()}`,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+  statFile(sandboxId, path4) {
+    const query = new URLSearchParams({ stat: "1", path: path4 });
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/files?${query.toString()}`
+    );
+  }
+  mkdir(sandboxId, input3) {
+    const normalized = typeof input3 === "string" ? { path: input3 } : input3;
+    const query = new URLSearchParams({ path: normalized.path });
+    if (normalized.recursive !== void 0)
+      query.set("recursive", String(normalized.recursive));
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/files?${query.toString()}`,
+      {
+        method: "PUT"
+      }
+    );
+  }
+  moveFile(sandboxId, input3) {
+    const query = new URLSearchParams({
+      fromPath: input3.fromPath,
+      toPath: input3.toPath
+    });
+    if (input3.overwrite !== void 0)
+      query.set("overwrite", String(input3.overwrite));
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/files?${query.toString()}`,
+      {
+        method: "PATCH"
+      }
+    );
+  }
+  searchFiles(sandboxId, input3) {
+    const query = new URLSearchParams({
+      search: "1",
+      query: input3.query
+    });
+    if (input3.path) query.set("path", input3.path);
+    if (input3.maxResults !== void 0)
+      query.set("maxResults", String(input3.maxResults));
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/files?${query.toString()}`
+    );
+  }
+  openPort(sandboxId, input3) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/ports`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  createSnapshot(sandboxId, input3) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/snapshots`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  updateSnapshot(sandboxId, snapshotId, input3) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/snapshots/${encodeURIComponent(
+        snapshotId
+      )}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  validateSnapshot(sandboxId, snapshotId, input3 = {}) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/snapshots/${encodeURIComponent(
+        snapshotId
+      )}/validate`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  publishSnapshot(sandboxId, snapshotId) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/snapshots/${encodeURIComponent(
+        snapshotId
+      )}/publish`,
+      {
+        method: "POST"
+      }
+    );
+  }
+  fork(sandboxId, input3 = {}) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/fork`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  stop(sandboxId, options = {}) {
+    const query = new URLSearchParams();
+    if (options.failOnUnpreservedChanges) {
+      query.set("failOnUnpreservedChanges", "true");
+    }
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/stop${query.size > 0 ? `?${query.toString()}` : ""}`,
+      {
+        method: "POST",
+        headers: asyncRequestHeaders(options)
+      }
+    );
+  }
+  start(sandboxId, options = {}) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/start`,
+      {
+        method: "POST",
+        headers: asyncRequestHeaders(options)
+      }
+    );
+  }
+  restore(sandboxId) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/restore`,
+      {
+        method: "POST"
+      }
+    );
+  }
+  delete(sandboxId, options = {}) {
+    const query = new URLSearchParams();
+    if (options.failOnUnpreservedChanges) {
+      query.set("failOnUnpreservedChanges", "true");
+    }
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}${query.size > 0 ? `?${query.toString()}` : ""}`,
+      {
+        method: "DELETE",
+        headers: asyncRequestHeaders(options)
+      }
+    ).then((payload) => payload.sandbox);
+  }
+  receipts(sandboxId) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/receipts`
+    ).then((payload) => payload.receipts);
+  }
+  logs(sandboxId) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/logs`
+    ).then((payload) => payload.logs);
+  }
+  gitStatus(sandboxId) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/git/status`
+    );
+  }
+  gitDiff(sandboxId, input3 = {}) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/git/diff`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  gitExportPatch(sandboxId, input3 = {}) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/git/export-patch`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  gitBranch(sandboxId, input3) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/git/branch`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  gitCommit(sandboxId, input3) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/git/commit`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  gitPull(sandboxId, input3 = {}) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/git/pull`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  gitPush(sandboxId, input3 = {}) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/git/push`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  billing(sandboxId) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/billing`
+    );
+  }
+  pricing() {
+    return this.request("/pricing");
+  }
+  costs(input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    if (input3.agentId) query.set("agentId", input3.agentId);
+    return this.request(
+      `/costs${query.size > 0 ? `?${query.toString()}` : ""}`
+    );
+  }
+  integrationLeases(sandboxId) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/integrations`
+    );
+  }
+  attachIntegrationConnection(sandboxId, input3) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/integrations`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  removeIntegrationLease(sandboxId, leaseId) {
+    return this.request(
+      `/${encodeURIComponent(sandboxId)}/integrations`,
+      {
+        method: "DELETE",
+        body: JSON.stringify({ leaseId })
+      }
+    );
+  }
+  async request(path4, init = {}) {
+    const response = await apiFetch(
+      this.sandboxApiUrl,
+      this.apiKey,
+      path4,
+      init
+    );
+    return readApiJson(response, "Sandbox request");
+  }
+  async requestApiRoot(path4, init = {}) {
+    const response = await apiFetch(this.apiRootUrl, this.apiKey, path4, init);
+    return readApiJson(response, "OpenPond API request");
+  }
+};
+
+// ../../packages/cloud/src/sandbox/client.ts
+var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
+  runtimes = createSandboxRuntimeNamespace(this);
+  sandboxes = createSandboxNamespace(this);
+  profile = createSandboxProfileNamespace(this);
+  projects = createSandboxProjectNamespace(this);
+  agents = createSandboxAgentNamespace(this);
+  workItems = createSandboxWorkItemNamespace(this);
+  list(input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    if (input3.agentId) query.set("agentId", input3.agentId);
+    return this.request(
+      query.size > 0 ? `?${query.toString()}` : ""
+    ).then((payload) => payload.sandboxes);
+  }
+  listSecrets(input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    return this.requestApiRoot(
+      `/sandbox-secrets${query.size > 0 ? `?${query.toString()}` : ""}`
+    ).then((payload) => payload.secrets);
+  }
+  getSecret(secretId, input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    return this.requestApiRoot(
+      `/sandbox-secrets/${encodeURIComponent(secretId)}${query.size > 0 ? `?${query.toString()}` : ""}`
+    ).then((payload) => payload.secret);
+  }
+  createSecret(input3) {
+    return this.requestApiRoot("/sandbox-secrets", {
+      method: "POST",
+      body: JSON.stringify(input3)
+    }).then((payload) => payload.secret);
+  }
+  rotateSecret(secretId, input3) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    const { teamId: _teamId, ...body } = input3;
+    return this.requestApiRoot(
+      `/sandbox-secrets/${encodeURIComponent(secretId)}/rotate${query.size > 0 ? `?${query.toString()}` : ""}`,
+      {
+        method: "POST",
+        body: JSON.stringify(body)
+      }
+    ).then((payload) => payload.secret);
+  }
+  attachSecret(secretId, input3) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    const { teamId: _teamId, ...body } = input3;
+    return this.requestApiRoot(
+      `/sandbox-secrets/${encodeURIComponent(secretId)}/attach${query.size > 0 ? `?${query.toString()}` : ""}`,
+      {
+        method: "POST",
+        body: JSON.stringify(body)
+      }
+    ).then((payload) => payload.secret);
+  }
+  revokeSecret(secretId, input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    return this.requestApiRoot(
+      `/sandbox-secrets/${encodeURIComponent(secretId)}/revoke${query.size > 0 ? `?${query.toString()}` : ""}`,
+      { method: "POST" }
+    ).then((payload) => payload.secret);
+  }
+  deleteSecret(secretId, input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    return this.requestApiRoot(
+      `/sandbox-secrets/${encodeURIComponent(secretId)}${query.size > 0 ? `?${query.toString()}` : ""}`,
+      { method: "DELETE" }
+    ).then((payload) => payload.secret);
+  }
+  snapshotCatalog(input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    if (input3.agentId) query.set("agentId", input3.agentId);
+    if (input3.q) query.set("q", input3.q);
+    if (input3.kind) query.set("kind", input3.kind);
+    if (input3.replayState) query.set("replayState", input3.replayState);
+    if (input3.visibility) query.set("visibility", input3.visibility);
+    if (input3.tag) query.set("tag", input3.tag);
+    if (input3.useCase) query.set("useCase", input3.useCase);
+    if (input3.limit) query.set("limit", String(input3.limit));
+    return this.request(
+      `/catalog/snapshots${query.size > 0 ? `?${query.toString()}` : ""}`
+    );
+  }
+  listSandboxRuntimes(input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    if (input3.agentId) query.set("agentId", input3.agentId);
+    return this.requestApiRoot(
+      `/runtimes${query.size > 0 ? `?${query.toString()}` : ""}`
+    ).then((payload) => payload.runtimes);
+  }
+  listProjects(input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    return this.requestApiRoot(
+      `/projects?${query.toString()}`
+    ).then((payload) => payload.projects);
+  }
+  upsertProject(input3) {
+    return this.requestApiRoot("/projects", {
+      method: "POST",
+      body: JSON.stringify(input3)
+    }).then((payload) => payload.project);
+  }
+  getHostedProfile(input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    return this.requestApiRoot(
+      `/profile?${query.toString()}`
+    ).then((payload) => payload.profile);
+  }
+  ensureHostedProfile(input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    return this.requestApiRoot(
+      `/profile/ensure?${query.toString()}`,
+      { method: "POST" }
+    ).then((payload) => {
+      if (!payload.profile) {
+        throw new Error("hosted_profile_missing");
+      }
+      return payload.profile;
+    });
+  }
+  pushHostedProfile(input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    const { teamId: _teamId, ...body } = input3;
+    return this.requestApiRoot(
+      `/profile/push?${query.toString()}`,
+      {
+        method: "POST",
+        body: JSON.stringify(body)
+      }
+    );
+  }
+  async upsertProjectGitRemote(input3) {
+    const project = await this.upsertProject(input3);
+    return this.ensureProjectGitRemote(project.id, { teamId: input3.teamId });
+  }
+  getProject(projectId, input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    return this.requestApiRoot(
+      `/projects/${encodeURIComponent(projectId)}?${query.toString()}`
+    ).then((payload) => payload.project);
+  }
+  syncProject(projectId, input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    return this.requestApiRoot(
+      `/projects/${encodeURIComponent(projectId)}/sync?${query.toString()}`,
+      { method: "POST" }
+    ).then((payload) => payload.project);
+  }
+  ensureProjectGitRemote(projectId, input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    return this.requestApiRoot(
+      `/projects/${encodeURIComponent(projectId)}/git?${query.toString()}`,
+      { method: "POST" }
+    );
+  }
+  uploadProjectSource(projectId, input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    const { teamId: _teamId, ...body } = input3;
+    return this.requestApiRoot(
+      `/projects/${encodeURIComponent(projectId)}/source?${query.toString()}`,
+      {
+        method: "POST",
+        body: JSON.stringify(body)
+      }
+    ).then((payload) => payload.project);
+  }
+  updateProject(projectId, input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    const { teamId: _teamId, ...body } = input3;
+    return this.requestApiRoot(
+      `/projects/${encodeURIComponent(projectId)}?${query.toString()}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(body)
+      }
+    ).then((payload) => payload.project);
+  }
+  archiveProject(projectId, input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    return this.requestApiRoot(
+      `/projects/${encodeURIComponent(projectId)}?${query.toString()}`,
+      { method: "DELETE" }
+    ).then((payload) => payload.project);
+  }
+  listAgents(input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    return this.requestApiRoot(
+      `/agents?${query.toString()}`
+    ).then((payload) => payload.agents);
+  }
+  upsertAgent(input3) {
+    return this.requestApiRoot("/agents", {
+      method: "POST",
+      body: JSON.stringify(input3)
+    }).then((payload) => payload.agent);
+  }
+  getAgent(agentId, input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    return this.requestApiRoot(
+      `/agents/${encodeURIComponent(agentId)}?${query.toString()}`
+    ).then((payload) => payload.agent);
+  }
+  archiveAgent(agentId, input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    return this.requestApiRoot(
+      `/agents/${encodeURIComponent(agentId)}?${query.toString()}`,
+      { method: "DELETE" }
+    ).then((payload) => payload.agent);
+  }
+  updateAgent(agentId, input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    const { teamId: _teamId, ...body } = input3;
+    return this.requestApiRoot(
+      `/agents/${encodeURIComponent(agentId)}?${query.toString()}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(body)
+      }
+    ).then((payload) => payload.agent);
+  }
+  runAgent(agentId, input3) {
+    return this.requestApiRoot(
+      `/agents/${encodeURIComponent(agentId)}/run`,
+      {
+        method: "POST",
+        headers: {
+          Prefer: "respond-async"
+        },
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  getAgentSourceDeployPlan(agentId, input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    return this.requestApiRoot(
+      `/agents/${encodeURIComponent(
+        agentId
+      )}/source/deploy-plan?${query.toString()}`
+    ).then((payload) => payload.deployPlan);
+  }
+  listAgentManifestSnapshots(agentId, input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    if (input3.limit !== void 0) query.set("limit", String(input3.limit));
+    return this.requestApiRoot(
+      `/agents/${encodeURIComponent(
+        agentId
+      )}/source/manifest-snapshots?${query.toString()}`
+    ).then((payload) => payload.manifestSnapshots);
+  }
+  requestAgentSourceChecks(agentId, input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    const { teamId: _teamId, ...body } = input3;
+    return this.requestApiRoot(
+      `/agents/${encodeURIComponent(
+        agentId
+      )}/source/checks?${query.toString()}`,
+      {
+        method: "POST",
+        body: JSON.stringify(body)
+      }
+    );
+  }
+  publishAgentSource(agentId, input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    const { teamId: _teamId, ...body } = input3;
+    return this.requestApiRoot(
+      `/agents/${encodeURIComponent(
+        agentId
+      )}/source/publish?${query.toString()}`,
+      {
+        method: "POST",
+        body: JSON.stringify(body)
+      }
+    );
+  }
+  openAgentEditWorkItem(agentId, input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    const { teamId: _teamId, ...body } = input3;
+    return this.requestApiRoot(
+      `/agents/${encodeURIComponent(
+        agentId
+      )}/edit-work-item?${query.toString()}`,
+      {
+        method: "POST",
+        body: JSON.stringify(body)
+      }
+    );
+  }
+  getCodingWorkItem(workItemId, input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    if (input3.includeArchived) query.set("includeArchived", "true");
+    return this.requestApiRoot(
+      `/work-items/${encodeURIComponent(workItemId)}?${query.toString()}`
+    ).then((payload) => payload.workItem);
+  }
+  sendCodingWorkItemChat(workItemId, input3) {
+    return this.requestApiRoot(
+      `/work-items/${encodeURIComponent(workItemId)}/chat`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  listCodingWorkItemActivity(workItemId, input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    if (input3.limit !== void 0) query.set("limit", String(input3.limit));
+    return this.requestApiRoot(
+      `/work-items/${encodeURIComponent(
+        workItemId
+      )}/activity?${query.toString()}`
+    ).then((payload) => payload.activity);
+  }
+  getCodingWorkItemStatus(workItemId, input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    if (input3.limit !== void 0) query.set("limit", String(input3.limit));
+    if (input3.includeArchived) query.set("includeArchived", "true");
+    return this.requestApiRoot(
+      `/work-items/${encodeURIComponent(workItemId)}/status?${query.toString()}`
+    );
+  }
+  handleCodingWorkItemInBackground(workItemId, input3) {
+    return this.requestApiRoot(
+      `/work-items/${encodeURIComponent(workItemId)}/handle-background`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  promoteCodingWorkItemResult(workItemId, action, input3) {
+    return this.requestApiRoot(
+      `/work-items/${encodeURIComponent(workItemId)}/result/${action}`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    ).then((payload) => payload.artifact);
+  }
+  getMicrosoftTeamsBotOverview(input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    return this.requestApiRoot(
+      `/teams/bot/overview?${query.toString()}`
+    );
+  }
+  bindMicrosoftTeamsBotConversation(input3) {
+    return this.requestApiRoot(
+      "/teams/bot/bindings",
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  rebindMicrosoftTeamsBotConversation(bindingId, input3) {
+    return this.requestApiRoot(
+      `/teams/bot/bindings/${encodeURIComponent(bindingId)}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  unlinkMicrosoftTeamsBotConversation(input3) {
+    return this.requestApiRoot(
+      `/teams/bot/bindings/${encodeURIComponent(input3.bindingId)}`,
+      {
+        method: "DELETE",
+        body: JSON.stringify({ teamId: input3.teamId })
+      }
+    );
+  }
+  sendMicrosoftTeamsBotDiagnostic(input3) {
+    return this.requestApiRoot("/teams/bot/diagnostics", {
+      method: "POST",
+      body: JSON.stringify(input3)
+    });
+  }
+  sendMicrosoftTeamsBotDiagnosticRun(input3) {
+    return this.requestApiRoot(
+      "/teams/bot/diagnostics/run",
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  createSandboxRuntime(input3) {
+    return this.requestApiRoot("/runtimes", {
+      method: "POST",
+      body: JSON.stringify(input3)
+    }).then((payload) => payload.runtime);
+  }
+  sandboxRuntime(runtimeId, initial = null) {
+    return createSandboxRuntimeHandle(this, runtimeId, initial);
+  }
+  getSandboxRuntime(runtimeId) {
+    return this.requestApiRoot(
+      `/runtimes/${encodeURIComponent(runtimeId)}`
+    ).then((payload) => payload.runtime);
+  }
+  createSandboxRuntimeSandbox(runtimeId, input3 = {}, options = {}) {
+    return this.requestApiRoot(
+      `/runtimes/${encodeURIComponent(runtimeId)}/sandbox`,
+      {
+        method: "POST",
+        headers: asyncRequestHeaders(options),
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  updateSandboxRuntimeStatus(runtimeId, input3) {
+    return this.requestApiRoot(
+      `/runtimes/${encodeURIComponent(runtimeId)}/status`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(input3)
+      }
+    ).then((payload) => payload.runtime);
+  }
+  listSandboxRuntimeEvents(runtimeId) {
+    return this.requestApiRoot(
+      `/runtimes/${encodeURIComponent(runtimeId)}/events`
+    );
+  }
+  emitSandboxRuntimeEvent(runtimeId, input3) {
+    return this.requestApiRoot(
+      `/runtimes/${encodeURIComponent(runtimeId)}/events`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  checkpointSandboxRuntime(runtimeId, input3) {
+    return this.requestApiRoot(
+      `/runtimes/${encodeURIComponent(runtimeId)}/checkpoints`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    ).then((payload) => payload.runtime);
+  }
+  promoteSandboxRuntime(runtimeId, input3, options = {}) {
+    const query = new URLSearchParams();
+    if (options.teamId) query.set("teamId", options.teamId);
+    return this.requestApiRoot(
+      `/runtimes/${encodeURIComponent(runtimeId)}/promote${query.size > 0 ? `?${query.toString()}` : ""}`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  preserveSandboxRuntimeSource(runtimeId, input3 = {}, options = {}) {
+    const query = new URLSearchParams();
+    if (options.teamId) query.set("teamId", options.teamId);
+    return this.requestApiRoot(
+      `/runtimes/${encodeURIComponent(runtimeId)}/preserve-source${query.size > 0 ? `?${query.toString()}` : ""}`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  forkSnapshot(snapshotId, input3 = {}, options = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    if (options.async) query.set("async", "1");
+    const { teamId: _teamId, projectId: _projectId, ...body } = input3;
+    return this.request(
+      `/catalog/snapshots/${encodeURIComponent(snapshotId)}/fork${query.size > 0 ? `?${query.toString()}` : ""}`,
+      {
+        method: "POST",
+        headers: options.async ? { Prefer: "respond-async" } : void 0,
+        body: JSON.stringify({
+          ...body,
+          snapshotId
+        })
+      }
+    );
+  }
+  templates(input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    if (input3.q) query.set("q", input3.q);
+    if (input3.name) query.set("name", input3.name);
+    if (input3.version) query.set("version", input3.version);
+    if (input3.visibility) query.set("visibility", input3.visibility);
+    if (input3.tag) query.set("tag", input3.tag);
+    if (input3.useCase) query.set("useCase", input3.useCase);
+    if (input3.limit) query.set("limit", String(input3.limit));
+    return this.request(
+      `/templates${query.size > 0 ? `?${query.toString()}` : ""}`
+    );
+  }
+  publishedSnapshots(input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    if (input3.q) query.set("q", input3.q);
+    if (input3.name) query.set("name", input3.name);
+    if (input3.version) query.set("version", input3.version);
+    if (input3.visibility) query.set("visibility", input3.visibility);
+    if (input3.tag) query.set("tag", input3.tag);
+    if (input3.useCase) query.set("useCase", input3.useCase);
+    if (input3.limit) query.set("limit", String(input3.limit));
+    return this.request(
+      `/published-snapshots${query.size > 0 ? `?${query.toString()}` : ""}`
+    ).then((payload) => {
+      const publishedSnapshots = payload.publishedSnapshots ?? payload.templates;
+      return {
+        ...payload,
+        templates: publishedSnapshots,
+        publishedSnapshots
+      };
+    });
+  }
+  launchTemplate(input3) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    const { teamId: _teamId, projectId: _projectId, ...body } = input3;
+    return this.request(
+      `/templates/launch${query.size > 0 ? `?${query.toString()}` : ""}`,
+      {
+        method: "POST",
+        body: JSON.stringify(body)
+      }
+    );
+  }
+  runPublishedSnapshot(input3) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    const { teamId: _teamId, projectId: _projectId, ...body } = input3;
+    return this.request(
+      `/published-snapshots/launch${query.size > 0 ? `?${query.toString()}` : ""}`,
+      {
+        method: "POST",
+        body: JSON.stringify(body)
+      }
+    ).then((payload) => {
+      const publishedSnapshot = payload.publishedSnapshot ?? payload.template;
+      return {
+        ...payload,
+        template: publishedSnapshot,
+        publishedSnapshot
+      };
+    });
+  }
+  listSchedules(input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    if (input3.sourceSandboxId)
+      query.set("sourceSandboxId", input3.sourceSandboxId);
+    return this.request(
+      `/schedules${query.size > 0 ? `?${query.toString()}` : ""}`
+    );
+  }
+  createSchedule(input3) {
+    const query = new URLSearchParams();
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    const { projectId: _projectId, ...body } = input3;
+    return this.request(
+      `/schedules${query.size > 0 ? `?${query.toString()}` : ""}`,
+      {
+        method: "POST",
+        body: JSON.stringify(body)
+      }
+    );
+  }
+  getSchedule(scheduleId) {
+    return this.request(
+      `/schedules/${encodeURIComponent(scheduleId)}`
+    );
+  }
+  updateSchedule(scheduleId, input3) {
+    return this.request(
+      `/schedules/${encodeURIComponent(scheduleId)}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  deleteSchedule(scheduleId) {
+    return this.request(
+      `/schedules/${encodeURIComponent(scheduleId)}`,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+  listScheduleRuns(scheduleId, input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.limit !== void 0) query.set("limit", String(input3.limit));
+    return this.request(
+      `/schedules/${encodeURIComponent(scheduleId)}/runs${query.size > 0 ? `?${query.toString()}` : ""}`
+    );
+  }
+  runScheduleNow(scheduleId, input3 = {}) {
+    return this.request(
+      `/schedules/${encodeURIComponent(scheduleId)}/run`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    );
+  }
+  listTemplateBuilds(input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    return this.requestApiRoot(
+      `/sandbox-template-builds?${query.toString()}`
+    ).then((payload) => payload.builds);
+  }
+  createTemplateBuild(input3) {
+    return this.requestApiRoot(
+      "/sandbox-template-builds",
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    ).then((payload) => payload.build);
+  }
+  getTemplateBuild(buildId) {
+    return this.requestApiRoot(
+      `/sandbox-template-builds/${encodeURIComponent(buildId)}`
+    ).then((payload) => payload.build);
+  }
+  getTemplateBuildLogs(buildId) {
+    return this.requestApiRoot(
+      `/sandbox-template-builds/${encodeURIComponent(buildId)}/logs`
+    );
+  }
+  cancelTemplateBuild(buildId) {
+    return this.requestApiRoot(
+      `/sandbox-template-builds/${encodeURIComponent(buildId)}/cancel`,
+      {
+        method: "POST"
+      }
+    ).then((payload) => payload.build);
+  }
+  listPublishedSnapshotBuilds(input3) {
+    const query = new URLSearchParams({ teamId: input3.teamId });
+    return this.requestApiRoot(
+      `/published-snapshot-builds?${query.toString()}`
+    ).then((payload) => payload.builds);
+  }
+  createPublishedSnapshotBuild(input3) {
+    return this.requestApiRoot(
+      "/published-snapshot-builds",
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    ).then((payload) => payload.build);
+  }
+  getPublishedSnapshotBuild(buildId) {
+    return this.requestApiRoot(
+      `/published-snapshot-builds/${encodeURIComponent(buildId)}`
+    ).then((payload) => payload.build);
+  }
+  getPublishedSnapshotBuildLogs(buildId) {
+    return this.requestApiRoot(
+      `/published-snapshot-builds/${encodeURIComponent(buildId)}/logs`
+    );
+  }
+  cancelPublishedSnapshotBuild(buildId) {
+    return this.requestApiRoot(
+      `/published-snapshot-builds/${encodeURIComponent(buildId)}/cancel`,
+      {
+        method: "POST"
+      }
+    ).then((payload) => payload.build);
+  }
+  listOrganizations() {
+    return this.requestApiRoot(
+      "/organizations"
+    ).then((payload) => payload.organizations ?? payload.teams ?? []);
+  }
+  createOrganization(input3) {
+    return this.requestApiRoot("/organizations", {
+      method: "POST",
+      body: JSON.stringify(input3)
+    }).then((payload) => payload.organization);
+  }
+  getOrganization(slug) {
+    return this.requestApiRoot(
+      `/organizations/${encodeURIComponent(slug)}`
+    ).then((payload) => payload.organization);
+  }
+  updateOrganization(slug, input3) {
+    return this.requestApiRoot(
+      `/organizations/${encodeURIComponent(slug)}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(input3)
+      }
+    ).then((payload) => payload.organization);
+  }
+  listOrganizationMembers(slug) {
+    return this.requestApiRoot(
+      `/organizations/${encodeURIComponent(slug)}/members`
+    ).then((payload) => payload.members);
+  }
+  upsertOrganizationMember(slug, input3) {
+    return this.requestApiRoot(
+      `/organizations/${encodeURIComponent(slug)}/members`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    ).then((payload) => payload.member);
+  }
+  getOrganizationMcpServer(slug) {
+    return this.requestApiRoot(
+      `/organizations/${encodeURIComponent(slug)}/mcp-server`
+    ).then((payload) => payload.mcpServer);
+  }
+  generateOrganizationMcpServer(slug, input3 = {}) {
+    return this.requestApiRoot(
+      `/organizations/${encodeURIComponent(slug)}/mcp-server`,
+      {
+        method: "POST",
+        body: JSON.stringify(input3)
+      }
+    ).then((payload) => payload.mcpServer);
+  }
+  rotateOrganizationMcpServer(slug) {
+    return this.requestApiRoot(
+      `/organizations/${encodeURIComponent(slug)}/mcp-server/rotate`,
+      {
+        method: "POST"
+      }
+    ).then((payload) => payload.mcpServer);
+  }
+  disableOrganizationMcpServer(slug) {
+    return this.requestApiRoot(
+      `/organizations/${encodeURIComponent(slug)}/mcp-server/disable`,
+      {
+        method: "POST"
+      }
+    ).then((payload) => payload.mcpServer);
+  }
+  enableOrganizationMcpServer(slug) {
+    return this.requestApiRoot(
+      `/organizations/${encodeURIComponent(slug)}/mcp-server/enable`,
+      {
+        method: "POST"
+      }
+    ).then((payload) => payload.mcpServer);
+  }
+  startReplay(input3) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    const { teamId: _teamId, projectId: _projectId, ...body } = input3;
+    return this.requestApiRoot(
+      `/sandbox-replays${query.size > 0 ? `?${query.toString()}` : ""}`,
+      {
+        method: "POST",
+        body: JSON.stringify(body)
+      }
+    );
+  }
+  listReplays(input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    return this.requestApiRoot(
+      `/sandbox-replays${query.size > 0 ? `?${query.toString()}` : ""}`
+    );
+  }
+  getReplay(replayId, input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    return this.requestApiRoot(
+      `/sandbox-replays/${encodeURIComponent(replayId)}${query.size > 0 ? `?${query.toString()}` : ""}`
+    );
+  }
+  getReplayLogs(replayId, input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    return this.requestApiRoot(
+      `/sandbox-replays/${encodeURIComponent(replayId)}/logs${query.size > 0 ? `?${query.toString()}` : ""}`
+    );
+  }
+  getReplayArtifacts(replayId, input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    return this.requestApiRoot(
+      `/sandbox-replays/${encodeURIComponent(replayId)}/artifacts${query.size > 0 ? `?${query.toString()}` : ""}`
+    );
+  }
+  cancelReplay(replayId, input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    return this.requestApiRoot(
+      `/sandbox-replays/${encodeURIComponent(replayId)}/cancel${query.size > 0 ? `?${query.toString()}` : ""}`,
+      {
+        method: "POST"
+      }
+    );
+  }
+  integrationConnections(input3 = {}) {
+    const query = new URLSearchParams();
+    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input3.projectId) query.set("projectId", input3.projectId);
+    if (input3.agentId) query.set("agentId", input3.agentId);
+    if (input3.status) query.set("status", input3.status);
+    return this.requestApiRoot(
+      `/integrations/connections${query.size > 0 ? `?${query.toString()}` : ""}`
+    );
+  }
+  mcpServerConfig() {
+    return {
+      name: "openpond-sandboxes",
+      transport: "streamable-http",
+      url: `${this.sandboxApiUrl}/mcp`,
+      headers: {
+        "openpond-api-key": this.apiKey
+      }
+    };
+  }
+  smoke(options = {}) {
+    return runSandboxSmoke(this, options);
+  }
+};
+function createOpenPondSandboxClient(options) {
+  return new OpenPondSandboxClient(options);
+}
+
+// ../../packages/cloud/src/sandbox/types/runtime-profiles.ts
+var SANDBOX_RUNTIME_PROFILE_IDS = [
+  "openpond-coding-core-v1"
+];
+
+// src/cli/common/sandbox-options.ts
+var SANDBOX_WORKFLOW_MODES = [
+  "readonly",
+  "attempt",
+  "feature",
+  "rollout",
+  "replay",
+  "template_build",
+  "scheduled_run",
+  "patch_only",
+  "hotfix",
+  "multi_feature_batch"
+];
+var SANDBOX_RUNTIME_PROMOTION_POLICIES = ["none", "manual", "auto_after_checks"];
+var SANDBOX_RUNTIME_PROFILES = [
+  ...SANDBOX_RUNTIME_PROFILE_IDS
+];
+function resolveSandboxBaseUrl(config, options) {
+  const envName = typeof options.env === "string" ? options.env.trim().toLowerCase() : typeof options.environment === "string" ? options.environment.trim().toLowerCase() : "";
+  if (envName === "staging") {
+    return "https://api-new.staging-api.openpond.ai";
+  }
+  if (envName && envName !== "production") {
+    throw new Error("sandbox env must be staging or production");
+  }
+  const base = process.env.OPENPOND_SANDBOX_BASE_URL || process.env.OPENPOND_API_URL || config.apiBaseUrl || mapUiBaseToApiBase(process.env.OPENPOND_BASE_URL || config.baseUrl) || DEFAULT_OPENPOND_API_BASE_URL;
+  return base.replace(/\/$/, "");
+}
+async function resolveSandboxClient(options) {
+  const config = await loadConfig();
+  const uiBase = resolveBaseUrl(config);
+  const apiKey = await ensureApiKey(config, uiBase);
+  const sandboxApiUrl = resolveSandboxApiUrlOption(options) || process.env.OPENPOND_SANDBOX_API_URL?.trim() || null;
+  return createOpenPondSandboxClient(
+    sandboxApiUrl ? { apiKey, sandboxApiUrl } : { apiKey, baseUrl: resolveSandboxBaseUrl(config, options) }
+  );
+}
+function parseSandboxWorkflowModeOption(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("workflow-mode must be a non-empty value");
+  }
+  const mode = value.trim();
+  if (!SANDBOX_WORKFLOW_MODES.includes(mode)) {
+    throw new Error(
+      `workflow-mode must be one of ${SANDBOX_WORKFLOW_MODES.join(", ")}`
+    );
+  }
+  return mode;
+}
+function parseSandboxRuntimePromotionPolicyOption(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("runtime-promotion-policy must be a non-empty value");
+  }
+  const policy = value.trim();
+  if (!SANDBOX_RUNTIME_PROMOTION_POLICIES.includes(policy)) {
+    throw new Error(
+      `runtime-promotion-policy must be one of ${SANDBOX_RUNTIME_PROMOTION_POLICIES.join(
+        ", "
+      )}`
+    );
+  }
+  return policy;
+}
+function parseSandboxRuntimeProfileIdOption(value) {
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  const runtimeProfileId = value.trim();
+  if (!SANDBOX_RUNTIME_PROFILES.includes(runtimeProfileId)) {
+    throw new Error(
+      `runtime-profile-id must be one of ${SANDBOX_RUNTIME_PROFILES.join(
+        ", "
+      )}`
+    );
+  }
+  return runtimeProfileId;
+}
+function parseSandboxEnvOptions(options) {
+  const refs = parseSandboxEnvAssignments(options.envRef, "env-ref").map(
+    ({ name, value }) => ({ name, secretRef: value })
+  );
+  const literals = parseSandboxEnvAssignments(
+    options.envLiteral,
+    "env-literal"
+  ).map(({ name, value }) => {
+    if (isSecretLikeEnvName(name) && !parseBooleanOption(options.allowPlainSecretEnv)) {
+      throw new Error(
+        `refusing plaintext value for secret-like env ${name}; create a sandbox secret and pass --env-ref ${name}=openpond://secret/...`
+      );
+    }
+    return { name, value };
+  });
+  const env = [...refs, ...literals];
+  const names = /* @__PURE__ */ new Set();
+  for (const item of env) {
+    if (names.has(item.name)) {
+      throw new Error(`duplicate sandbox env var: ${item.name}`);
+    }
+    names.add(item.name);
+  }
+  return env;
+}
+function parseSandboxTemplateEnvOptions(manifest, options) {
+  const env = parseSandboxEnvOptions(options);
+  const provided = new Set(env.map((item) => item.name));
+  const providedByName = new Map(env.map((item) => [item.name, item]));
+  for (const requirement of manifest.inputs.env) {
+    const value = providedByName.get(requirement.name);
+    if (value?.value !== void 0 && requirement.secret !== false) {
+      throw new Error(
+        `sandbox template env ${requirement.name} requires a secret ref. Pass --env-ref ${requirement.name}=openpond://secret/...`
+      );
+    }
+  }
+  const missing = manifest.inputs.env.filter((item) => item.required && !provided.has(item.name)).map((item) => item.name);
+  if (missing.length > 0) {
+    throw new Error(
+      `missing required sandbox template env refs: ${missing.join(
+        ", "
+      )}. Pass --env-ref NAME=openpond://secret/...`
+    );
+  }
+  return env;
+}
+function parseSandboxEnvAssignments(value, label) {
+  if (typeof value !== "string") return [];
+  return value.split(",").map((item) => item.trim()).filter(Boolean).map((item) => {
+    const separator = item.indexOf("=");
+    if (separator <= 0) {
+      throw new Error(`${label} entries must use NAME=value`);
+    }
+    const name = item.slice(0, separator).trim();
+    const entryValue = item.slice(separator + 1).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+      throw new Error(`${label} has invalid env name: ${name}`);
+    }
+    if (!entryValue) {
+      throw new Error(`${label} value is required for ${name}`);
+    }
+    return { name, value: entryValue };
+  });
+}
+function isSecretLikeEnvName(name) {
+  return /(?:SECRET|TOKEN|KEY|PASSWORD|PASSWD|PRIVATE|CREDENTIAL|DATABASE_URL|DSN)/i.test(
+    name
+  );
+}
+async function readSandboxSecretValue(options, label) {
+  if (typeof options.value === "string" || typeof options.secretValue === "string") {
+    throw new Error(
+      "sandbox secret values must be provided with --stdin or the masked prompt"
+    );
+  }
+  const useStdin = parseBooleanOption(options.stdin);
+  if (useStdin) {
+    const value2 = await readAllStdin();
+    if (!value2) throw new Error(`${label} read no secret value from stdin`);
+    return value2;
+  }
+  if (!process.stdin.isTTY) {
+    throw new Error(`${label} requires --stdin when not running in a TTY`);
+  }
+  const value = await readMaskedLine(`${label}: `);
+  if (!value) throw new Error(`${label} cannot be empty`);
+  return value;
+}
+function summarizeSandboxSecret(secret) {
+  return {
+    id: secret.id,
+    teamId: secret.teamId,
+    name: secret.name,
+    scope: secret.scope,
+    status: secret.status,
+    secretRef: secret.secretRef,
+    currentVersion: secret.currentVersion,
+    updatedAt: secret.updatedAt,
+    lastUsedAt: secret.lastUsedAt,
+    attachedDestinations: secret.attachments?.length ?? 0
+  };
+}
+
+// src/process-runner.ts
+import { Buffer as Buffer2 } from "node:buffer";
+import { spawn } from "node:child_process";
+var DEFAULT_PROCESS_TIMEOUT_MS = 10 * 60 * 1e3;
+var DEFAULT_PROCESS_MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
+function runProcessCommand(command, args = [], options = {}) {
+  if (options.inherit && options.terminateWhenStdoutIncludes !== void 0) {
+    return Promise.reject(new Error("terminateWhenStdoutIncludes requires captured stdout"));
+  }
+  if (options.terminateWhenStdoutIncludes === "") {
+    return Promise.reject(new Error("terminateWhenStdoutIncludes must not be empty"));
+  }
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env ? { ...process.env, ...options.env } : void 0,
+      shell: options.shell,
+      detached: options.detached ?? process.platform !== "win32",
+      stdio: options.inherit ? "inherit" : [options.stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"]
+    });
+    const stdout = new BoundedOutput(maxOutputBytes(options));
+    const stderr = new BoundedOutput(maxOutputBytes(options));
+    let timedOut = false;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_PROCESS_TIMEOUT_MS;
+    let timeout;
+    let forceKill;
+    let requestedTermination = null;
+    let settled = false;
+    const clearTimers = () => {
+      if (timeout) clearTimeout(timeout);
+      if (forceKill) clearTimeout(forceKill);
+    };
+    const requestTermination = (reason) => {
+      if (requestedTermination !== null || settled) return;
+      requestedTermination = reason;
+      timedOut = reason === "timeout";
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = void 0;
+      }
+      terminateProcessTree(proc.pid, "SIGTERM");
+      forceKill = setTimeout(() => {
+        if (proc.exitCode === null && proc.signalCode === null) terminateProcessTree(proc.pid, "SIGKILL");
+      }, 5e3);
+    };
+    if (timeoutMs > 0) {
+      timeout = setTimeout(() => {
+        requestTermination("timeout");
+      }, timeoutMs);
+    }
+    if (!options.inherit) {
+      proc.stdout?.on("data", (chunk) => {
+        stdout.append(chunk);
+        const marker = options.terminateWhenStdoutIncludes;
+        if (marker !== void 0 && stdout.text().includes(marker)) {
+          requestTermination("output");
+        }
+      });
+      proc.stderr?.on("data", (chunk) => {
+        stderr.append(chunk);
+      });
+    }
+    proc.on("error", (error) => {
+      clearTimers();
+      settled = true;
+      reject(error);
+    });
+    proc.on("close", (code, signal) => {
+      if (settled) return;
+      settled = true;
+      clearTimers();
+      resolve({
+        code,
+        signal,
+        terminationReason: requestedTermination ?? (signal ? "signal" : "exit"),
+        stdout: stdout.text(),
+        stderr: stderr.text(),
+        timedOut,
+        stdoutTruncated: stdout.truncated,
+        stderrTruncated: stderr.truncated
+      });
+    });
+    if (options.stdin !== void 0) {
+      proc.stdin?.end(options.stdin);
+    }
+  });
+}
+var BoundedOutput = class {
+  #chunks = [];
+  #maxBytes;
+  #bytes = 0;
+  truncated = false;
+  constructor(maxBytes) {
+    this.#maxBytes = maxBytes;
+  }
+  append(value) {
+    const chunk = Buffer2.isBuffer(value) ? value : Buffer2.from(value);
+    const remaining = this.#maxBytes - this.#bytes;
+    if (remaining <= 0) {
+      if (chunk.byteLength > 0) this.truncated = true;
+      return;
+    }
+    if (chunk.byteLength <= remaining) {
+      this.#chunks.push(chunk);
+      this.#bytes += chunk.byteLength;
+      return;
+    }
+    this.#chunks.push(chunk.subarray(0, remaining));
+    this.#bytes += remaining;
+    this.truncated = true;
+  }
+  text() {
+    const value = Buffer2.concat(this.#chunks, this.#bytes).toString("utf8");
+    return this.truncated ? `${value}
+[truncated after ${this.#maxBytes} bytes]
+` : value;
+  }
+};
+function maxOutputBytes(options) {
+  const value = options.maxOutputBytes ?? DEFAULT_PROCESS_MAX_OUTPUT_BYTES;
+  return Math.max(0, Math.floor(value));
+}
+function terminateProcessTree(pid, signal) {
+  if (!pid) return;
+  if (process.platform === "win32") {
+    const args = ["/PID", String(pid), "/T"];
+    if (signal === "SIGKILL") args.push("/F");
+    const killer = spawn("taskkill", args, { stdio: "ignore", windowsHide: true });
+    killer.unref();
+    return;
+  }
+  try {
+    process.kill(-pid, signal);
+  } catch (error) {
+    if (error.code !== "ESRCH") throw error;
+  }
+}
+
+// src/cli/common/shell.ts
+async function runCommand(command, args, options = {}) {
+  return runProcessCommand(command, args, {
+    cwd: options.cwd,
+    inherit: options.inherit,
+    timeoutMs: options.timeoutMs,
+    maxOutputBytes: options.maxOutputBytes,
+    terminateWhenStdoutIncludes: options.terminateWhenStdoutIncludes
+  });
+}
+async function runShellCommand(command, options = {}) {
+  const timeoutMs = options.timeoutSeconds === void 0 ? void 0 : options.timeoutSeconds * 1e3;
+  return runProcessCommand(command, [], {
+    cwd: options.cwd,
+    env: options.env,
+    shell: true,
+    inherit: options.inherit,
+    timeoutMs,
+    maxOutputBytes: options.maxOutputBytes
+  });
+}
+async function getGitRemoteUrl(cwd, remoteName) {
+  const result = await runCommand("git", ["remote", "get-url", remoteName], {
+    cwd
+  });
+  if (result.code !== 0) return null;
+  const url = result.stdout.trim();
+  return url.length > 0 ? url : null;
+}
+
+export {
+  apiFetch,
+  readApiJson,
+  deployApp,
+  getLatestDeploymentForApp,
+  getDeploymentDetail,
+  createRepo,
+  updateAppCodeVisibility,
+  createHeadlessApps,
+  getTemplateStatus,
+  listTemplateBranches,
+  deployLatestTemplate,
+  updateAppEnvironment,
+  getAppEnvironment,
+  createAgentFromPrompt,
+  getUserPerformance,
+  getAppRuntimeSummary,
+  getOpenPondAccount,
+  checkOpenPondApiHealth,
+  runAssistantMode,
+  executeUserTool,
+  submitPositionsTx,
+  submitBacktestRun,
+  submitBacktestTx,
+  submitBacktestDetail,
+  executeHostedTool,
+  writePrivateJsonFile,
+  loadGlobalConfig,
+  loadConfig,
+  listConfiguredProfiles,
+  setActiveProfile,
+  saveProfileApiKey,
+  saveGlobalConfig,
+  resolveApiKey,
+  promptForApiKey,
+  ensureApiKey,
+  resolveRepoUrl,
+  formatTokenizedRepoUrl,
+  formatTokenizedRepoUrlForPrint,
+  redactToken,
+  warnOnRepoHostMismatch,
+  normalizeRepoName,
+  fetchAppsWithCache,
+  fetchToolsWithCache,
+  resolveAppTarget,
+  pollDeploymentLogs,
+  promptConfirm,
+  promptForPath,
+  resolveSandboxClient,
+  parseSandboxWorkflowModeOption,
+  parseSandboxRuntimePromotionPolicyOption,
+  parseSandboxRuntimeProfileIdOption,
+  parseSandboxEnvOptions,
+  parseSandboxTemplateEnvOptions,
+  readSandboxSecretValue,
+  summarizeSandboxSecret,
+  runProcessCommand,
+  runCommand,
+  runShellCommand,
+  getGitRemoteUrl
+};