openpond 0.0.36 → 0.0.38

package/dist/chunks/{chunk-NWVIUBJ3.js → chunk-ZI4GDAUB.js}

@@ -1,14 +1,8 @@
 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-NVTC3XOA.js";
-import {
-  parseBooleanOption
-} from "./chunk-YLULZMWE.js";
+  DEFAULT_OPENPOND_WEB_BASE_URL
+} from "./chunk-KSRWKXRB.js";
 
 // ../../packages/cloud/src/api/core.ts
 var DEFAULT_API_TIMEOUT_MS = 3e4;
@@ -89,16 +83,16 @@ async function readApiJson(response, label) {
   }
   return payload;
 }
-function boundedResponse(response, input3) {
+function boundedResponse(response, input) {
   if (!response.body) {
-    input3.cleanup();
+    input.cleanup();
     return response;
   }
   const contentLength = Number(response.headers.get("content-length"));
-  if (input3.maximumBytes > 0 && Number.isFinite(contentLength) && contentLength > input3.maximumBytes) {
-    input3.cleanup();
+  if (input.maximumBytes > 0 && Number.isFinite(contentLength) && contentLength > input.maximumBytes) {
+    input.cleanup();
     void response.body.cancel();
-    throw new ApiResponseTooLargeError(input3.maximumBytes, input3.requestUrl);
+    throw new ApiResponseTooLargeError(input.maximumBytes, input.requestUrl);
   }
   const reader = response.body.getReader();
   let receivedBytes = 0;
@@ -107,25 +101,25 @@ function boundedResponse(response, input3) {
       try {
         const result = await reader.read();
         if (result.done) {
-          input3.cleanup();
+          input.cleanup();
           controller.close();
           return;
         }
         receivedBytes += result.value.byteLength;
-        if (input3.maximumBytes > 0 && receivedBytes > input3.maximumBytes) {
-          input3.cleanup();
+        if (input.maximumBytes > 0 && receivedBytes > input.maximumBytes) {
+          input.cleanup();
           await reader.cancel();
-          controller.error(new ApiResponseTooLargeError(input3.maximumBytes, input3.requestUrl));
+          controller.error(new ApiResponseTooLargeError(input.maximumBytes, input.requestUrl));
           return;
         }
         controller.enqueue(result.value);
       } catch (error) {
-        input3.cleanup();
-        controller.error(input3.timeoutController.signal.aborted ? input3.timeoutError : error);
+        input.cleanup();
+        controller.error(input.timeoutController.signal.aborted ? input.timeoutError : error);
       }
     },
     async cancel(reason) {
-      input3.cleanup();
+      input.cleanup();
       await reader.cancel(reason);
     }
   });
@@ -141,8 +135,8 @@ function composedSignal(callerSignal, timeoutSignal, timeoutMs) {
 }
 
 // ../../packages/cloud/src/api/deployments.ts
-async function deployApp(baseUrl, token, appId, input3) {
-  const environment = input3?.environment ?? "production";
+async function deployApp(baseUrl, token, appId, input) {
+  const environment = input?.environment ?? "production";
   const response = await apiFetch(
     baseUrl,
     token,
@@ -151,8 +145,8 @@ async function deployApp(baseUrl, token, appId, input3) {
       method: "POST",
       body: JSON.stringify({
         environment,
-        ...input3?.commitSha ? { commitSha: input3.commitSha } : {},
-        ...input3?.branch ? { branch: input3.branch } : {}
+        ...input?.commitSha ? { commitSha: input.commitSha } : {},
+        ...input?.branch ? { branch: input.branch } : {}
       })
     }
   );
@@ -276,10 +270,10 @@ async function listApps(apiBase, token, options) {
   const payload = await response.json().catch(() => ({}));
   return Array.isArray(payload.apps) ? payload.apps : [];
 }
-async function createRepo(apiBase, apiKey, input3) {
+async function createRepo(apiBase, apiKey, input) {
   const response = await apiFetch(apiBase, apiKey, "/apps/repo/create", {
     method: "POST",
-    body: JSON.stringify(input3)
+    body: JSON.stringify(input)
   });
   if (!response.ok) {
     const text = await response.text().catch(() => "");
@@ -342,14 +336,14 @@ async function listTemplateBranches(apiBase, token, appId) {
   }
   return await response.json();
 }
-async function deployLatestTemplate(apiBase, token, appId, input3) {
+async function deployLatestTemplate(apiBase, token, appId, input) {
   const response = await apiFetch(
     apiBase,
     token,
     `/v4/apps/${appId}/template/deploy-latest`,
     {
       method: "POST",
-      body: JSON.stringify(input3)
+      body: JSON.stringify(input)
     }
   );
   if (!response.ok) {
@@ -358,14 +352,14 @@ async function deployLatestTemplate(apiBase, token, appId, input3) {
   }
   return await response.json();
 }
-async function updateAppEnvironment(apiBase, token, appId, input3) {
+async function updateAppEnvironment(apiBase, token, appId, input) {
   const response = await apiFetch(
     apiBase,
     token,
     `/v4/apps/${appId}/environment`,
     {
       method: "POST",
-      body: JSON.stringify(input3)
+      body: JSON.stringify(input)
     }
   );
   if (!response.ok) {
@@ -533,18 +527,6 @@ async function executeUserTool(baseUrl, token, body) {
     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",
@@ -806,13 +788,13 @@ function selectorFromAccount(account) {
 }
 function sanitizeActiveProfile(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const input3 = value;
+  const input = value;
   const handle = normalizeHandle(
-    typeof input3.handle === "string" ? input3.handle : void 0
+    typeof input.handle === "string" ? input.handle : void 0
   );
   if (!handle) return null;
   const baseUrl = normalizeBaseUrl(
-    typeof input3.baseUrl === "string" ? input3.baseUrl : void 0
+    typeof input.baseUrl === "string" ? input.baseUrl : void 0
   );
   return baseUrl ? { handle, baseUrl } : { handle };
 }
@@ -820,17 +802,17 @@ 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";
+  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 (input3.lastCheck && typeof input3.lastCheck === "object" && !Array.isArray(input3.lastCheck)) {
-    const check = input3.lastCheck;
+  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;
@@ -844,8 +826,8 @@ function sanitizeLocalOpenPondProfile(value) {
       };
     }
   }
-  if (input3.lastPush && typeof input3.lastPush === "object" && !Array.isArray(input3.lastPush)) {
-    const push = input3.lastPush;
+  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") {
@@ -874,120 +856,120 @@ function sanitizeLocalOpenPondProfile(value) {
 }
 function sanitizeHostedMaterializationStatus(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const input3 = value;
-  const status = stringField(input3.status);
+  const input = value;
+  const status = stringField(input.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")
+    ...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 input3 = value;
-  const status = stringField(input3.status);
+  const input = value;
+  const status = stringField(input.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")
+    ...nullableStringProp(input, "agentId"),
+    ...nullableStringProp(input, "workItemId"),
+    ...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 input3 = value;
-  const status = stringField(input3.status);
+  const input = value;
+  const status = stringField(input.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")
+    ...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 input3 = value;
-  const status = stringField(input3.status);
+  const input = value;
+  const status = stringField(input.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")
+    ...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(input3, key) {
-  const value = input3[key];
+function nullableStringProp(input, key) {
+  const value = input[key];
   return typeof value === "string" || value === null ? { [key]: value } : {};
 }
-function nullableBooleanProp(input3, key) {
-  const value = input3[key];
+function nullableBooleanProp(input, key) {
+  const value = input[key];
   return typeof value === "boolean" || value === null ? { [key]: value } : {};
 }
-function nullableNumberProp(input3, key) {
-  const value = input3[key];
+function nullableNumberProp(input, key) {
+  const value = input[key];
   return typeof value === "number" || value === null ? { [key]: value } : {};
 }
-function stringArrayProp(input3, key) {
-  const value = input3[key];
+function stringArrayProp(input, key) {
+  const value = input[key];
   if (!Array.isArray(value)) return {};
   const strings = value.filter((item) => typeof item === "string");
   return { [key]: strings };
@@ -1024,33 +1006,33 @@ function sanitizeSession(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return void 0;
   }
-  const input3 = value;
+  const input = 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 input.token === "string") out.token = input.token;
+  if (typeof input.appId === "string" || input.appId === null) {
+    out.appId = input.appId;
   }
-  if (typeof input3.conversationId === "string" || input3.conversationId === null) {
-    out.conversationId = input3.conversationId;
+  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 input3 = value;
+  const input = value;
   const handle = normalizeHandle(
-    typeof input3.handle === "string" ? input3.handle : void 0
+    typeof input.handle === "string" ? input.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 (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;
 }
@@ -1374,12 +1356,12 @@ async function setActiveProfile(handle, options = {}) {
   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);
+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 ?? [];
@@ -1387,16 +1369,16 @@ async function saveProfileApiKey(input3) {
     account.apiKey = apiKey;
     if (baseUrl) account.baseUrl = baseUrl;
     if (apiBaseUrl) account.apiBaseUrl = apiBaseUrl;
-    else if (input3.apiBaseUrl === null) delete account.apiBaseUrl;
+    else if (input.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();
+    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 (input3.setActive !== false) global.activeProfile = savedSelector;
+    if (input.setActive !== false) global.activeProfile = savedSelector;
   });
   const profiles = await listConfiguredProfiles();
   const saved = profiles.find((profile) => {
@@ -1416,102 +1398,6 @@ async function saveGlobalConfig(next) {
   });
 }
 
-// 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";
@@ -1602,260 +1488,128 @@ async function mutateCache(mutate) {
   });
 }
 
-// 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;
-    }
+// ../../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 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 url = new URL(trimmed);
+  const normalizedPath = url.pathname.replace(/\/$/, "");
+  if (normalizedPath.endsWith("/v1/sandboxes") || normalizedPath.endsWith("/api/sandboxes")) {
+    return `${url.origin}${normalizedPath}`;
   }
-  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}`);
+  if (normalizedPath.endsWith("/v1")) {
+    return `${url.origin}${normalizedPath}/sandboxes`;
   }
-  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));
+  if (isOpenPondHostedApiHost(url.hostname)) {
+    return `${url.origin}${normalizedPath}/v1/sandboxes`;
   }
-  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();
+  if (url.origin === DEFAULT_OPENPOND_WEB_BASE_URL) {
+    return `${DEFAULT_OPENPOND_API_BASE_URL}/v1/sandboxes`;
   }
+  return `${url.origin}${normalizedPath}/api/sandboxes`;
 }
-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();
+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/client-handles.ts
 function createSandboxRuntimeNamespace(client) {
   return {
-    list: (input3 = {}) => client.listSandboxRuntimes(input3),
-    create: (input3) => client.createSandboxRuntime(input3),
+    list: (input = {}) => client.listSandboxRuntimes(input),
+    create: (input) => client.createSandboxRuntime(input),
     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),
+    createSandbox: (runtimeId, input = {}, options = {}) => client.createSandboxRuntimeSandbox(runtimeId, input, options),
+    updateStatus: (runtimeId, input) => client.updateSandboxRuntimeStatus(runtimeId, input),
     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)
+    event: (runtimeId, input) => client.emitSandboxRuntimeEvent(runtimeId, input),
+    checkpoint: (runtimeId, input = {}) => client.checkpointSandboxRuntime(runtimeId, input),
+    promote: (runtimeId, input, options = {}) => client.promoteSandboxRuntime(runtimeId, input, options),
+    preserveSource: (runtimeId, input = {}, options = {}) => client.preserveSandboxRuntimeSource(runtimeId, input, options)
   };
 }
 function createSandboxNamespace(client) {
   return {
-    list: (input3 = {}) => client.list(input3),
-    create: (input3) => client.create(input3),
+    list: (input = {}) => client.list(input),
+    create: (input) => client.create(input),
     get: (sandboxId) => client.get(sandboxId),
     pricing: () => client.pricing(),
-    costs: (input3 = {}) => client.costs(input3)
+    costs: (input = {}) => client.costs(input)
   };
 }
 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)
+    list: (input) => client.listProjects(input),
+    upsert: (input) => client.upsertProject(input),
+    upsertGitRemote: (input) => client.upsertProjectGitRemote(input),
+    get: (projectId, input) => client.getProject(projectId, input),
+    update: (projectId, input) => client.updateProject(projectId, input),
+    sync: (projectId, input) => client.syncProject(projectId, input),
+    ensureGitRemote: (projectId, input) => client.ensureProjectGitRemote(projectId, input),
+    getGitRemote: (projectId, input) => client.ensureProjectGitRemote(projectId, input),
+    git: (projectId, input) => client.ensureProjectGitRemote(projectId, input),
+    uploadSource: (projectId, input) => client.uploadProjectSource(projectId, input),
+    archive: (projectId, input) => client.archiveProject(projectId, input)
   };
 }
 function createSandboxProfileNamespace(client) {
   return {
-    get: (input3) => client.getHostedProfile(input3),
-    status: (input3) => client.getHostedProfile(input3),
-    ensureHosted: (input3) => client.ensureHostedProfile(input3),
-    push: (input3) => client.pushHostedProfile(input3)
+    get: (input) => client.getHostedProfile(input),
+    status: (input) => client.getHostedProfile(input),
+    ensureHosted: (input) => client.ensureHostedProfile(input),
+    push: (input) => client.pushHostedProfile(input)
   };
 }
 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)
+    list: (input) => client.listAgents(input),
+    upsert: (input) => client.upsertAgent(input),
+    get: (agentId, input) => client.getAgent(agentId, input),
+    update: (agentId, input) => client.updateAgent(agentId, input),
+    archive: (agentId, input) => client.archiveAgent(agentId, input),
+    run: (agentId, input) => client.runAgent(agentId, input),
+    sourceDeployPlan: (agentId, input) => client.getAgentSourceDeployPlan(agentId, input),
+    manifestSnapshots: (agentId, input) => client.listAgentManifestSnapshots(agentId, input),
+    requestSourceChecks: (agentId, input) => client.requestAgentSourceChecks(agentId, input),
+    publishSource: (agentId, input) => client.publishAgentSource(agentId, input),
+    openEditWorkItem: (agentId, input) => client.openAgentEditWorkItem(agentId, input)
   };
 }
 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)
+    get: (workItemId, input) => client.getCodingWorkItem(workItemId, input),
+    chat: (workItemId, input) => client.sendCodingWorkItemChat(workItemId, input),
+    activity: (workItemId, input) => client.listCodingWorkItemActivity(workItemId, input),
+    status: (workItemId, input) => client.getCodingWorkItemStatus(workItemId, input),
+    handleBackground: (workItemId, input) => client.handleCodingWorkItemInBackground(workItemId, input),
+    promoteCheckpoint: (workItemId, input) => client.promoteCodingWorkItemResult(workItemId, "checkpoint", input),
+    promoteCommit: (workItemId, input) => client.promoteCodingWorkItemResult(workItemId, "commit", input),
+    promotePullRequest: (workItemId, input) => client.promoteCodingWorkItemResult(workItemId, "pr", input)
   };
 }
 
 // ../../packages/cloud/src/sandbox/runtime-handle.ts
 function createSandboxRuntimeHandle(client, runtimeId, initial = null) {
-  const currentSandbox = async (input3 = {}, options = {}) => {
+  const currentSandbox = async (input = {}, 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);
+    return client.createSandboxRuntimeSandbox(runtimeId, input, options).then((payload) => payload.sandbox);
   };
-  const resume = async (input3 = {}, options = {}) => {
+  const resume = async (input = {}, options = {}) => {
     const runtime = await client.getSandboxRuntime(runtimeId);
     if (!runtime.sandboxId) {
-      return client.createSandboxRuntimeSandbox(runtimeId, input3, options).then((payload) => payload.sandbox);
+      return client.createSandboxRuntimeSandbox(runtimeId, input, options).then((payload) => payload.sandbox);
     }
     const sandbox = await client.get(runtime.sandboxId);
     if (sandbox.state === "stopped") {
@@ -1865,34 +1619,34 @@ function createSandboxRuntimeHandle(client, runtimeId, initial = null) {
       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 client.createSandboxRuntimeSandbox(runtimeId, input, options).then((payload) => payload.sandbox);
     }
     return sandbox;
   };
-  const checkpointHint = (input3 = {}) => client.emitSandboxRuntimeEvent(runtimeId, {
+  const checkpointHint = (input = {}) => client.emitSandboxRuntimeEvent(runtimeId, {
     type: "workflow.checkpoint_hint",
-    summary: input3.summary ?? input3.reason ?? "Workflow checkpoint hint",
+    summary: input.summary ?? input.reason ?? "Workflow checkpoint hint",
     payload: {
-      ...input3.payload,
-      reason: input3.reason ?? null
+      ...input.payload,
+      reason: input.reason ?? null
     },
-    artifactRefs: input3.artifactRefs,
+    artifactRefs: input.artifactRefs,
     lifecycleHint: {
       kind: "checkpoint",
-      reason: input3.reason ?? null
+      reason: input.reason ?? null
     }
   });
-  const waitForUser = async (input3 = {}) => {
+  const waitForUser = async (input = {}) => {
     await client.emitSandboxRuntimeEvent(runtimeId, {
       type: "workflow.waiting_for_user",
-      summary: input3.summary ?? input3.reason ?? "Waiting for user",
+      summary: input.summary ?? input.reason ?? "Waiting for user",
       payload: {
-        ...input3.payload,
-        reason: input3.reason ?? null
+        ...input.payload,
+        reason: input.reason ?? null
       },
       lifecycleHint: {
         kind: "waiting_for_user",
-        reason: input3.reason ?? null
+        reason: input.reason ?? null
       }
     });
     const current = await client.getSandboxRuntime(runtimeId);
@@ -1900,25 +1654,25 @@ function createSandboxRuntimeHandle(client, runtimeId, initial = null) {
     return client.updateSandboxRuntimeStatus(runtimeId, {
       status: "waiting_for_user",
       expectedVersion: current.version,
-      summary: input3.summary ?? input3.reason,
+      summary: input.summary ?? input.reason,
       metadata: {
-        workflowWaitForUserReason: input3.reason ?? null
+        workflowWaitForUserReason: input.reason ?? null
       }
     });
   };
-  const keepAlive = (input3 = {}) => {
-    const keepaliveUntil = runtimeKeepaliveUntilIso(input3);
+  const keepAlive = (input = {}) => {
+    const keepaliveUntil = runtimeKeepaliveUntilIso(input);
     return client.emitSandboxRuntimeEvent(runtimeId, {
       type: "workflow.keepalive",
-      summary: input3.summary ?? input3.reason ?? "Workflow keepalive",
+      summary: input.summary ?? input.reason ?? "Workflow keepalive",
       payload: {
-        ...input3.payload,
-        reason: input3.reason ?? null,
+        ...input.payload,
+        reason: input.reason ?? null,
         keepaliveUntil
       },
       lifecycleHint: {
         kind: "keepalive",
-        reason: input3.reason ?? null,
+        reason: input.reason ?? null,
         keepaliveUntil
       }
     });
@@ -1929,38 +1683,38 @@ function createSandboxRuntimeHandle(client, runtimeId, initial = null) {
     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);
+    createSandbox: (input = {}, options = {}) => client.createSandboxRuntimeSandbox(runtimeId, input, options),
+    status: async (input) => {
+      if (typeof input !== "string") {
+        return client.updateSandboxRuntimeStatus(runtimeId, input);
       }
       const current = await client.getSandboxRuntime(runtimeId);
       return client.updateSandboxRuntimeStatus(runtimeId, {
-        status: input3,
+        status: input,
         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",
+    event: (input) => client.emitSandboxRuntimeEvent(runtimeId, input),
+    recordCommit: (commitSha, input = {}) => client.emitSandboxRuntimeEvent(runtimeId, {
+      ...input,
+      type: input.type ?? "git.commit",
       commitSha
     }),
     checkpointHint,
     waitForUser,
     keepAlive,
-    checkpoint: (input3) => client.checkpointSandboxRuntime(runtimeId, input3),
+    checkpoint: (input) => client.checkpointSandboxRuntime(runtimeId, input),
     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),
+      readResponse: async (input) => client.downloadFileResponse((await resume()).id, input),
+      list: async (input = {}) => client.listFiles((await resume()).id, input),
+      delete: async (path4, input = {}) => client.deleteFile((await resume()).id, path4, input),
+      search: async (input) => client.searchFiles((await resume()).id, input),
       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)
+      mkdir: async (input) => client.mkdir((await resume()).id, input),
+      move: async (input) => client.moveFile((await resume()).id, input)
     },
     commands: {
       run: async (command) => client.exec(
@@ -1974,8 +1728,8 @@ function createSandboxRuntimeHandle(client, runtimeId, initial = null) {
         typeof port === "number" ? { port } : port
       )
     },
-    promote: (input3, options = {}) => client.promoteSandboxRuntime(runtimeId, input3, options),
-    preserveSource: (input3 = {}, options = {}) => client.preserveSandboxRuntimeSource(runtimeId, input3, options),
+    promote: (input, options = {}) => client.promoteSandboxRuntime(runtimeId, input, options),
+    preserveSource: (input = {}, options = {}) => client.preserveSandboxRuntimeSource(runtimeId, input, options),
     archive: async (expectedVersion) => {
       const version = expectedVersion ?? (await client.getSandboxRuntime(runtimeId)).version;
       return client.updateSandboxRuntimeStatus(runtimeId, {
@@ -1985,14 +1739,14 @@ function createSandboxRuntimeHandle(client, runtimeId, initial = null) {
     }
   };
 }
-function runtimeKeepaliveUntilIso(input3) {
-  if (input3?.until instanceof Date) {
-    return input3.until.toISOString();
+function runtimeKeepaliveUntilIso(input) {
+  if (input?.until instanceof Date) {
+    return input.until.toISOString();
   }
-  if (typeof input3?.until === "string" && input3.until.trim()) {
-    return new Date(input3.until).toISOString();
+  if (typeof input?.until === "string" && input.until.trim()) {
+    return new Date(input.until).toISOString();
   }
-  const seconds = typeof input3?.seconds === "number" && Number.isFinite(input3.seconds) ? Math.max(1, Math.trunc(input3.seconds)) : 60;
+  const seconds = typeof input?.seconds === "number" && Number.isFinite(input.seconds) ? Math.max(1, Math.trunc(input.seconds)) : 60;
   return new Date(Date.now() + seconds * 1e3).toISOString();
 }
 
@@ -2369,8 +2123,8 @@ async function streamSandboxEventOutput(params) {
       while (separatorIndex !== -1) {
         const event = buffered.slice(0, separatorIndex);
         buffered = buffered.slice(separatorIndex + 2);
-        const output3 = parseProcessOutputEvent(event);
-        if (output3) process.stdout.write(output3);
+        const output = parseProcessOutputEvent(event);
+        if (output) process.stdout.write(output);
         separatorIndex = buffered.indexOf("\n\n");
       }
     }
@@ -2378,14 +2132,14 @@ async function streamSandboxEventOutput(params) {
     reader.releaseLock();
   }
 }
-function normalizePtyInput(input3) {
-  if (typeof input3 === "string") {
-    return { dataBase64: Buffer.from(input3, "utf-8").toString("base64") };
+function normalizePtyInput(input) {
+  if (typeof input === "string") {
+    return { dataBase64: Buffer.from(input, "utf-8").toString("base64") };
   }
-  if (input3 instanceof Uint8Array) {
-    return { dataBase64: Buffer.from(input3).toString("base64") };
+  if (input instanceof Uint8Array) {
+    return { dataBase64: Buffer.from(input).toString("base64") };
   }
-  return input3;
+  return input;
 }
 function parseProcessOutputEvent(event) {
   if (!event.includes("event: output")) {
@@ -2403,39 +2157,6 @@ function parseProcessOutputEvent(event) {
   }
 }
 
-// ../../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;
@@ -2448,11 +2169,11 @@ var OpenPondSandboxInstanceClient = class {
     );
     this.apiRootUrl = apiRootUrlFromSandboxApiUrl(this.sandboxApiUrl);
   }
-  create(input3, options = {}) {
+  create(input, options = {}) {
     return this.request("", {
       method: "POST",
       headers: asyncRequestHeaders(options),
-      body: JSON.stringify(input3)
+      body: JSON.stringify(input)
     }).then((payload) => payload.sandbox);
   }
   get(sandboxId) {
@@ -2460,21 +2181,21 @@ var OpenPondSandboxInstanceClient = class {
       `/${encodeURIComponent(sandboxId)}`
     ).then((payload) => payload.sandbox);
   }
-  exec(sandboxId, input3) {
+  exec(sandboxId, input) {
     return this.request(
       `/${encodeURIComponent(sandboxId)}/exec`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  startProcess(sandboxId, input3) {
+  startProcess(sandboxId, input) {
     return this.request(
       `/${encodeURIComponent(sandboxId)}/processes`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
@@ -2483,10 +2204,10 @@ var OpenPondSandboxInstanceClient = class {
       `/${encodeURIComponent(sandboxId)}/processes`
     );
   }
-  getProcess(sandboxId, processId, input3 = {}) {
+  getProcess(sandboxId, processId, input = {}) {
     const query = new URLSearchParams();
-    if (input3.since !== void 0)
-      query.set("since", String(Math.max(0, input3.since)));
+    if (input.since !== void 0)
+      query.set("since", String(Math.max(0, input.since)));
     return this.request(
       `/${encodeURIComponent(sandboxId)}/processes/${encodeURIComponent(
         processId
@@ -2503,10 +2224,10 @@ var OpenPondSandboxInstanceClient = class {
       }
     );
   }
-  async streamProcessOutput(sandboxId, processId, input3 = {}) {
+  async streamProcessOutput(sandboxId, processId, input = {}) {
     const query = new URLSearchParams();
-    if (input3.since !== void 0)
-      query.set("since", String(Math.max(0, input3.since)));
+    if (input.since !== void 0)
+      query.set("since", String(Math.max(0, input.since)));
     await streamSandboxEventOutput({
       sandboxApiUrl: this.sandboxApiUrl,
       apiKey: this.apiKey,
@@ -2515,12 +2236,12 @@ var OpenPondSandboxInstanceClient = class {
       )}/stream${query.size > 0 ? `?${query.toString()}` : ""}`
     });
   }
-  startPty(sandboxId, input3 = {}) {
+  startPty(sandboxId, input = {}) {
     return this.request(
       `/${encodeURIComponent(sandboxId)}/pty`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
@@ -2529,22 +2250,22 @@ var OpenPondSandboxInstanceClient = class {
       `/${encodeURIComponent(sandboxId)}/pty`
     );
   }
-  getPty(sandboxId, ptyId, input3 = {}) {
+  getPty(sandboxId, ptyId, input = {}) {
     const query = new URLSearchParams();
-    if (input3.since !== void 0)
-      query.set("since", String(Math.max(0, input3.since)));
+    if (input.since !== void 0)
+      query.set("since", String(Math.max(0, input.since)));
     return this.request(
       `/${encodeURIComponent(sandboxId)}/pty/${encodeURIComponent(ptyId)}${query.size > 0 ? `?${query.toString()}` : ""}`
     );
   }
-  writePtyInput(sandboxId, ptyId, input3) {
+  writePtyInput(sandboxId, ptyId, input) {
     return this.request(
       `/${encodeURIComponent(sandboxId)}/pty/${encodeURIComponent(
         ptyId
       )}/input`,
       {
         method: "POST",
-        body: JSON.stringify(normalizePtyInput(input3))
+        body: JSON.stringify(normalizePtyInput(input))
       }
     );
   }
@@ -2556,10 +2277,10 @@ var OpenPondSandboxInstanceClient = class {
       }
     );
   }
-  async streamPtyOutput(sandboxId, ptyId, input3 = {}) {
+  async streamPtyOutput(sandboxId, ptyId, input = {}) {
     const query = new URLSearchParams();
-    if (input3.since !== void 0)
-      query.set("since", String(Math.max(0, input3.since)));
+    if (input.since !== void 0)
+      query.set("since", String(Math.max(0, input.since)));
     await streamSandboxEventOutput({
       sandboxApiUrl: this.sandboxApiUrl,
       apiKey: this.apiKey,
@@ -2591,8 +2312,8 @@ var OpenPondSandboxInstanceClient = class {
     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;
+  downloadFileResponse(sandboxId, input) {
+    const normalized = typeof input === "string" ? { path: input } : input;
     const query = new URLSearchParams({ path: normalized.path });
     if (normalized.offsetBytes !== void 0) {
       query.set("offsetBytes", String(normalized.offsetBytes));
@@ -2604,21 +2325,21 @@ var OpenPondSandboxInstanceClient = class {
       `/${encodeURIComponent(sandboxId)}/files?${query.toString()}`
     );
   }
-  listFiles(sandboxId, input3 = {}) {
+  listFiles(sandboxId, input = {}) {
     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));
+    if (input.path) query.set("path", input.path);
+    if (input.recursive !== void 0)
+      query.set("recursive", String(input.recursive));
+    if (input.maxEntries !== void 0)
+      query.set("maxEntries", String(input.maxEntries));
     return this.request(
       `/${encodeURIComponent(sandboxId)}/files?${query.toString()}`
     );
   }
-  deleteFile(sandboxId, path4, input3 = {}) {
+  deleteFile(sandboxId, path4, input = {}) {
     const query = new URLSearchParams({ path: path4 });
-    if (input3.recursive !== void 0)
-      query.set("recursive", String(input3.recursive));
+    if (input.recursive !== void 0)
+      query.set("recursive", String(input.recursive));
     return this.request(
       `/${encodeURIComponent(sandboxId)}/files?${query.toString()}`,
       {
@@ -2632,8 +2353,8 @@ var OpenPondSandboxInstanceClient = class {
       `/${encodeURIComponent(sandboxId)}/files?${query.toString()}`
     );
   }
-  mkdir(sandboxId, input3) {
-    const normalized = typeof input3 === "string" ? { path: input3 } : input3;
+  mkdir(sandboxId, input) {
+    const normalized = typeof input === "string" ? { path: input } : input;
     const query = new URLSearchParams({ path: normalized.path });
     if (normalized.recursive !== void 0)
       query.set("recursive", String(normalized.recursive));
@@ -2644,13 +2365,13 @@ var OpenPondSandboxInstanceClient = class {
       }
     );
   }
-  moveFile(sandboxId, input3) {
+  moveFile(sandboxId, input) {
     const query = new URLSearchParams({
-      fromPath: input3.fromPath,
-      toPath: input3.toPath
+      fromPath: input.fromPath,
+      toPath: input.toPath
     });
-    if (input3.overwrite !== void 0)
-      query.set("overwrite", String(input3.overwrite));
+    if (input.overwrite !== void 0)
+      query.set("overwrite", String(input.overwrite));
     return this.request(
       `/${encodeURIComponent(sandboxId)}/files?${query.toString()}`,
       {
@@ -2658,55 +2379,55 @@ var OpenPondSandboxInstanceClient = class {
       }
     );
   }
-  searchFiles(sandboxId, input3) {
+  searchFiles(sandboxId, input) {
     const query = new URLSearchParams({
       search: "1",
-      query: input3.query
+      query: input.query
     });
-    if (input3.path) query.set("path", input3.path);
-    if (input3.maxResults !== void 0)
-      query.set("maxResults", String(input3.maxResults));
+    if (input.path) query.set("path", input.path);
+    if (input.maxResults !== void 0)
+      query.set("maxResults", String(input.maxResults));
     return this.request(
       `/${encodeURIComponent(sandboxId)}/files?${query.toString()}`
     );
   }
-  openPort(sandboxId, input3) {
+  openPort(sandboxId, input) {
     return this.request(
       `/${encodeURIComponent(sandboxId)}/ports`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  createSnapshot(sandboxId, input3) {
+  createSnapshot(sandboxId, input) {
     return this.request(
       `/${encodeURIComponent(sandboxId)}/snapshots`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  updateSnapshot(sandboxId, snapshotId, input3) {
+  updateSnapshot(sandboxId, snapshotId, input) {
     return this.request(
       `/${encodeURIComponent(sandboxId)}/snapshots/${encodeURIComponent(
         snapshotId
       )}`,
       {
         method: "PATCH",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  validateSnapshot(sandboxId, snapshotId, input3 = {}) {
+  validateSnapshot(sandboxId, snapshotId, input = {}) {
     return this.request(
       `/${encodeURIComponent(sandboxId)}/snapshots/${encodeURIComponent(
         snapshotId
       )}/validate`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
@@ -2720,12 +2441,12 @@ var OpenPondSandboxInstanceClient = class {
       }
     );
   }
-  fork(sandboxId, input3 = {}) {
+  fork(sandboxId, input = {}) {
     return this.request(
       `/${encodeURIComponent(sandboxId)}/fork`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
@@ -2787,57 +2508,57 @@ var OpenPondSandboxInstanceClient = class {
       `/${encodeURIComponent(sandboxId)}/git/status`
     );
   }
-  gitDiff(sandboxId, input3 = {}) {
+  gitDiff(sandboxId, input = {}) {
     return this.request(
       `/${encodeURIComponent(sandboxId)}/git/diff`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  gitExportPatch(sandboxId, input3 = {}) {
+  gitExportPatch(sandboxId, input = {}) {
     return this.request(
       `/${encodeURIComponent(sandboxId)}/git/export-patch`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  gitBranch(sandboxId, input3) {
+  gitBranch(sandboxId, input) {
     return this.request(
       `/${encodeURIComponent(sandboxId)}/git/branch`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  gitCommit(sandboxId, input3) {
+  gitCommit(sandboxId, input) {
     return this.request(
       `/${encodeURIComponent(sandboxId)}/git/commit`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  gitPull(sandboxId, input3 = {}) {
+  gitPull(sandboxId, input = {}) {
     return this.request(
       `/${encodeURIComponent(sandboxId)}/git/pull`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  gitPush(sandboxId, input3 = {}) {
+  gitPush(sandboxId, input = {}) {
     return this.request(
       `/${encodeURIComponent(sandboxId)}/git/push`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
@@ -2849,11 +2570,11 @@ var OpenPondSandboxInstanceClient = class {
   pricing() {
     return this.request("/pricing");
   }
-  costs(input3 = {}) {
+  costs(input = {}) {
     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 (input.teamId) query.set("teamId", input.teamId);
+    if (input.projectId) query.set("projectId", input.projectId);
+    if (input.agentId) query.set("agentId", input.agentId);
     return this.request(
       `/costs${query.size > 0 ? `?${query.toString()}` : ""}`
     );
@@ -2863,12 +2584,12 @@ var OpenPondSandboxInstanceClient = class {
       `/${encodeURIComponent(sandboxId)}/integrations`
     );
   }
-  attachIntegrationConnection(sandboxId, input3) {
+  attachIntegrationConnection(sandboxId, input) {
     return this.request(
       `/${encodeURIComponent(sandboxId)}/integrations`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
@@ -2904,39 +2625,39 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
   projects = createSandboxProjectNamespace(this);
   agents = createSandboxAgentNamespace(this);
   workItems = createSandboxWorkItemNamespace(this);
-  list(input3 = {}) {
+  list(input = {}) {
     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 (input.teamId) query.set("teamId", input.teamId);
+    if (input.projectId) query.set("projectId", input.projectId);
+    if (input.agentId) query.set("agentId", input.agentId);
     return this.request(
       query.size > 0 ? `?${query.toString()}` : ""
     ).then((payload) => payload.sandboxes);
   }
-  listSecrets(input3 = {}) {
+  listSecrets(input = {}) {
     const query = new URLSearchParams();
-    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input.teamId) query.set("teamId", input.teamId);
     return this.requestApiRoot(
       `/sandbox-secrets${query.size > 0 ? `?${query.toString()}` : ""}`
     ).then((payload) => payload.secrets);
   }
-  getSecret(secretId, input3 = {}) {
+  getSecret(secretId, input = {}) {
     const query = new URLSearchParams();
-    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input.teamId) query.set("teamId", input.teamId);
     return this.requestApiRoot(
       `/sandbox-secrets/${encodeURIComponent(secretId)}${query.size > 0 ? `?${query.toString()}` : ""}`
     ).then((payload) => payload.secret);
   }
-  createSecret(input3) {
+  createSecret(input) {
     return this.requestApiRoot("/sandbox-secrets", {
       method: "POST",
-      body: JSON.stringify(input3)
+      body: JSON.stringify(input)
     }).then((payload) => payload.secret);
   }
-  rotateSecret(secretId, input3) {
+  rotateSecret(secretId, input) {
     const query = new URLSearchParams();
-    if (input3.teamId) query.set("teamId", input3.teamId);
-    const { teamId: _teamId, ...body } = input3;
+    if (input.teamId) query.set("teamId", input.teamId);
+    const { teamId: _teamId, ...body } = input;
     return this.requestApiRoot(
       `/sandbox-secrets/${encodeURIComponent(secretId)}/rotate${query.size > 0 ? `?${query.toString()}` : ""}`,
       {
@@ -2945,10 +2666,10 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       }
     ).then((payload) => payload.secret);
   }
-  attachSecret(secretId, input3) {
+  attachSecret(secretId, input) {
     const query = new URLSearchParams();
-    if (input3.teamId) query.set("teamId", input3.teamId);
-    const { teamId: _teamId, ...body } = input3;
+    if (input.teamId) query.set("teamId", input.teamId);
+    const { teamId: _teamId, ...body } = input;
     return this.requestApiRoot(
       `/sandbox-secrets/${encodeURIComponent(secretId)}/attach${query.size > 0 ? `?${query.toString()}` : ""}`,
       {
@@ -2957,67 +2678,67 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       }
     ).then((payload) => payload.secret);
   }
-  revokeSecret(secretId, input3 = {}) {
+  revokeSecret(secretId, input = {}) {
     const query = new URLSearchParams();
-    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input.teamId) query.set("teamId", input.teamId);
     return this.requestApiRoot(
       `/sandbox-secrets/${encodeURIComponent(secretId)}/revoke${query.size > 0 ? `?${query.toString()}` : ""}`,
       { method: "POST" }
     ).then((payload) => payload.secret);
   }
-  deleteSecret(secretId, input3 = {}) {
+  deleteSecret(secretId, input = {}) {
     const query = new URLSearchParams();
-    if (input3.teamId) query.set("teamId", input3.teamId);
+    if (input.teamId) query.set("teamId", input.teamId);
     return this.requestApiRoot(
       `/sandbox-secrets/${encodeURIComponent(secretId)}${query.size > 0 ? `?${query.toString()}` : ""}`,
       { method: "DELETE" }
     ).then((payload) => payload.secret);
   }
-  snapshotCatalog(input3 = {}) {
+  snapshotCatalog(input = {}) {
     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));
+    if (input.teamId) query.set("teamId", input.teamId);
+    if (input.projectId) query.set("projectId", input.projectId);
+    if (input.agentId) query.set("agentId", input.agentId);
+    if (input.q) query.set("q", input.q);
+    if (input.kind) query.set("kind", input.kind);
+    if (input.replayState) query.set("replayState", input.replayState);
+    if (input.visibility) query.set("visibility", input.visibility);
+    if (input.tag) query.set("tag", input.tag);
+    if (input.useCase) query.set("useCase", input.useCase);
+    if (input.limit) query.set("limit", String(input.limit));
     return this.request(
       `/catalog/snapshots${query.size > 0 ? `?${query.toString()}` : ""}`
     );
   }
-  listSandboxRuntimes(input3 = {}) {
+  listSandboxRuntimes(input = {}) {
     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 (input.teamId) query.set("teamId", input.teamId);
+    if (input.projectId) query.set("projectId", input.projectId);
+    if (input.agentId) query.set("agentId", input.agentId);
     return this.requestApiRoot(
       `/runtimes${query.size > 0 ? `?${query.toString()}` : ""}`
     ).then((payload) => payload.runtimes);
   }
-  listProjects(input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
+  listProjects(input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
     return this.requestApiRoot(
       `/projects?${query.toString()}`
     ).then((payload) => payload.projects);
   }
-  upsertProject(input3) {
+  upsertProject(input) {
     return this.requestApiRoot("/projects", {
       method: "POST",
-      body: JSON.stringify(input3)
+      body: JSON.stringify(input)
     }).then((payload) => payload.project);
   }
-  getHostedProfile(input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
+  getHostedProfile(input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
     return this.requestApiRoot(
       `/profile?${query.toString()}`
     ).then((payload) => payload.profile);
   }
-  ensureHostedProfile(input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
+  ensureHostedProfile(input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
     return this.requestApiRoot(
       `/profile/ensure?${query.toString()}`,
       { method: "POST" }
@@ -3028,9 +2749,9 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       return payload.profile;
     });
   }
-  pushHostedProfile(input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
-    const { teamId: _teamId, ...body } = input3;
+  pushHostedProfile(input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    const { teamId: _teamId, ...body } = input;
     return this.requestApiRoot(
       `/profile/push?${query.toString()}`,
       {
@@ -3039,33 +2760,33 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       }
     );
   }
-  async upsertProjectGitRemote(input3) {
-    const project = await this.upsertProject(input3);
-    return this.ensureProjectGitRemote(project.id, { teamId: input3.teamId });
+  async upsertProjectGitRemote(input) {
+    const project = await this.upsertProject(input);
+    return this.ensureProjectGitRemote(project.id, { teamId: input.teamId });
   }
-  getProject(projectId, input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
+  getProject(projectId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
     return this.requestApiRoot(
       `/projects/${encodeURIComponent(projectId)}?${query.toString()}`
     ).then((payload) => payload.project);
   }
-  syncProject(projectId, input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
+  syncProject(projectId, input) {
+    const query = new URLSearchParams({ teamId: input.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 });
+  ensureProjectGitRemote(projectId, input) {
+    const query = new URLSearchParams({ teamId: input.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;
+  uploadProjectSource(projectId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    const { teamId: _teamId, ...body } = input;
     return this.requestApiRoot(
       `/projects/${encodeURIComponent(projectId)}/source?${query.toString()}`,
       {
@@ -3074,9 +2795,9 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       }
     ).then((payload) => payload.project);
   }
-  updateProject(projectId, input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
-    const { teamId: _teamId, ...body } = input3;
+  updateProject(projectId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    const { teamId: _teamId, ...body } = input;
     return this.requestApiRoot(
       `/projects/${encodeURIComponent(projectId)}?${query.toString()}`,
       {
@@ -3085,41 +2806,41 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       }
     ).then((payload) => payload.project);
   }
-  archiveProject(projectId, input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
+  archiveProject(projectId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
     return this.requestApiRoot(
       `/projects/${encodeURIComponent(projectId)}?${query.toString()}`,
       { method: "DELETE" }
     ).then((payload) => payload.project);
   }
-  listAgents(input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
+  listAgents(input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
     return this.requestApiRoot(
       `/agents?${query.toString()}`
     ).then((payload) => payload.agents);
   }
-  upsertAgent(input3) {
+  upsertAgent(input) {
     return this.requestApiRoot("/agents", {
       method: "POST",
-      body: JSON.stringify(input3)
+      body: JSON.stringify(input)
     }).then((payload) => payload.agent);
   }
-  getAgent(agentId, input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
+  getAgent(agentId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
     return this.requestApiRoot(
       `/agents/${encodeURIComponent(agentId)}?${query.toString()}`
     ).then((payload) => payload.agent);
   }
-  archiveAgent(agentId, input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
+  archiveAgent(agentId, input) {
+    const query = new URLSearchParams({ teamId: input.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;
+  updateAgent(agentId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    const { teamId: _teamId, ...body } = input;
     return this.requestApiRoot(
       `/agents/${encodeURIComponent(agentId)}?${query.toString()}`,
       {
@@ -3128,7 +2849,7 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       }
     ).then((payload) => payload.agent);
   }
-  runAgent(agentId, input3) {
+  runAgent(agentId, input) {
     return this.requestApiRoot(
       `/agents/${encodeURIComponent(agentId)}/run`,
       {
@@ -3136,30 +2857,30 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
         headers: {
           Prefer: "respond-async"
         },
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  getAgentSourceDeployPlan(agentId, input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
+  getAgentSourceDeployPlan(agentId, input) {
+    const query = new URLSearchParams({ teamId: input.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));
+  listAgentManifestSnapshots(agentId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    if (input.limit !== void 0) query.set("limit", String(input.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;
+  requestAgentSourceChecks(agentId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    const { teamId: _teamId, ...body } = input;
     return this.requestApiRoot(
       `/agents/${encodeURIComponent(
         agentId
@@ -3170,9 +2891,9 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       }
     );
   }
-  publishAgentSource(agentId, input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
-    const { teamId: _teamId, ...body } = input3;
+  publishAgentSource(agentId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    const { teamId: _teamId, ...body } = input;
     return this.requestApiRoot(
       `/agents/${encodeURIComponent(
         agentId
@@ -3183,9 +2904,9 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       }
     );
   }
-  openAgentEditWorkItem(agentId, input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
-    const { teamId: _teamId, ...body } = input3;
+  openAgentEditWorkItem(agentId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    const { teamId: _teamId, ...body } = input;
     return this.requestApiRoot(
       `/agents/${encodeURIComponent(
         agentId
@@ -3196,109 +2917,109 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       }
     );
   }
-  getCodingWorkItem(workItemId, input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
-    if (input3.includeArchived) query.set("includeArchived", "true");
+  getCodingWorkItem(workItemId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    if (input.includeArchived) query.set("includeArchived", "true");
     return this.requestApiRoot(
       `/work-items/${encodeURIComponent(workItemId)}?${query.toString()}`
     ).then((payload) => payload.workItem);
   }
-  sendCodingWorkItemChat(workItemId, input3) {
+  sendCodingWorkItemChat(workItemId, input) {
     return this.requestApiRoot(
       `/work-items/${encodeURIComponent(workItemId)}/chat`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  listCodingWorkItemActivity(workItemId, input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
-    if (input3.limit !== void 0) query.set("limit", String(input3.limit));
+  listCodingWorkItemActivity(workItemId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    if (input.limit !== void 0) query.set("limit", String(input.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");
+  getCodingWorkItemStatus(workItemId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    if (input.limit !== void 0) query.set("limit", String(input.limit));
+    if (input.includeArchived) query.set("includeArchived", "true");
     return this.requestApiRoot(
       `/work-items/${encodeURIComponent(workItemId)}/status?${query.toString()}`
     );
   }
-  handleCodingWorkItemInBackground(workItemId, input3) {
+  handleCodingWorkItemInBackground(workItemId, input) {
     return this.requestApiRoot(
       `/work-items/${encodeURIComponent(workItemId)}/handle-background`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  promoteCodingWorkItemResult(workItemId, action, input3) {
+  promoteCodingWorkItemResult(workItemId, action, input) {
     return this.requestApiRoot(
       `/work-items/${encodeURIComponent(workItemId)}/result/${action}`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     ).then((payload) => payload.artifact);
   }
-  getMicrosoftTeamsBotOverview(input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
+  getMicrosoftTeamsBotOverview(input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
     return this.requestApiRoot(
       `/teams/bot/overview?${query.toString()}`
     );
   }
-  bindMicrosoftTeamsBotConversation(input3) {
+  bindMicrosoftTeamsBotConversation(input) {
     return this.requestApiRoot(
       "/teams/bot/bindings",
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  rebindMicrosoftTeamsBotConversation(bindingId, input3) {
+  rebindMicrosoftTeamsBotConversation(bindingId, input) {
     return this.requestApiRoot(
       `/teams/bot/bindings/${encodeURIComponent(bindingId)}`,
       {
         method: "PATCH",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  unlinkMicrosoftTeamsBotConversation(input3) {
+  unlinkMicrosoftTeamsBotConversation(input) {
     return this.requestApiRoot(
-      `/teams/bot/bindings/${encodeURIComponent(input3.bindingId)}`,
+      `/teams/bot/bindings/${encodeURIComponent(input.bindingId)}`,
       {
         method: "DELETE",
-        body: JSON.stringify({ teamId: input3.teamId })
+        body: JSON.stringify({ teamId: input.teamId })
       }
     );
   }
-  sendMicrosoftTeamsBotDiagnostic(input3) {
+  sendMicrosoftTeamsBotDiagnostic(input) {
     return this.requestApiRoot("/teams/bot/diagnostics", {
       method: "POST",
-      body: JSON.stringify(input3)
+      body: JSON.stringify(input)
     });
   }
-  sendMicrosoftTeamsBotDiagnosticRun(input3) {
+  sendMicrosoftTeamsBotDiagnosticRun(input) {
     return this.requestApiRoot(
       "/teams/bot/diagnostics/run",
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  createSandboxRuntime(input3) {
+  createSandboxRuntime(input) {
     return this.requestApiRoot("/runtimes", {
       method: "POST",
-      body: JSON.stringify(input3)
+      body: JSON.stringify(input)
     }).then((payload) => payload.runtime);
   }
   sandboxRuntime(runtimeId, initial = null) {
@@ -3309,22 +3030,22 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       `/runtimes/${encodeURIComponent(runtimeId)}`
     ).then((payload) => payload.runtime);
   }
-  createSandboxRuntimeSandbox(runtimeId, input3 = {}, options = {}) {
+  createSandboxRuntimeSandbox(runtimeId, input = {}, options = {}) {
     return this.requestApiRoot(
       `/runtimes/${encodeURIComponent(runtimeId)}/sandbox`,
       {
         method: "POST",
         headers: asyncRequestHeaders(options),
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  updateSandboxRuntimeStatus(runtimeId, input3) {
+  updateSandboxRuntimeStatus(runtimeId, input) {
     return this.requestApiRoot(
       `/runtimes/${encodeURIComponent(runtimeId)}/status`,
       {
         method: "PATCH",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     ).then((payload) => payload.runtime);
   }
@@ -3333,52 +3054,52 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       `/runtimes/${encodeURIComponent(runtimeId)}/events`
     );
   }
-  emitSandboxRuntimeEvent(runtimeId, input3) {
+  emitSandboxRuntimeEvent(runtimeId, input) {
     return this.requestApiRoot(
       `/runtimes/${encodeURIComponent(runtimeId)}/events`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  checkpointSandboxRuntime(runtimeId, input3) {
+  checkpointSandboxRuntime(runtimeId, input) {
     return this.requestApiRoot(
       `/runtimes/${encodeURIComponent(runtimeId)}/checkpoints`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     ).then((payload) => payload.runtime);
   }
-  promoteSandboxRuntime(runtimeId, input3, options = {}) {
+  promoteSandboxRuntime(runtimeId, input, 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)
+        body: JSON.stringify(input)
       }
     );
   }
-  preserveSandboxRuntimeSource(runtimeId, input3 = {}, options = {}) {
+  preserveSandboxRuntimeSource(runtimeId, input = {}, 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)
+        body: JSON.stringify(input)
       }
     );
   }
-  forkSnapshot(snapshotId, input3 = {}, options = {}) {
+  forkSnapshot(snapshotId, input = {}, options = {}) {
     const query = new URLSearchParams();
-    if (input3.teamId) query.set("teamId", input3.teamId);
-    if (input3.projectId) query.set("projectId", input3.projectId);
+    if (input.teamId) query.set("teamId", input.teamId);
+    if (input.projectId) query.set("projectId", input.projectId);
     if (options.async) query.set("async", "1");
-    const { teamId: _teamId, projectId: _projectId, ...body } = input3;
+    const { teamId: _teamId, projectId: _projectId, ...body } = input;
     return this.request(
       `/catalog/snapshots/${encodeURIComponent(snapshotId)}/fork${query.size > 0 ? `?${query.toString()}` : ""}`,
       {
@@ -3391,32 +3112,32 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       }
     );
   }
-  templates(input3 = {}) {
+  templates(input = {}) {
     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));
+    if (input.teamId) query.set("teamId", input.teamId);
+    if (input.projectId) query.set("projectId", input.projectId);
+    if (input.q) query.set("q", input.q);
+    if (input.name) query.set("name", input.name);
+    if (input.version) query.set("version", input.version);
+    if (input.visibility) query.set("visibility", input.visibility);
+    if (input.tag) query.set("tag", input.tag);
+    if (input.useCase) query.set("useCase", input.useCase);
+    if (input.limit) query.set("limit", String(input.limit));
     return this.request(
       `/templates${query.size > 0 ? `?${query.toString()}` : ""}`
     );
   }
-  publishedSnapshots(input3 = {}) {
+  publishedSnapshots(input = {}) {
     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));
+    if (input.teamId) query.set("teamId", input.teamId);
+    if (input.projectId) query.set("projectId", input.projectId);
+    if (input.q) query.set("q", input.q);
+    if (input.name) query.set("name", input.name);
+    if (input.version) query.set("version", input.version);
+    if (input.visibility) query.set("visibility", input.visibility);
+    if (input.tag) query.set("tag", input.tag);
+    if (input.useCase) query.set("useCase", input.useCase);
+    if (input.limit) query.set("limit", String(input.limit));
     return this.request(
       `/published-snapshots${query.size > 0 ? `?${query.toString()}` : ""}`
     ).then((payload) => {
@@ -3428,11 +3149,11 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       };
     });
   }
-  launchTemplate(input3) {
+  launchTemplate(input) {
     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;
+    if (input.teamId) query.set("teamId", input.teamId);
+    if (input.projectId) query.set("projectId", input.projectId);
+    const { teamId: _teamId, projectId: _projectId, ...body } = input;
     return this.request(
       `/templates/launch${query.size > 0 ? `?${query.toString()}` : ""}`,
       {
@@ -3441,11 +3162,11 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       }
     );
   }
-  runPublishedSnapshot(input3) {
+  runPublishedSnapshot(input) {
     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;
+    if (input.teamId) query.set("teamId", input.teamId);
+    if (input.projectId) query.set("projectId", input.projectId);
+    const { teamId: _teamId, projectId: _projectId, ...body } = input;
     return this.request(
       `/published-snapshots/launch${query.size > 0 ? `?${query.toString()}` : ""}`,
       {
@@ -3461,20 +3182,20 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       };
     });
   }
-  listSchedules(input3 = {}) {
+  listSchedules(input = {}) {
     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);
+    if (input.teamId) query.set("teamId", input.teamId);
+    if (input.projectId) query.set("projectId", input.projectId);
+    if (input.sourceSandboxId)
+      query.set("sourceSandboxId", input.sourceSandboxId);
     return this.request(
       `/schedules${query.size > 0 ? `?${query.toString()}` : ""}`
     );
   }
-  createSchedule(input3) {
+  createSchedule(input) {
     const query = new URLSearchParams();
-    if (input3.projectId) query.set("projectId", input3.projectId);
-    const { projectId: _projectId, ...body } = input3;
+    if (input.projectId) query.set("projectId", input.projectId);
+    const { projectId: _projectId, ...body } = input;
     return this.request(
       `/schedules${query.size > 0 ? `?${query.toString()}` : ""}`,
       {
@@ -3488,12 +3209,12 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       `/schedules/${encodeURIComponent(scheduleId)}`
     );
   }
-  updateSchedule(scheduleId, input3) {
+  updateSchedule(scheduleId, input) {
     return this.request(
       `/schedules/${encodeURIComponent(scheduleId)}`,
       {
         method: "PATCH",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
@@ -3505,34 +3226,34 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       }
     );
   }
-  listScheduleRuns(scheduleId, input3 = {}) {
+  listScheduleRuns(scheduleId, input = {}) {
     const query = new URLSearchParams();
-    if (input3.limit !== void 0) query.set("limit", String(input3.limit));
+    if (input.limit !== void 0) query.set("limit", String(input.limit));
     return this.request(
       `/schedules/${encodeURIComponent(scheduleId)}/runs${query.size > 0 ? `?${query.toString()}` : ""}`
     );
   }
-  runScheduleNow(scheduleId, input3 = {}) {
+  runScheduleNow(scheduleId, input = {}) {
     return this.request(
       `/schedules/${encodeURIComponent(scheduleId)}/run`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     );
   }
-  listTemplateBuilds(input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
+  listTemplateBuilds(input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
     return this.requestApiRoot(
       `/sandbox-template-builds?${query.toString()}`
     ).then((payload) => payload.builds);
   }
-  createTemplateBuild(input3) {
+  createTemplateBuild(input) {
     return this.requestApiRoot(
       "/sandbox-template-builds",
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     ).then((payload) => payload.build);
   }
@@ -3554,18 +3275,18 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       }
     ).then((payload) => payload.build);
   }
-  listPublishedSnapshotBuilds(input3) {
-    const query = new URLSearchParams({ teamId: input3.teamId });
+  listPublishedSnapshotBuilds(input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
     return this.requestApiRoot(
       `/published-snapshot-builds?${query.toString()}`
     ).then((payload) => payload.builds);
   }
-  createPublishedSnapshotBuild(input3) {
+  createPublishedSnapshotBuild(input) {
     return this.requestApiRoot(
       "/published-snapshot-builds",
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     ).then((payload) => payload.build);
   }
@@ -3592,10 +3313,10 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       "/organizations"
     ).then((payload) => payload.organizations ?? payload.teams ?? []);
   }
-  createOrganization(input3) {
+  createOrganization(input) {
     return this.requestApiRoot("/organizations", {
       method: "POST",
-      body: JSON.stringify(input3)
+      body: JSON.stringify(input)
     }).then((payload) => payload.organization);
   }
   getOrganization(slug) {
@@ -3603,12 +3324,12 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       `/organizations/${encodeURIComponent(slug)}`
     ).then((payload) => payload.organization);
   }
-  updateOrganization(slug, input3) {
+  updateOrganization(slug, input) {
     return this.requestApiRoot(
       `/organizations/${encodeURIComponent(slug)}`,
       {
         method: "PATCH",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     ).then((payload) => payload.organization);
   }
@@ -3617,12 +3338,12 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       `/organizations/${encodeURIComponent(slug)}/members`
     ).then((payload) => payload.members);
   }
-  upsertOrganizationMember(slug, input3) {
+  upsertOrganizationMember(slug, input) {
     return this.requestApiRoot(
       `/organizations/${encodeURIComponent(slug)}/members`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     ).then((payload) => payload.member);
   }
@@ -3631,12 +3352,12 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       `/organizations/${encodeURIComponent(slug)}/mcp-server`
     ).then((payload) => payload.mcpServer);
   }
-  generateOrganizationMcpServer(slug, input3 = {}) {
+  generateOrganizationMcpServer(slug, input = {}) {
     return this.requestApiRoot(
       `/organizations/${encodeURIComponent(slug)}/mcp-server`,
       {
         method: "POST",
-        body: JSON.stringify(input3)
+        body: JSON.stringify(input)
       }
     ).then((payload) => payload.mcpServer);
   }
@@ -3664,11 +3385,11 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       }
     ).then((payload) => payload.mcpServer);
   }
-  startReplay(input3) {
+  startReplay(input) {
     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;
+    if (input.teamId) query.set("teamId", input.teamId);
+    if (input.projectId) query.set("projectId", input.projectId);
+    const { teamId: _teamId, projectId: _projectId, ...body } = input;
     return this.requestApiRoot(
       `/sandbox-replays${query.size > 0 ? `?${query.toString()}` : ""}`,
       {
@@ -3677,42 +3398,42 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       }
     );
   }
-  listReplays(input3 = {}) {
+  listReplays(input = {}) {
     const query = new URLSearchParams();
-    if (input3.teamId) query.set("teamId", input3.teamId);
-    if (input3.projectId) query.set("projectId", input3.projectId);
+    if (input.teamId) query.set("teamId", input.teamId);
+    if (input.projectId) query.set("projectId", input.projectId);
     return this.requestApiRoot(
       `/sandbox-replays${query.size > 0 ? `?${query.toString()}` : ""}`
     );
   }
-  getReplay(replayId, input3 = {}) {
+  getReplay(replayId, input = {}) {
     const query = new URLSearchParams();
-    if (input3.teamId) query.set("teamId", input3.teamId);
-    if (input3.projectId) query.set("projectId", input3.projectId);
+    if (input.teamId) query.set("teamId", input.teamId);
+    if (input.projectId) query.set("projectId", input.projectId);
     return this.requestApiRoot(
       `/sandbox-replays/${encodeURIComponent(replayId)}${query.size > 0 ? `?${query.toString()}` : ""}`
     );
   }
-  getReplayLogs(replayId, input3 = {}) {
+  getReplayLogs(replayId, input = {}) {
     const query = new URLSearchParams();
-    if (input3.teamId) query.set("teamId", input3.teamId);
-    if (input3.projectId) query.set("projectId", input3.projectId);
+    if (input.teamId) query.set("teamId", input.teamId);
+    if (input.projectId) query.set("projectId", input.projectId);
     return this.requestApiRoot(
       `/sandbox-replays/${encodeURIComponent(replayId)}/logs${query.size > 0 ? `?${query.toString()}` : ""}`
     );
   }
-  getReplayArtifacts(replayId, input3 = {}) {
+  getReplayArtifacts(replayId, input = {}) {
     const query = new URLSearchParams();
-    if (input3.teamId) query.set("teamId", input3.teamId);
-    if (input3.projectId) query.set("projectId", input3.projectId);
+    if (input.teamId) query.set("teamId", input.teamId);
+    if (input.projectId) query.set("projectId", input.projectId);
     return this.requestApiRoot(
       `/sandbox-replays/${encodeURIComponent(replayId)}/artifacts${query.size > 0 ? `?${query.toString()}` : ""}`
     );
   }
-  cancelReplay(replayId, input3 = {}) {
+  cancelReplay(replayId, input = {}) {
     const query = new URLSearchParams();
-    if (input3.teamId) query.set("teamId", input3.teamId);
-    if (input3.projectId) query.set("projectId", input3.projectId);
+    if (input.teamId) query.set("teamId", input.teamId);
+    if (input.projectId) query.set("projectId", input.projectId);
     return this.requestApiRoot(
       `/sandbox-replays/${encodeURIComponent(replayId)}/cancel${query.size > 0 ? `?${query.toString()}` : ""}`,
       {
@@ -3720,12 +3441,12 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       }
     );
   }
-  integrationConnections(input3 = {}) {
+  integrationConnections(input = {}) {
     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);
+    if (input.teamId) query.set("teamId", input.teamId);
+    if (input.projectId) query.set("projectId", input.projectId);
+    if (input.agentId) query.set("agentId", input.agentId);
+    if (input.status) query.set("status", input.status);
     return this.requestApiRoot(
       `/integrations/connections${query.size > 0 ? `?${query.toString()}` : ""}`
     );
@@ -3753,361 +3474,15 @@ 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
-  };
-}
-
-// ../../packages/cloud/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,
+  getDeploymentLogs,
+  getDeploymentStatus,
   getLatestDeploymentForApp,
   getDeploymentDetail,
+  listApps,
   createRepo,
   updateAppCodeVisibility,
   createHeadlessApps,
@@ -4116,6 +3491,7 @@ export {
   deployLatestTemplate,
   updateAppEnvironment,
   getAppEnvironment,
+  listUserTools,
   createAgentFromPrompt,
   getUserPerformance,
   getAppRuntimeSummary,
@@ -4123,44 +3499,24 @@ export {
   checkOpenPondApiHealth,
   runAssistantMode,
   executeUserTool,
-  submitPositionsTx,
   submitBacktestRun,
   submitBacktestTx,
   submitBacktestDetail,
   executeHostedTool,
   openPondConfigDirectory,
   writePrivateJsonFile,
+  updatePrivateJsonFile,
   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
+  DEFAULT_CACHE_TTL_MS,
+  getCachedApps,
+  setCachedApps,
+  getCachedTools,
+  setCachedTools,
+  createOpenPondSandboxClient,
+  SANDBOX_RUNTIME_PROFILE_IDS
 };