openpond 0.0.38 → 0.0.40

package/dist/chunks/{chunk-275WCETC.js → chunk-FCVVOMIP.js}

@@ -1,24 +1,27 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  createOpenPondSandboxClient
+} from "./chunk-KHNHUA2H.js";
 import {
   mapUiBaseToApiBase,
   resolveBaseUrl,
   resolveSandboxApiUrlOption
-} from "./chunk-GDZYDLEL.js";
+} from "./chunk-SMNFI2FU.js";
 import {
   DEFAULT_CACHE_TTL_MS,
   SANDBOX_RUNTIME_PROFILE_IDS,
-  createOpenPondSandboxClient,
   getCachedApps,
   getCachedTools,
   getDeploymentLogs,
   getDeploymentStatus,
   listApps,
+  listConfiguredProfiles,
   listUserTools,
   loadConfig,
   saveGlobalConfig,
   setCachedApps,
   setCachedTools
-} from "./chunk-ZI4GDAUB.js";
+} from "./chunk-DBHSOTYZ.js";
 import {
   DEFAULT_OPENPOND_API_BASE_URL,
   DEFAULT_OPENPOND_WEB_BASE_URL
@@ -288,6 +291,99 @@ async function promptForPath(defaultPath) {
   }
 }
 
+// ../../packages/sdk/src/work.ts
+var MAX_WORK_INPUT_BYTES = 100 * 1024 * 1024;
+var WORK_OUTPUT_MIME_TYPES = Object.freeze({
+  ".avif": "image/avif",
+  ".csv": "text/csv",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".gif": "image/gif",
+  ".html": "text/html",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".json": "application/json",
+  ".m4a": "audio/mp4",
+  ".md": "text/markdown",
+  ".mov": "video/quicktime",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".svg": "image/svg+xml",
+  ".tsv": "text/tab-separated-values",
+  ".txt": "text/plain",
+  ".wav": "audio/wav",
+  ".webm": "video/webm",
+  ".webp": "image/webp",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+});
+
+// src/cli/common/vercel-protection.ts
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+function ensureStagingVercelProtectionBypass(requestUrl, options = {}) {
+  const env = options.env ?? process.env;
+  if (env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim()) return true;
+  if (!isOpenPondStagingUrl(requestUrl)) return false;
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const projectDirectories = candidateProjectDirectories(cwd, env);
+  const run = options.run ?? runProtectionCommand;
+  const command = process.platform === "win32" ? "vercel.cmd" : "vercel";
+  for (const projectDirectory of projectDirectories) {
+    const result = run({
+      command,
+      args: ["project", "protection", "--format", "json"],
+      cwd: projectDirectory,
+      env
+    });
+    if (result.status !== 0 || !result.stdout.trim()) continue;
+    const secret = vercelProtectionBypassSecret(result.stdout);
+    if (!secret) continue;
+    env.VERCEL_AUTOMATION_BYPASS_SECRET = secret;
+    return true;
+  }
+  return false;
+}
+function vercelProtectionBypassSecret(rawProtectionJson) {
+  try {
+    const payload = JSON.parse(rawProtectionJson);
+    const entries = Object.entries(payload.protectionBypass ?? {});
+    const selected = entries.find(([, metadata]) => metadata?.isEnvVar === true) ?? entries[0];
+    return selected?.[0]?.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function isOpenPondStagingUrl(requestUrl) {
+  try {
+    const hostname = new URL(requestUrl).hostname.toLowerCase();
+    return hostname === "staging.openpond.ai" || hostname === "staging-api.openpond.ai" || hostname.endsWith(".staging-api.openpond.ai");
+  } catch {
+    return false;
+  }
+}
+function candidateProjectDirectories(cwd, env) {
+  const configured = env.OPENPOND_VERCEL_PROJECT_DIR?.trim();
+  return [.../* @__PURE__ */ new Set([
+    ...configured ? [path.resolve(cwd, configured)] : [],
+    path.resolve(cwd, "../sandbox"),
+    cwd
+  ])];
+}
+function runProtectionCommand(input3) {
+  const result = spawnSync(input3.command, input3.args, {
+    cwd: input3.cwd,
+    env: input3.env,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  return {
+    status: result.status,
+    stdout: typeof result.stdout === "string" ? result.stdout : ""
+  };
+}
+
 // src/cli/common/sandbox-options.ts
 var SANDBOX_WORKFLOW_MODES = [
   "readonly",
@@ -317,13 +413,57 @@ function resolveSandboxBaseUrl(config, options) {
   return base.replace(/\/$/, "");
 }
 async function resolveSandboxClient(options) {
-  const config = await loadConfig();
+  const config = await loadSandboxConfig(options);
   const uiBase = resolveBaseUrl(config);
   const apiKey = await ensureApiKey(config, uiBase);
   const sandboxApiUrl = resolveSandboxApiUrlOption(options) || process.env.OPENPOND_SANDBOX_API_URL?.trim() || null;
+  const baseUrl = resolveSandboxBaseUrl(config, options);
+  ensureStagingVercelProtectionBypass(sandboxApiUrl ?? baseUrl);
   return createOpenPondSandboxClient(
-    sandboxApiUrl ? { apiKey, sandboxApiUrl } : { apiKey, baseUrl: resolveSandboxBaseUrl(config, options) }
+    sandboxApiUrl ? { apiKey, sandboxApiUrl } : { apiKey, baseUrl }
+  );
+}
+async function loadSandboxConfig(options) {
+  const environment = sandboxEnvironmentOption(options);
+  if (!environment) return loadConfig();
+  const profiles = await listConfiguredProfiles();
+  const requestedAccount = typeof options.account === "string" ? options.account.trim().toLowerCase() : typeof options.profile === "string" ? options.profile.trim().toLowerCase() : "";
+  const matches = profiles.filter(
+    (profile) => profileMatchesEnvironment(profile, environment) && (!requestedAccount || profile.handle.toLowerCase() === requestedAccount)
+  );
+  const selected = matches.find((profile) => profile.isActive) ?? (matches.length === 1 ? matches[0] : null);
+  if (!selected) {
+    throw new Error(
+      matches.length === 0 ? `no saved ${environment} OpenPond account found; run openpond login for that environment first` : `multiple saved ${environment} OpenPond accounts found; pass --account and --base-url to select one`
+    );
+  }
+  return loadConfig({
+    account: selected.handle,
+    ...selected.baseUrl ? { baseUrl: selected.baseUrl } : {}
+  });
+}
+function sandboxEnvironmentOption(options) {
+  const value = typeof options.env === "string" ? options.env.trim().toLowerCase() : typeof options.environment === "string" ? options.environment.trim().toLowerCase() : "";
+  if (!value) return null;
+  if (value !== "production" && value !== "staging") {
+    throw new Error("sandbox env must be staging or production");
+  }
+  return value;
+}
+function profileMatchesEnvironment(profile, environment) {
+  const hosts = [profile.baseUrl, profile.apiBaseUrl].flatMap((value) => {
+    if (!value) return [];
+    try {
+      return [new URL(value).hostname.toLowerCase()];
+    } catch {
+      return [];
+    }
+  });
+  const isStaging = hosts.some(
+    (hostname) => hostname === "staging.openpond.ai" || hostname === "staging-api.openpond.ai" || hostname.endsWith(".staging-api.openpond.ai")
   );
+  if (environment === "staging") return isStaging;
+  return !isStaging && profile.environment?.toLowerCase() === "production";
 }
 function parseSandboxWorkflowModeOption(value) {
   if (value === void 0) return void 0;

package/dist/chunks/{chunk-AHNFNWUN.js → chunk-HHALVXPK.js}

@@ -1,7 +1,7 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
   now
-} from "./chunk-HS2AGRDV.js";
+} from "./chunk-CZG4XKVF.js";
 
 // ../server/src/workspace/workspace-command.ts
 import { spawn, spawnSync } from "node:child_process";

package/dist/chunks/{chunk-GB6VUZUA.js → chunk-JIEUB6OS.js}

@@ -1,7 +1,7 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
   writePrivateJsonFile
-} from "./chunk-ZI4GDAUB.js";
+} from "./chunk-DBHSOTYZ.js";
 
 // ../../packages/cloud/src/profile/source-upload-cache.ts
 import { createHash } from "node:crypto";