openpond 0.2.0 → 0.2.1

package/dist/chunks/chunk-3VEYNDHN.js

@@ -1,669 +0,0 @@
-import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
-import {
-  DEFAULT_CACHE_TTL_MS,
-  SANDBOX_RUNTIME_PROFILE_IDS,
-  getCachedApps,
-  getCachedTools,
-  getDeploymentLogs,
-  getDeploymentStatus,
-  listApps,
-  listUserTools,
-  loadConfig,
-  saveGlobalConfig,
-  setCachedApps,
-  setCachedTools
-} from "./chunk-FJ2JGB2N.js";
-import {
-  mapUiBaseToApiBase,
-  resolveBaseUrl,
-  resolveSandboxApiUrlOption
-} from "./chunk-SMNFI2FU.js";
-import {
-  DEFAULT_OPENPOND_API_BASE_URL,
-  DEFAULT_OPENPOND_WEB_BASE_URL
-} from "./chunk-KSRWKXRB.js";
-import {
-  createOpenPondSandboxClient
-} from "./chunk-JTHL5XJ2.js";
-import {
-  parseBooleanOption
-} from "./chunk-MUMPWI4O.js";
-
-// 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 account credentials to the encrypted OpenPond credential store.");
-  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();
-}
-
-// src/cli/common/cache.ts
-async function fetchAppsWithCache(params) {
-  if (!params.forceRefresh) {
-    const cached = await getCachedApps({
-      apiBase: params.apiBase,
-      apiKey: params.apiKey,
-      ttlMs: DEFAULT_CACHE_TTL_MS
-    });
-    if (cached) {
-      return cached;
-    }
-  }
-  const apps = await listApps(params.apiBase, params.apiKey);
-  await setCachedApps({
-    apiBase: params.apiBase,
-    apiKey: params.apiKey,
-    apps
-  });
-  return apps;
-}
-async function fetchToolsWithCache(params) {
-  if (!params.forceRefresh) {
-    const cached = await getCachedTools({
-      apiBase: params.apiBase,
-      apiKey: params.apiKey,
-      ttlMs: DEFAULT_CACHE_TTL_MS
-    });
-    if (cached) {
-      return cached;
-    }
-  }
-  const result = await listUserTools(params.apiBase, params.apiKey);
-  const tools = Array.isArray(result.tools) ? result.tools : [];
-  await setCachedTools({
-    apiBase: params.apiBase,
-    apiKey: params.apiKey,
-    tools
-  });
-  return tools;
-}
-async function resolveAppTarget(apiBase, apiKey, target) {
-  const { handle, repo } = parseHandleRepo(target);
-  const apps = await fetchAppsWithCache({ apiBase, apiKey });
-  const normalizedRepo = normalizeRepoName(repo);
-  const match = apps.find((app) => {
-    if (app.handle && app.handle !== handle) {
-      return false;
-    }
-    const candidates = [app.repo, app.gitRepo, app.id].map(normalizeRepoName);
-    return candidates.includes(normalizedRepo);
-  });
-  if (!match) {
-    throw new Error(`app not found for ${handle}/${repo}`);
-  }
-  return { app: match, handle, repo };
-}
-async function pollDeploymentLogs(params) {
-  const intervalMs = params.intervalMs ?? 5e3;
-  const timeoutMs = params.timeoutMs ?? 4 * 60 * 1e3;
-  const seen = /* @__PURE__ */ new Set();
-  const startedAt = Date.now();
-  while (Date.now() - startedAt < timeoutMs) {
-    const logs = await getDeploymentLogs(
-      params.baseUrl,
-      params.apiKey,
-      params.deploymentId
-    );
-    const newLogs = logs.filter((log) => !seen.has(log.id));
-    for (const log of newLogs) {
-      seen.add(log.id);
-    }
-    for (const log of newLogs) {
-      console.log(`${params.prefix}${log.message}`);
-    }
-    const status = await getDeploymentStatus(
-      params.baseUrl,
-      params.apiKey,
-      params.deploymentId
-    );
-    if (status.status === "failed") {
-      console.log(`${params.prefix}deployment failed`);
-      return;
-    }
-    if (status.status === "running" || status.status === "deployed") {
-      console.log(`${params.prefix}deployment complete`);
-      return;
-    }
-    await new Promise((resolve) => setTimeout(resolve, intervalMs));
-  }
-  console.log(`${params.prefix}deployment still in progress`);
-}
-
-// src/cli/common/prompts.ts
-import { stdin as input2, stdout as output2 } from "node:process";
-import { createInterface as createInterface2 } from "node:readline/promises";
-async function readAllStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
-  }
-  return Buffer.concat(chunks).toString("utf8").replace(/\r?\n$/, "");
-}
-function readMaskedLine(prompt) {
-  return new Promise((resolve, reject) => {
-    const stdin = process.stdin;
-    const stderr = process.stderr;
-    let value = "";
-    const wasRaw = stdin.isRaw;
-    function cleanup() {
-      stdin.off("data", onData);
-      if (stdin.setRawMode) stdin.setRawMode(wasRaw);
-      stdin.pause();
-      stderr.write("\n");
-    }
-    function onData(chunk) {
-      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-      for (const byte of buffer) {
-        if (byte === 3) {
-          cleanup();
-          reject(new Error("secret prompt cancelled"));
-          return;
-        }
-        if (byte === 13 || byte === 10) {
-          cleanup();
-          resolve(value);
-          return;
-        }
-        if (byte === 127 || byte === 8) {
-          if (value.length > 0) {
-            value = value.slice(0, -1);
-            stderr.write("\b \b");
-          }
-          continue;
-        }
-        value += Buffer.from([byte]).toString("utf8");
-        stderr.write("*");
-      }
-    }
-    stderr.write(prompt);
-    stdin.resume();
-    if (stdin.setRawMode) stdin.setRawMode(true);
-    stdin.on("data", onData);
-  });
-}
-async function promptConfirm(question, defaultValue = false) {
-  const rl = createInterface2({ input: input2, output: output2 });
-  try {
-    const suffix = defaultValue ? "[Y/n]" : "[y/N]";
-    const answer = (await rl.question(`${question} ${suffix} `)).trim().toLowerCase();
-    if (!answer) return defaultValue;
-    return answer === "y" || answer === "yes";
-  } finally {
-    rl.close();
-  }
-}
-async function promptForPath(defaultPath) {
-  const rl = createInterface2({ input: input2, output: output2 });
-  try {
-    const answer = (await rl.question(`Local path (default: ${defaultPath}): `)).trim();
-    return answer || defaultPath;
-  } finally {
-    rl.close();
-  }
-}
-
-// 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) {
-  void options;
-  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 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);
-  return createOpenPondSandboxClient(
-    sandboxApiUrl ? { apiKey, sandboxApiUrl } : { apiKey, baseUrl }
-  );
-}
-async function loadSandboxConfig(options) {
-  void options;
-  return loadConfig();
-}
-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 {
-  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
-};