openpond 0.0.30-bootstrap.0

package/dist/chunks/chunk-5G4E547X.js

@@ -0,0 +1,294 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  CLI_SHORT_OPTION_ALIASES,
+  getAnyCliOptionKind,
+  getCliCommandDefinition,
+  getCliOptionKind,
+  parseJsonOption
+} from "./chunk-3Y4EL3P6.js";
+
+// ../../packages/cloud/src/urls.ts
+var DEFAULT_OPENPOND_WEB_BASE_URL = "https://openpond.ai";
+var DEFAULT_OPENPOND_API_BASE_URL = "https://api.openpond.ai";
+var DEFAULT_OPENPOND_OPCHAT_API_BASE_URL = "https://api.openpond.ai/opchat/v1";
+
+// src/cli/common/urls.ts
+var DEFAULT_OPENPOND_API_HOST = new URL(DEFAULT_OPENPOND_API_BASE_URL).hostname;
+var DEFAULT_OPENPOND_WEB_HOST = new URL(DEFAULT_OPENPOND_WEB_BASE_URL).hostname;
+function resolveAccountOption(options) {
+  const raw = typeof options.account === "string" ? options.account : typeof options.profile === "string" ? options.profile : null;
+  if (!raw) return null;
+  const trimmed = raw.trim();
+  if (!trimmed || trimmed === "true") {
+    throw new Error("account must be a non-empty value");
+  }
+  return trimmed;
+}
+function resolveBaseUrlOption(options) {
+  const raw = typeof options.baseUrl === "string" ? options.baseUrl : typeof options.baseurl === "string" ? options.baseurl : null;
+  if (!raw) return null;
+  const trimmed = raw.trim();
+  if (!trimmed || trimmed === "true") {
+    throw new Error("baseurl must be a non-empty value");
+  }
+  return trimmed.replace(/\/$/, "");
+}
+function resolveApiBaseUrlOption(options) {
+  const raw = typeof options.apiBaseUrl === "string" ? options.apiBaseUrl : typeof options.apiBaseurl === "string" ? options.apiBaseurl : null;
+  if (!raw) return null;
+  const trimmed = raw.trim();
+  if (!trimmed || trimmed === "true") {
+    throw new Error("api-base-url must be a non-empty value");
+  }
+  return trimmed.replace(/\/$/, "");
+}
+function resolveChatApiBaseUrlOption(options) {
+  const raw = typeof options.chatApiBaseUrl === "string" ? options.chatApiBaseUrl : typeof options.chatApiBaseurl === "string" ? options.chatApiBaseurl : typeof options.chatApiUrl === "string" ? options.chatApiUrl : null;
+  if (!raw) return null;
+  const trimmed = raw.trim();
+  if (!trimmed || trimmed === "true") {
+    throw new Error("chat-api-base-url must be a non-empty value");
+  }
+  return trimmed.replace(/\/$/, "");
+}
+function resolveSandboxApiUrlOption(options) {
+  const raw = typeof options.sandboxApiUrl === "string" ? options.sandboxApiUrl : typeof options.sandboxApiurl === "string" ? options.sandboxApiurl : null;
+  if (!raw) return null;
+  const trimmed = raw.trim();
+  if (!trimmed || trimmed === "true") {
+    throw new Error("sandbox-api-url must be a non-empty value");
+  }
+  return trimmed.replace(/\/$/, "");
+}
+function resolveBaseUrl(config) {
+  const envBase = process.env.OPENPOND_BASE_URL;
+  const base = envBase || config.baseUrl || DEFAULT_OPENPOND_WEB_BASE_URL;
+  return base.replace(/\/$/, "");
+}
+function mapUiBaseToApiBase(baseUrl) {
+  if (!baseUrl) return null;
+  const trimmed = baseUrl.replace(/\/$/, "");
+  try {
+    const url = new URL(trimmed);
+    const host = url.hostname.toLowerCase();
+    if (host === DEFAULT_OPENPOND_WEB_HOST || host === "openpond.live" || host === "www.openpond.live") {
+      return DEFAULT_OPENPOND_API_BASE_URL;
+    }
+    if (host === DEFAULT_OPENPOND_API_HOST || host.startsWith("api.")) {
+      return trimmed;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function resolvePublicApiBaseUrl(config) {
+  const envBase = process.env.OPENPOND_API_URL;
+  const configuredApiBase = config?.apiBaseUrl?.trim();
+  const mapped = mapUiBaseToApiBase(
+    process.env.OPENPOND_BASE_URL || config?.baseUrl
+  );
+  const base = envBase || configuredApiBase || mapped || DEFAULT_OPENPOND_API_BASE_URL;
+  return base.replace(/\/$/, "");
+}
+function normalizeTemplateRepoUrl(input, baseUrl) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error("template must be non-empty");
+  }
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+    return trimmed.endsWith(".git") ? trimmed : `${trimmed}.git`;
+  }
+  const normalizedBase = baseUrl.replace(/\/$/, "");
+  const [owner, repoRaw] = trimmed.includes("/") ? trimmed.split("/", 2) : ["openpondai", trimmed];
+  const repo = repoRaw.endsWith(".git") ? repoRaw.slice(0, -4) : repoRaw;
+  if (!owner || !repo) {
+    throw new Error("template must be <owner>/<repo> or a full https URL");
+  }
+  return `${normalizedBase}/${owner}/${repo}.git`;
+}
+
+// src/cli/common/args.ts
+var CLI_OPTION_VALUES = /* @__PURE__ */ Symbol("openpondCliOptionValues");
+var CliUsageError = class extends Error {
+  exitCode = 2;
+  constructor(message) {
+    super(message);
+    this.name = "CliUsageError";
+  }
+};
+var CLI_POSITIVE_INTEGER_OPTIONS = /* @__PURE__ */ new Set(["maxOutputBytes", "timeoutSec"]);
+function parseArgs(argv) {
+  const args = [...argv];
+  let command = "";
+  const options = {};
+  const optionValues = {};
+  const rest = [];
+  while (args.length > 0) {
+    const next = args.shift();
+    if (next === "--") {
+      rest.push(...args);
+      break;
+    }
+    if (next.startsWith("--")) {
+      const separatorIndex = next.indexOf("=");
+      const rawKey = separatorIndex >= 0 ? next.slice(2, separatorIndex) : next.slice(2);
+      const key = normalizeCliOptionKey(rawKey);
+      const value = separatorIndex >= 0 ? next.slice(separatorIndex + 1) : readOptionValue(args, key, command);
+      setParsedOption(options, optionValues, key, value, command);
+    } else if (isShortOptionToken(next)) {
+      parseShortOptionToken(next, args, options, optionValues);
+    } else {
+      if (!command) {
+        command = next;
+      } else {
+        rest.push(next);
+      }
+    }
+  }
+  Object.defineProperty(options, CLI_OPTION_VALUES, {
+    value: optionValues,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  validateCommandOptions(command, options);
+  return { command, options, rest };
+}
+function normalizeCliOptionKey(rawKey) {
+  return rawKey.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+function isShortOptionToken(value) {
+  return /^-[^-].*/.test(value) && !isNegativeNumber(value);
+}
+function parseShortOptionToken(token, args, options, optionValues) {
+  const body = token.slice(1);
+  if (!body) return;
+  const equalsIndex = body.indexOf("=");
+  const aliasBody = equalsIndex >= 0 ? body.slice(0, equalsIndex) : body;
+  const inlineValue = equalsIndex >= 0 ? body.slice(equalsIndex + 1) : null;
+  if (aliasBody.length !== 1) {
+    for (const alias of aliasBody) {
+      const key2 = CLI_SHORT_OPTION_ALIASES[alias];
+      if (!key2) {
+        throw new CliUsageError(`unknown short option -${alias}`);
+      }
+      const kind = getAnyCliOptionKind(key2);
+      if (kind !== "boolean") {
+        throw new CliUsageError(`short option -${alias} requires its own value`);
+      }
+      setParsedOption(options, optionValues, key2, "true");
+    }
+    return;
+  }
+  const key = CLI_SHORT_OPTION_ALIASES[aliasBody];
+  if (!key) {
+    throw new CliUsageError(`unknown short option -${aliasBody}`);
+  }
+  const value = inlineValue ?? readOptionValue(args, key);
+  setParsedOption(options, optionValues, key, value);
+}
+function readOptionValue(args, key, command) {
+  const kind = typedOptionKind(key, command);
+  if (kind === "boolean") {
+    if (args[0] && isBooleanLiteral(args[0])) return args.shift();
+    return "true";
+  }
+  if (kind) {
+    const next = args.shift();
+    if (next === void 0 || isOptionLike(next) && !isNegativeNumber(next)) {
+      if (next !== void 0) args.unshift(next);
+      throw new CliUsageError(`${cliOptionLabel(key)} must be ${optionKindPhrase(kind)}`);
+    }
+    return next;
+  }
+  return args[0] && !args[0].startsWith("--") ? args.shift() : "true";
+}
+function setParsedOption(options, optionValues, key, value, command) {
+  validateParsedOptionValue(key, value, command);
+  options[key] = value;
+  (optionValues[key] ??= []).push(value);
+}
+function validateParsedOptionValue(key, value, command) {
+  const kind = typedOptionKind(key, command);
+  if (!kind) return;
+  if (kind === "boolean") {
+    if (!isBooleanLiteral(value)) {
+      throw new CliUsageError(`${cliOptionLabel(key)} must be a boolean`);
+    }
+    return;
+  }
+  if (value.trim().length === 0 || value === "true") {
+    throw new CliUsageError(`${cliOptionLabel(key)} must be ${optionKindPhrase(kind)}`);
+  }
+  if (kind === "number" || kind === "integer") {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+      throw new CliUsageError(`${cliOptionLabel(key)} must be ${optionKindPhrase(kind)}`);
+    }
+    if (kind === "integer" && !Number.isInteger(parsed)) {
+      throw new CliUsageError(`${cliOptionLabel(key)} must be an integer`);
+    }
+    if (kind === "integer" && CLI_POSITIVE_INTEGER_OPTIONS.has(key) && parsed <= 0) {
+      throw new CliUsageError(`${cliOptionLabel(key)} must be a positive integer`);
+    }
+    return;
+  }
+  if (kind === "json") {
+    try {
+      parseJsonOption(value, cliOptionLabel(key));
+    } catch (error) {
+      throw new CliUsageError(error instanceof Error ? error.message : String(error));
+    }
+  }
+}
+function typedOptionKind(key, command) {
+  return command ? getCliOptionKind(command, key) : getAnyCliOptionKind(key);
+}
+function cliOptionLabel(key) {
+  return key.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`);
+}
+function optionKindLabel(kind) {
+  if (kind === "json") return "JSON value";
+  return kind;
+}
+function optionKindPhrase(kind) {
+  const label = optionKindLabel(kind);
+  return /^[aeiou]/i.test(label) ? `an ${label}` : `a ${label}`;
+}
+function isBooleanLiteral(value) {
+  return /^(true|false|1|0|yes|no)$/i.test(value);
+}
+function isOptionLike(value) {
+  return value.startsWith("-") && value !== "-";
+}
+function isNegativeNumber(value) {
+  return /^-\d+(?:\.\d+)?$/.test(value);
+}
+function validateCommandOptions(command, options) {
+  const definition = command ? getCliCommandDefinition(command) : null;
+  for (const key of Object.keys(options)) {
+    if (!getCliOptionKind(command, key)) {
+      const label = cliOptionLabel(key);
+      const suffix = definition ? ` for ${definition.name}` : "";
+      throw new CliUsageError(`unknown option --${label}${suffix}`);
+    }
+  }
+}
+
+export {
+  DEFAULT_OPENPOND_WEB_BASE_URL,
+  DEFAULT_OPENPOND_API_BASE_URL,
+  DEFAULT_OPENPOND_OPCHAT_API_BASE_URL,
+  resolveAccountOption,
+  resolveBaseUrlOption,
+  resolveApiBaseUrlOption,
+  resolveChatApiBaseUrlOption,
+  resolveSandboxApiUrlOption,
+  resolveBaseUrl,
+  mapUiBaseToApiBase,
+  resolvePublicApiBaseUrl,
+  normalizeTemplateRepoUrl,
+  CliUsageError,
+  parseArgs
+};