openpond 0.0.38 → 0.0.39

package/dist/chunks/chunk-DBHSOTYZ.js

@@ -0,0 +1,1552 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  DEFAULT_OPENPOND_API_BASE_URL,
+  DEFAULT_OPENPOND_WEB_BASE_URL
+} from "./chunk-KSRWKXRB.js";
+
+// ../../packages/cloud/src/api/vercel-protection.ts
+var VERCEL_PROTECTION_BYPASS_HEADER = "x-vercel-protection-bypass";
+function withVercelProtectionBypass(requestUrl, inputHeaders, env = typeof process === "undefined" ? {} : process.env) {
+  const headers = new Headers(inputHeaders);
+  const secret = env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();
+  if (!secret || !isOpenPondStagingUrl(requestUrl)) return headers;
+  headers.set(VERCEL_PROTECTION_BYPASS_HEADER, secret);
+  return headers;
+}
+function isOpenPondStagingUrl(requestUrl) {
+  try {
+    const hostname = new URL(requestUrl).hostname.toLowerCase();
+    return hostname === "staging.openpond.ai" || hostname === "staging-api.openpond.ai" || hostname.endsWith(".staging-api.openpond.ai");
+  } catch {
+    return false;
+  }
+}
+
+// ../../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 requestUrl = `${baseUrl}${requestPath}`;
+  const headers = withVercelProtectionBypass(requestUrl, 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 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;
+  }
+}
+function boundedResponse(response, input) {
+  if (!response.body) {
+    input.cleanup();
+    return response;
+  }
+  const contentLength = Number(response.headers.get("content-length"));
+  if (input.maximumBytes > 0 && Number.isFinite(contentLength) && contentLength > input.maximumBytes) {
+    input.cleanup();
+    void response.body.cancel();
+    throw new ApiResponseTooLargeError(input.maximumBytes, input.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) {
+          input.cleanup();
+          controller.close();
+          return;
+        }
+        receivedBytes += result.value.byteLength;
+        if (input.maximumBytes > 0 && receivedBytes > input.maximumBytes) {
+          input.cleanup();
+          await reader.cancel();
+          controller.error(new ApiResponseTooLargeError(input.maximumBytes, input.requestUrl));
+          return;
+        }
+        controller.enqueue(result.value);
+      } catch (error) {
+        input.cleanup();
+        controller.error(input.timeoutController.signal.aborted ? input.timeoutError : error);
+      }
+    },
+    async cancel(reason) {
+      input.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, input) {
+  const environment = input?.environment ?? "production";
+  const response = await apiFetch(
+    baseUrl,
+    token,
+    `/v4/apps/${appId}/deployments`,
+    {
+      method: "POST",
+      body: JSON.stringify({
+        environment,
+        ...input?.commitSha ? { commitSha: input.commitSha } : {},
+        ...input?.branch ? { branch: input.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, input) {
+  const response = await apiFetch(apiBase, apiKey, "/apps/repo/create", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+  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, input) {
+  const response = await apiFetch(
+    apiBase,
+    token,
+    `/v4/apps/${appId}/template/deploy-latest`,
+    {
+      method: "POST",
+      body: JSON.stringify(input)
+    }
+  );
+  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, input) {
+  const response = await apiFetch(
+    apiBase,
+    token,
+    `/v4/apps/${appId}/environment`,
+    {
+      method: "POST",
+      body: JSON.stringify(input)
+    }
+  );
+  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, "/v1/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 apiFetch(normalizedBase, null, "/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 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 input = value;
+  const handle = normalizeHandle(
+    typeof input.handle === "string" ? input.handle : void 0
+  );
+  if (!handle) return null;
+  const baseUrl = normalizeBaseUrl(
+    typeof input.baseUrl === "string" ? input.baseUrl : void 0
+  );
+  return baseUrl ? { handle, baseUrl } : { handle };
+}
+function sanitizeLocalOpenPondProfile(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const input = value;
+  const repoPath = typeof input.repoPath === "string" ? input.repoPath.trim() : "";
+  const profile = typeof input.profile === "string" && input.profile.trim() ? input.profile.trim() : "default";
+  if (!repoPath) return void 0;
+  const out = {
+    repoPath,
+    profile,
+    mode: "local"
+  };
+  if (input.lastCheck && typeof input.lastCheck === "object" && !Array.isArray(input.lastCheck)) {
+    const check = input.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 (input.lastPush && typeof input.lastPush === "object" && !Array.isArray(input.lastPush)) {
+    const push = input.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.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 } : {}
+      };
+    }
+  }
+  if (Array.isArray(input.profiles)) {
+    const profiles = input.profiles.flatMap((value2) => {
+      const entry = sanitizeLocalOpenPondProfile(value2);
+      if (!entry) return [];
+      const rawEntry = value2;
+      const source = rawEntry.source === "github" || rawEntry.source === "openpond_git" ? rawEntry.source : "local";
+      const repositoryId = typeof rawEntry.repositoryId === "string" && rawEntry.repositoryId.trim() ? rawEntry.repositoryId.trim() : path2.resolve(entry.repoPath);
+      return [{
+        source,
+        repositoryId,
+        repoPath: entry.repoPath,
+        profile: entry.profile,
+        ...entry.lastCheck ? { lastCheck: entry.lastCheck } : {},
+        ...entry.lastPush ? { lastPush: entry.lastPush } : {}
+      }];
+    });
+    if (profiles.length > 0) out.profiles = profiles;
+  }
+  return out;
+}
+function sanitizeHostedMaterializationStatus(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const input = value;
+  const status = stringField(input.status);
+  if (!status) return null;
+  return {
+    status,
+    ...nullableStringProp(input, "agentId"),
+    ...nullableStringProp(input, "runtimeAgentId"),
+    ...nullableStringProp(input, "projectId"),
+    ...nullableStringProp(input, "sourceRoot"),
+    ...nullableStringProp(input, "sourceRef"),
+    ...nullableStringProp(input, "sourceCommitSha"),
+    ...nullableStringProp(input, "manifestHash"),
+    ...nullableStringProp(input, "manifestPath"),
+    ...nullableStringProp(input, "manifestSyncedAt"),
+    ...nullableNumberProp(input, "fileCount"),
+    ...nullableNumberProp(input, "totalBytes"),
+    ...nullableStringProp(input, "generatedManifestPath"),
+    ...nullableBooleanProp(input, "synthesizedOpenPondYaml"),
+    ...nullableStringProp(input, "uploadMetadataPath"),
+    ...stringArrayProp(input, "setupCommands"),
+    ...stringArrayProp(input, "validationCommands"),
+    ...nullableStringProp(input, "materializedAt"),
+    ...nullableStringProp(input, "error")
+  };
+}
+function sanitizeHostedSourceCheckStatus(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const input = value;
+  const status = stringField(input.status);
+  if (!status) return null;
+  return {
+    status,
+    ...nullableStringProp(input, "agentId"),
+    ...nullableStringProp(input, "deployPlanStatus"),
+    ...nullableBooleanProp(input, "canRun"),
+    ...nullableBooleanProp(input, "canDeploy"),
+    ...nullableStringProp(input, "sourceRef"),
+    ...nullableStringProp(input, "sourceCommitSha"),
+    ...nullableStringProp(input, "manifestHash"),
+    ...nullableStringProp(input, "manifestPath"),
+    ...stringArrayProp(input, "setupCommands"),
+    ...stringArrayProp(input, "validationCommands"),
+    ...stringArrayProp(input, "requiredChecks"),
+    ...stringArrayProp(input, "evalNames"),
+    ...stringArrayProp(input, "blockedReasons"),
+    ...stringArrayProp(input, "staleReasons"),
+    ...nullableStringProp(input, "runtimeId"),
+    ...nullableStringProp(input, "sandboxId"),
+    ...stringArrayProp(input, "traceArtifactRefs"),
+    ...stringArrayProp(input, "evalResultArtifactRefs"),
+    ...stringArrayProp(input, "validatorArtifactRefs"),
+    ...nullableStringProp(input, "checkedAt"),
+    ...nullableStringProp(input, "error")
+  };
+}
+function sanitizeHostedPublishStatus(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const input = value;
+  const status = stringField(input.status);
+  if (!status) return null;
+  return {
+    status,
+    ...nullableStringProp(input, "agentId"),
+    ...nullableStringProp(input, "snapshotId"),
+    ...nullableStringProp(input, "sourceRef"),
+    ...nullableStringProp(input, "sourceCommitSha"),
+    ...nullableStringProp(input, "manifestHash"),
+    ...nullableStringProp(input, "manifestPath"),
+    ...nullableStringProp(input, "buildStatus"),
+    ...nullableStringProp(input, "validationStatus"),
+    ...nullableStringProp(input, "evalStatus"),
+    ...nullableStringProp(input, "publishedAt"),
+    ...nullableStringProp(input, "error")
+  };
+}
+function sanitizeHostedRunSummary(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const input = value;
+  const status = stringField(input.status);
+  if (!status) return null;
+  return {
+    status,
+    ...nullableStringProp(input, "agentId"),
+    ...nullableStringProp(input, "runId"),
+    ...nullableStringProp(input, "runtimeId"),
+    ...nullableStringProp(input, "sandboxId"),
+    ...nullableStringProp(input, "sourceRef"),
+    ...nullableStringProp(input, "sourceCommitSha"),
+    ...nullableStringProp(input, "manifestHash"),
+    ...nullableStringProp(input, "setupGateStatus"),
+    ...stringArrayProp(input, "setupRequirementRefs"),
+    ...stringArrayProp(input, "artifactRefs"),
+    ...stringArrayProp(input, "traceArtifactRefs"),
+    ...stringArrayProp(input, "evalArtifactRefs"),
+    ...nullableStringProp(input, "startedAt"),
+    ...nullableStringProp(input, "completedAt"),
+    ...nullableStringProp(input, "error")
+  };
+}
+function nullableStringProp(input, key) {
+  const value = input[key];
+  return typeof value === "string" || value === null ? { [key]: value } : {};
+}
+function nullableBooleanProp(input, key) {
+  const value = input[key];
+  return typeof value === "boolean" || value === null ? { [key]: value } : {};
+}
+function nullableNumberProp(input, key) {
+  const value = input[key];
+  return typeof value === "number" || value === null ? { [key]: value } : {};
+}
+function stringArrayProp(input, key) {
+  const value = input[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 input = value;
+  const out = {};
+  if (typeof input.token === "string") out.token = input.token;
+  if (typeof input.appId === "string" || input.appId === null) {
+    out.appId = input.appId;
+  }
+  if (typeof input.conversationId === "string" || input.conversationId === null) {
+    out.conversationId = input.conversationId;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function sanitizeAccount(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const input = value;
+  const handle = normalizeHandle(
+    typeof input.handle === "string" ? input.handle : void 0
+  );
+  if (!handle) return null;
+  const out = { handle };
+  if (typeof input.apiKey === "string") out.apiKey = input.apiKey;
+  if (typeof input.baseUrl === "string") out.baseUrl = input.baseUrl;
+  if (typeof input.apiBaseUrl === "string") out.apiBaseUrl = input.apiBaseUrl;
+  if (typeof input.chatApiBaseUrl === "string")
+    out.chatApiBaseUrl = input.chatApiBaseUrl;
+  if (typeof input.environment === "string")
+    out.environment = input.environment;
+  const session = sanitizeSession(input.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 (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, "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(input) {
+  const handle = requireHandle(input.handle);
+  const apiKey = requireApiKey(input.apiKey);
+  const baseUrl = normalizeBaseUrl(input.baseUrl);
+  const apiBaseUrl = normalizeBaseUrl(input.apiBaseUrl);
+  const chatApiBaseUrl = normalizeBaseUrl(input.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 (input.apiBaseUrl === null) delete account.apiBaseUrl;
+    if (chatApiBaseUrl) account.chatApiBaseUrl = chatApiBaseUrl;
+    else if (input.chatApiBaseUrl === null) delete account.chatApiBaseUrl;
+    if (input.environment === null) delete account.environment;
+    else if (typeof input.environment === "string" && input.environment.trim()) {
+      account.environment = input.environment.trim();
+    }
+    global.accounts = accounts;
+    savedSelector = selectorFromAccount(account);
+    if (input.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 });
+  });
+}
+
+// ../../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;
+  });
+}
+
+// ../../packages/cloud/src/sandbox/types/runtime-profiles.ts
+var SANDBOX_RUNTIME_PROFILE_IDS = [
+  "openpond-generic-v1",
+  "openpond-work-v1",
+  "openpond-coding-core-v1",
+  "openpond-agent-harness-v1"
+];
+
+export {
+  withVercelProtectionBypass,
+  deployApp,
+  getDeploymentLogs,
+  getDeploymentStatus,
+  getLatestDeploymentForApp,
+  getDeploymentDetail,
+  listApps,
+  createRepo,
+  updateAppCodeVisibility,
+  createHeadlessApps,
+  getTemplateStatus,
+  listTemplateBranches,
+  deployLatestTemplate,
+  updateAppEnvironment,
+  getAppEnvironment,
+  listUserTools,
+  createAgentFromPrompt,
+  getUserPerformance,
+  getAppRuntimeSummary,
+  getOpenPondAccount,
+  checkOpenPondApiHealth,
+  runAssistantMode,
+  executeUserTool,
+  submitBacktestRun,
+  submitBacktestTx,
+  submitBacktestDetail,
+  executeHostedTool,
+  openPondConfigDirectory,
+  writePrivateJsonFile,
+  updatePrivateJsonFile,
+  loadGlobalConfig,
+  loadConfig,
+  listConfiguredProfiles,
+  setActiveProfile,
+  saveProfileApiKey,
+  saveGlobalConfig,
+  DEFAULT_CACHE_TTL_MS,
+  getCachedApps,
+  setCachedApps,
+  getCachedTools,
+  setCachedTools,
+  SANDBOX_RUNTIME_PROFILE_IDS
+};