openpond 0.0.30-bootstrap.0

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

@@ -0,0 +1,1090 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+
+// src/cli/common/options.ts
+function parseJsonOption(value, label) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new Error(`${label} must be valid JSON`);
+  }
+}
+function parseJsonObjectOption(value, label) {
+  const parsed = parseJsonOption(value, label);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${label} must be a JSON object`);
+  }
+  return parsed;
+}
+function optionString(options, key) {
+  const value = options[key];
+  return typeof value === "string" ? value.trim() : "";
+}
+function requiredTeamId(options, usage) {
+  const teamId = optionString(options, "teamId");
+  if (!teamId) {
+    throw new Error(`${usage} --team-id <id>`);
+  }
+  return teamId;
+}
+function optionalJsonObject(options, key, label) {
+  const value = optionString(options, key);
+  return value ? parseJsonObjectOption(value, label) : void 0;
+}
+function parseBooleanOption(value) {
+  if (value === true) return true;
+  if (typeof value === "string") {
+    return value.toLowerCase() === "true";
+  }
+  return false;
+}
+function parseNumberOption(value, label) {
+  if (typeof value !== "string") return void 0;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`${label} must be a number`);
+  }
+  return parsed;
+}
+function parseIntegerOption(value, label) {
+  const parsed = parseNumberOption(value, label);
+  if (parsed === void 0) return void 0;
+  if (!Number.isInteger(parsed)) {
+    throw new Error(`${label} must be an integer`);
+  }
+  return parsed;
+}
+function parseCsvOption(value) {
+  if (typeof value !== "string") return [];
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function parseTimeOption(value, label) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  if (/^\d+$/.test(trimmed)) return trimmed;
+  const parsed = Date.parse(trimmed);
+  if (!Number.isNaN(parsed)) {
+    return String(parsed);
+  }
+  throw new Error(`${label} must be a unix ms timestamp or ISO date`);
+}
+function resolveTemplateEnvironment(value) {
+  if (!value) return "production";
+  const normalized = value.toLowerCase();
+  if (normalized === "preview" || normalized === "production") {
+    return normalized;
+  }
+  throw new Error("env must be preview or production");
+}
+
+// src/cli/common/version.ts
+import { readFileSync } from "node:fs";
+import path from "node:path";
+function getInstalledCliVersion() {
+  const candidatePaths = [
+    "../../../package.json",
+    "../../package.json",
+    "../package.json",
+    "./package.json",
+    "../../../../package.json"
+  ];
+  for (const candidatePath of candidatePaths) {
+    try {
+      const packageJsonPath = new URL(candidatePath, import.meta.url);
+      const raw = readFileSync(packageJsonPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.version === "string") {
+        return parsed.version;
+      }
+    } catch {
+    }
+  }
+  try {
+    const raw = readFileSync(path.join(path.dirname(process.execPath), "package.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.version === "string") {
+      return parsed.version;
+    }
+  } catch {
+  }
+  return "unknown";
+}
+function parseSemver(version) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version.trim());
+  if (!match) return null;
+  const major = Number.parseInt(match[1], 10);
+  const minor = Number.parseInt(match[2], 10);
+  const patch = Number.parseInt(match[3], 10);
+  if (!Number.isFinite(major) || !Number.isFinite(minor) || !Number.isFinite(patch)) {
+    return null;
+  }
+  return [major, minor, patch];
+}
+function compareSemver(left, right) {
+  const l = parseSemver(left);
+  const r = parseSemver(right);
+  if (!l || !r) return null;
+  for (let i = 0; i < 3; i += 1) {
+    if (l[i] < r[i]) return -1;
+    if (l[i] > r[i]) return 1;
+  }
+  return 0;
+}
+async function fetchLatestNpmVersion(packageName) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 7e3);
+  try {
+    const response = await fetch(
+      `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`,
+      { signal: controller.signal }
+    );
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(
+        `npm registry request failed: ${response.status} ${text}`.trim()
+      );
+    }
+    const payload = await response.json().catch(() => ({}));
+    if (typeof payload.version !== "string" || payload.version.trim().length === 0) {
+      throw new Error("npm registry payload missing version");
+    }
+    return payload.version.trim();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/cli/command-option-schemas.ts
+var boolean = "boolean";
+var integer = "integer";
+var json = "json";
+var number = "number";
+var string = "string";
+var CHAT_OPTION_SCHEMA = {
+  approvalPolicy: string,
+  cwd: string,
+  json: boolean,
+  maxOutputBytes: integer,
+  message: string,
+  messageFile: string,
+  model: string,
+  noServerStart: boolean,
+  nonInteractive: boolean,
+  project: string,
+  provider: string,
+  sandbox: string,
+  server: string,
+  stdin: boolean,
+  timeoutSec: integer,
+  yes: boolean
+};
+var SANDBOX_OPTION_SCHEMA = {
+  access: string,
+  agentId: string,
+  all: boolean,
+  artifactPaths: string,
+  async: boolean,
+  authHeader: string,
+  authHeaderValue: string,
+  authToken: string,
+  autoStart: boolean,
+  baseRef: string,
+  branch: string,
+  budget: number,
+  budgetUsd: number,
+  cleanup: boolean,
+  cols: integer,
+  command: string,
+  content: string,
+  contentBase64: string,
+  contents: string,
+  contentsBase64: string,
+  cpu: number,
+  create: boolean,
+  description: string,
+  diskGb: number,
+  dockerBuildArgs: json,
+  dockerRegistrySecretRefs: string,
+  dockerfile: string,
+  dockerfileContext: string,
+  dockerfileTarget: string,
+  domain: string,
+  envLiteral: string,
+  envName: string,
+  envRef: string,
+  expectedMppMode: string,
+  expectedVersion: integer,
+  failOnUnpreservedChanges: boolean,
+  ffOnly: boolean,
+  forceWithLease: boolean,
+  fork: boolean,
+  fromPath: string,
+  idempotencyKey: string,
+  idleTimeoutSeconds: integer,
+  image: string,
+  imageDigest: string,
+  input: string,
+  inputBase64: string,
+  integrationCapabilities: string,
+  integrationConnection: string,
+  integrationScopes: string,
+  intervalMs: integer,
+  json: boolean,
+  keep: boolean,
+  label: string,
+  leaseId: string,
+  lifecycleHint: json,
+  manifestPath: string,
+  maxDurationSeconds: integer,
+  maxEntries: number,
+  maxResults: number,
+  memoryGb: number,
+  message: string,
+  name: string,
+  noPreview: boolean,
+  overwrite: boolean,
+  params: json,
+  path: string,
+  paths: string,
+  payload: json,
+  port: integer,
+  preview: boolean,
+  projectId: string,
+  publish: boolean,
+  q: string,
+  query: string,
+  rebase: boolean,
+  recursive: boolean,
+  registrySecretRef: string,
+  remote: string,
+  replayState: string,
+  repo: string,
+  respondAsync: boolean,
+  rows: integer,
+  runtimeAgentId: string,
+  runtimeBaseBranch: string,
+  runtimeBaseSha: string,
+  runtimeId: string,
+  runtimeProfileId: string,
+  runtimeProjectId: string,
+  runtimePromotionPolicy: string,
+  runtimeWorkspaceRoot: string,
+  sandboxId: string,
+  scope: string,
+  since: integer,
+  snapshot: boolean,
+  snapshotId: string,
+  sourceProjectId: string,
+  sourceRepoUrl: string,
+  sourceSandboxId: string,
+  startPoint: string,
+  status: string,
+  stdin: boolean,
+  summary: boolean,
+  tag: string,
+  tags: string,
+  targetId: string,
+  targetType: string,
+  teamId: string,
+  templateName: string,
+  templateVersion: string,
+  templateVisibility: string,
+  timeoutSeconds: integer,
+  toPath: string,
+  type: string,
+  useCase: string,
+  validationCommand: string,
+  value: string,
+  version: string,
+  volumeDeleteOnSandboxDelete: boolean,
+  volumeMountPath: string,
+  volumeName: string,
+  volumeStorageGb: number,
+  workflowMode: string
+};
+var SANDBOX_TEMPLATE_OPTION_SCHEMA = {
+  action: string,
+  agentId: string,
+  budget: number,
+  budgetUsd: number,
+  build: string,
+  branch: string,
+  commit: boolean,
+  commitMessage: string,
+  description: string,
+  dir: string,
+  disableSchedule: string,
+  disableSchedules: string,
+  enableSchedule: string,
+  enableSchedules: string,
+  entrypoint: string,
+  env: json,
+  envRef: string,
+  file: string,
+  force: boolean,
+  idleTimeoutSeconds: integer,
+  inherit: boolean,
+  input: json,
+  inputFile: string,
+  inputFiles: string,
+  inputJson: json,
+  inputs: json,
+  json: boolean,
+  keepTokenRemote: boolean,
+  manifest: string,
+  maxDurationSeconds: integer,
+  name: string,
+  noPush: boolean,
+  noWrite: boolean,
+  out: string,
+  outDir: string,
+  output: string,
+  outputDir: string,
+  params: json,
+  path: string,
+  plan: string,
+  projectId: string,
+  repo: string,
+  runtimeAgentId: string,
+  runtimeBaseBranch: string,
+  runtimeBaseSha: string,
+  runtimeId: string,
+  runtimeProjectId: string,
+  runtimePromotionPolicy: string,
+  scheduleMode: string,
+  scheduleOverride: json,
+  scheduleOverrides: json,
+  schedules: string,
+  service: string,
+  setRemoteToken: boolean,
+  setupTimeoutSeconds: integer,
+  target: string,
+  teamId: string,
+  timeoutSeconds: integer,
+  token: string,
+  workflowMode: string,
+  yes: boolean
+};
+var PROJECT_OPTION_SCHEMA = {
+  branch: string,
+  commitMessage: string,
+  defaultBranch: string,
+  description: string,
+  gitOwner: string,
+  gitRepo: string,
+  internalRepoPath: string,
+  json: boolean,
+  name: string,
+  path: string,
+  projectId: string,
+  repo: string,
+  sourceCheckDispatch: string,
+  sourceType: string,
+  teamId: string,
+  templateRepoUrl: string
+};
+var AGENT_OPTION_SCHEMA = {
+  agentId: string,
+  agentEdit: json,
+  allowLatestSource: boolean,
+  attachmentsJson: json,
+  baseSha: string,
+  chatMode: string,
+  checkKind: string,
+  conversationId: string,
+  cwd: string,
+  dispatch: string,
+  entrypointName: string,
+  entrypointScope: string,
+  expectedManifestHash: string,
+  evalStatus: string,
+  expectedSourceCommitSha: string,
+  idempotencyKey: string,
+  input: json,
+  inputFile: string,
+  json: boolean,
+  limit: integer,
+  message: string,
+  metadata: json,
+  name: string,
+  path: string,
+  payload: json,
+  projectId: string,
+  prompt: string,
+  publishedSnapshotId: string,
+  ref: string,
+  requirePublishedSnapshot: boolean,
+  requiredEnv: string,
+  requiredIntegrations: string,
+  runtimePromotionPolicy: string,
+  runtimeSourceMode: string,
+  sourceCheckDispatch: string,
+  sourceMode: string,
+  sourceRef: string,
+  status: string,
+  targetProjectId: string,
+  teamId: string,
+  triggerType: string,
+  workItemId: string,
+  workflowMode: string
+};
+
+// src/cli/command-registry.ts
+var CLI_GLOBAL_OPTION_SCHEMA = {
+  account: "string",
+  apiBaseUrl: "string",
+  apiBaseurl: "string",
+  baseUrl: "string",
+  baseurl: "string",
+  chatApiBaseUrl: "string",
+  chatApiBaseurl: "string",
+  checkUpdate: "boolean",
+  cwd: "string",
+  help: "boolean",
+  json: "boolean",
+  profile: "string",
+  sandboxApiUrl: "string",
+  sandboxApiurl: "string",
+  tui: "boolean",
+  version: "boolean"
+};
+var CLI_SHORT_OPTION_ALIASES = {
+  C: "cwd",
+  f: "force",
+  h: "help",
+  j: "json",
+  v: "version",
+  y: "yes"
+};
+var PROFILE_SDK_OPTION_SCHEMA = {
+  cwd: "string",
+  input: "json",
+  inputFile: "string",
+  json: "boolean",
+  path: "string"
+};
+var CLI_COMMAND_REGISTRY = [
+  {
+    name: "help",
+    usage: "openpond help",
+    optionSchema: {},
+    handler: async () => (await import("./help-LMH5FGT2.js")).printHelp()
+  },
+  {
+    name: "version",
+    usage: "openpond version",
+    optionSchema: {},
+    handler: () => console.log(getInstalledCliVersion())
+  },
+  {
+    name: "check-update",
+    usage: "openpond check-update",
+    optionSchema: {},
+    handler: async () => (await import("./core-commands-IM2UKLU4.js")).runCheckUpdate()
+  },
+  {
+    name: "login",
+    usage: "openpond login [--base-url <url>]",
+    optionSchema: CLI_GLOBAL_OPTION_SCHEMA,
+    handler: async ({ options }) => (await import("./core-commands-IM2UKLU4.js")).runLogin(options)
+  },
+  {
+    name: "init",
+    usage: "openpond init [--path <dir>]",
+    optionSchema: { path: "string" },
+    handler: async ({ options }) => (await import("./profile-NLDZDT3L.js")).runOpenPondInitCommand(options)
+  },
+  {
+    name: "profile",
+    usage: "openpond profile <current|init|load|check|push|commit|diff|catalog>",
+    optionSchema: {
+      checkKind: "string",
+      conversationId: "string",
+      ensureHosted: "boolean",
+      expectedManifestHash: "string",
+      force: "boolean",
+      hostedCheckKind: "string",
+      hostedRunAgentId: "string",
+      hostedRunConversationId: "string",
+      hostedRunIdempotencyKey: "string",
+      hostedRunInput: "json",
+      hostedRunRetry: "boolean",
+      hostedRunTargetProjectId: "string",
+      hostedSourceDispatch: "string",
+      hostedSourceAgentId: "string",
+      hostedSourceChecks: "boolean",
+      hostedSourceProjectId: "string",
+      json: "boolean",
+      kind: "string",
+      path: "string",
+      publishHostedSource: "boolean",
+      teamId: "string",
+      workItemId: "string"
+    },
+    handler: async ({ options, rest }) => (await import("./profile-NLDZDT3L.js")).runOpenPondProfileCommand(options, rest)
+  },
+  {
+    name: "agents",
+    usage: "openpond agents [--json]",
+    optionSchema: { json: "boolean" },
+    handler: async ({ options, rest }) => (await import("./profile-NLDZDT3L.js")).runOpenPondAgentsCommand(options, rest)
+  },
+  ...profileSdkAliasDefinitions(),
+  {
+    name: "extend",
+    usage: "openpond extend <instructions>",
+    optionSchema: { cwd: "string" },
+    handler: async ({ options, rest }) => (await import("./extend-YXCBULPO.js")).runOpenPondExtendCommand(options, rest)
+  },
+  {
+    name: "edit",
+    usage: "openpond edit <instructions>",
+    optionSchema: { cwd: "string" },
+    handler: async ({ options, rest }) => (await import("./extend-YXCBULPO.js")).runOpenPondEditCommand(options, rest)
+  },
+  {
+    name: "profiles",
+    usage: "openpond profiles [args]",
+    optionSchema: { json: "boolean" },
+    handler: async ({ options, rest }) => (await import("./core-commands-IM2UKLU4.js")).runProfiles(options, rest)
+  },
+  {
+    name: "account",
+    usage: "openpond account",
+    optionSchema: { json: "boolean" },
+    handler: async () => (await import("./core-commands-IM2UKLU4.js")).runAccount()
+  },
+  {
+    name: "health",
+    usage: "openpond health",
+    optionSchema: { json: "boolean" },
+    handler: async ({ options }) => (await import("./core-commands-IM2UKLU4.js")).runHealth(options)
+  },
+  {
+    name: "serve",
+    usage: "openpond serve [args]",
+    optionSchema: {
+      host: "string",
+      hostname: "string",
+      listen: "string",
+      port: "integer"
+    },
+    handler: async ({ options, rest }) => (await import("./app-layer-YKXEQGOW.js")).runOpenPondServerCommand("serve", options, rest)
+  },
+  {
+    name: "ui",
+    usage: "openpond ui [args]",
+    optionSchema: {
+      host: "string",
+      hostname: "string",
+      listen: "string",
+      port: "integer",
+      webRoot: "string"
+    },
+    handler: async ({ options, rest }) => (await import("./app-layer-YKXEQGOW.js")).runOpenPondServerCommand("web", options, rest)
+  },
+  {
+    name: "tui",
+    aliases: ["interactive"],
+    usage: "openpond tui [--provider <id>] [--model <id>] [--project <id>]",
+    optionSchema: {
+      cwd: "string",
+      model: "string",
+      noServerStart: "boolean",
+      project: "string",
+      provider: "string",
+      server: "string"
+    },
+    handler: async ({ options, rest }) => (await import("./app-layer-YKXEQGOW.js")).runOpenPondTerminalCommand(options, rest)
+  },
+  {
+    name: "chat",
+    usage: "openpond chat (--message-file <path>|--message <text>|--stdin) --non-interactive [--provider <id>] [--model <id>] [--project <id>] [--yes] [--approval-policy <policy>] [--json] [--timeout-sec <n>] [--max-output-bytes <n>] [--sandbox <mode>]",
+    optionSchema: CHAT_OPTION_SCHEMA,
+    handler: async ({ options, rest }) => (await import("./app-layer-YKXEQGOW.js")).runOpenPondTerminalCommand(options, rest)
+  },
+  {
+    name: "tool",
+    usage: "openpond tool <list|run> <handle>/<repo> [args]",
+    optionSchema: { body: "json", json: "boolean" },
+    handler: runToolCommand
+  },
+  {
+    name: "backtest",
+    usage: "openpond backtest <run|events|get> <handle>/<repo> [args]",
+    optionSchema: {
+      body: "json",
+      branch: "string",
+      deploymentId: "string",
+      limit: "integer",
+      runId: "string"
+    },
+    handler: runBacktestCommand
+  },
+  {
+    name: "deploy",
+    usage: "openpond deploy watch <handle>/<repo> [--branch <branch>]",
+    optionSchema: { branch: "string" },
+    handler: runDeployCommand
+  },
+  {
+    name: "template",
+    usage: "openpond template <status|branches|update> <handle>/<repo> [--env preview|production]",
+    optionSchema: { env: "string" },
+    handler: runTemplateCommand
+  },
+  {
+    name: "sandbox-template",
+    usage: "openpond sandbox-template <command> [args]",
+    optionSchema: SANDBOX_TEMPLATE_OPTION_SCHEMA,
+    handler: async ({ options, rest }) => (await import("./sandbox-template-LZN4F55Z.js")).runSandboxTemplateCommand(options, rest)
+  },
+  {
+    name: "repo",
+    usage: "openpond repo <create|push> [--name <name>] [--path <dir>] [--branch <branch>]",
+    optionSchema: {
+      branch: "string",
+      name: "string",
+      path: "string"
+    },
+    handler: runRepoCommand
+  },
+  {
+    name: "organizations",
+    aliases: ["organization"],
+    usage: "openpond organizations <login|list|use|logout|whoami> [args]",
+    optionSchema: {
+      callbackPort: "integer",
+      json: "boolean",
+      open: "boolean",
+      timeoutSeconds: "integer"
+    },
+    handler: async ({ options, rest }) => (await import("./organizations-4ISQRGMQ.js")).runOrganizationsCommand(options, rest)
+  },
+  {
+    name: "project",
+    usage: "openpond project <list|create|upsert|get|update|sync|source-upload|archive> [args]",
+    optionSchema: PROJECT_OPTION_SCHEMA,
+    handler: async ({ options, rest }) => (await import("./project-agent-ZPVO25HA.js")).runProjectCommand(options, rest)
+  },
+  {
+    name: "agent",
+    usage: "openpond agent <inspect|build|validate|eval|traces|list|create|upsert|get|update|run|run-test|bind-source|source|edit|archive> [args]",
+    usages: [
+      "openpond agent run <action> [--cwd <project>] [--input <json>]",
+      "openpond agent run <agentId> --team-id <id> [--conversation-id <id>] [--target-project-id <projectId>] [--input <json>]",
+      "openpond agent source check-status <workItemId> --team-id <id> [--limit <n>]",
+      "openpond agent edit open <agentId> --team-id <id> --project-id <id> [--message <text>]",
+      "openpond agent edit checkpoint-result|commit-result|pr-result <workItemId> --team-id <id> --ref <artifact-ref>"
+    ],
+    optionSchema: AGENT_OPTION_SCHEMA,
+    handler: async ({ options, rest }) => (await import("./project-agent-ZPVO25HA.js")).runAgentCommand(options, rest)
+  },
+  {
+    name: "goal",
+    usage: "openpond goal <command> [args]",
+    optionSchema: {
+      agentId: "string",
+      cwd: "string",
+      goalStorage: "string",
+      json: "boolean",
+      goalId: "string"
+    },
+    handler: async ({ options, rest }) => (await import("./cli-X3HPLSOV.js")).runGoalCommand(options, rest)
+  },
+  {
+    name: "harness",
+    usage: "openpond harness desktop <run|attach> <scenario...> [--isolated|--attach|--packaged|--none] [--app <path>] [--artifacts-dir <path>] [--json <path>]",
+    optionSchema: {
+      artifactsDir: "string",
+      attach: "boolean",
+      cwd: "string",
+      devtoolsPort: "integer",
+      grep: "string",
+      isolated: "boolean",
+      json: "string",
+      jsonPath: "string",
+      keepHome: "boolean",
+      none: "boolean",
+      server: "string",
+      timeoutMs: "integer",
+      token: "string",
+      tokenFile: "string"
+    },
+    handler: async ({ options, rest }) => (await import("./harness-GMK6IY2U.js")).runHarnessCommand(options, rest)
+  },
+  {
+    name: "sandbox",
+    usage: "openpond sandbox <command> [args]",
+    optionSchema: SANDBOX_OPTION_SCHEMA,
+    handler: async ({ options, rest }) => (await import("./sandbox-command-5GFJ2U3V.js")).runSandboxCommand(options, rest)
+  },
+  {
+    name: "opchat",
+    usage: "openpond opchat <command> [args]",
+    optionSchema: {
+      json: "boolean",
+      stream: "boolean"
+    },
+    handler: async ({ options, rest }) => (await import("./opchat-BWXZ32GX.js")).runOpChatCommand(options, rest)
+  },
+  {
+    name: "teams-bot",
+    usage: "openpond teams-bot <command> [args]",
+    optionSchema: {
+      json: "boolean",
+      teamId: "string"
+    },
+    handler: async ({ options, rest }) => (await import("./teams-bot-WP3FHKGA.js")).runTeamsBotCommand(options, rest)
+  },
+  {
+    name: "apps",
+    usage: "openpond apps <list|code-visibility|tools|deploy|env get|env set|performance|summary|assistant|store events|trade-facts|agent create|positions tx> [args]",
+    optionSchema: {
+      appId: "string",
+      body: "json",
+      env: "json",
+      json: "boolean",
+      limit: "integer",
+      refresh: "boolean",
+      teamId: "string",
+      watch: "boolean"
+    },
+    handler: runAppsCommand
+  },
+  {
+    name: "opentool",
+    usage: "openpond opentool <init|validate|build> [args]",
+    optionSchema: {},
+    handler: async ({ rest }) => (await import("./core-commands-IM2UKLU4.js")).runOpentool(rest)
+  }
+];
+var CLI_COMMAND_BY_NAME = /* @__PURE__ */ new Map();
+for (const definition of CLI_COMMAND_REGISTRY) {
+  CLI_COMMAND_BY_NAME.set(definition.name, definition);
+  for (const alias of definition.aliases ?? []) {
+    CLI_COMMAND_BY_NAME.set(alias, definition);
+  }
+}
+function listCliCommandDefinitions() {
+  return CLI_COMMAND_REGISTRY;
+}
+function getCliCommandDefinition(command) {
+  return CLI_COMMAND_BY_NAME.get(command) ?? null;
+}
+function getCliOptionKind(command, key) {
+  const definition = command ? getCliCommandDefinition(command) : null;
+  return definition?.optionSchema[key] ?? CLI_GLOBAL_OPTION_SCHEMA[key];
+}
+function getAnyCliOptionKind(key) {
+  const globalKind = CLI_GLOBAL_OPTION_SCHEMA[key];
+  if (globalKind) return globalKind;
+  for (const definition of CLI_COMMAND_REGISTRY) {
+    const kind = definition.optionSchema[key];
+    if (kind) return kind;
+  }
+  return void 0;
+}
+async function runCliCommand(context) {
+  const definition = getCliCommandDefinition(context.command);
+  if (!definition) return false;
+  if (parseBooleanOption(context.options.help)) {
+    printCliCommandUsage(definition);
+    return true;
+  }
+  await definition.handler(context);
+  return true;
+}
+function formatCliCommandUsage(definition) {
+  const lines = [
+    `Usage:`,
+    `  ${definition.usage}`,
+    ...(definition.usages ?? []).map((usage) => `  ${usage}`)
+  ];
+  if (definition.aliases?.length) {
+    lines.push("", `Aliases:`, `  ${definition.aliases.join(", ")}`);
+  }
+  const options = Object.entries(definition.optionSchema).sort(
+    ([left], [right]) => left.localeCompare(right)
+  );
+  if (options.length > 0) {
+    lines.push("", "Options:");
+    for (const [name, kind] of options) {
+      const optionName = cliOptionName(name);
+      lines.push(kind === "boolean" ? `  --${optionName}` : `  --${optionName} <${kind}>`);
+    }
+  }
+  return lines.join("\n");
+}
+function printCliCommandUsage(definition) {
+  console.log(formatCliCommandUsage(definition));
+}
+function cliOptionName(name) {
+  return name.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`);
+}
+function profileSdkAliasDefinitions() {
+  const aliases = ["inspect", "build", "validate", "eval", "run"];
+  return aliases.map((name) => ({
+    name,
+    usage: `openpond ${name} [args]`,
+    optionSchema: PROFILE_SDK_OPTION_SCHEMA,
+    handler: async ({ options, rest }) => (await import("./profile-NLDZDT3L.js")).runOpenPondProfileSdkAlias(name, options, rest)
+  }));
+}
+async function runToolCommand({ options, rest }) {
+  const { runToolList, runToolRun } = await import("./core-commands-IM2UKLU4.js");
+  const subcommand = rest[0];
+  if (subcommand === "list") {
+    const target = rest[1];
+    if (!target) {
+      throw new Error("usage: tool list <handle>/<repo>");
+    }
+    await runToolList(options, target);
+    return;
+  }
+  if (subcommand === "run") {
+    const target = rest[1];
+    const toolName = rest[2];
+    if (!target || !toolName) {
+      throw new Error(
+        "usage: tool run <handle>/<repo> <tool> [--body <json>]"
+      );
+    }
+    await runToolRun(options, target, toolName);
+    return;
+  }
+  throw new Error("usage: tool <list|run> <handle>/<repo> [args]");
+}
+async function runBacktestCommand({ options, rest }) {
+  const { runBacktestRun } = await import("./core-commands-IM2UKLU4.js");
+  const { runBacktestEvents, runBacktestGet } = await import("./apps-GGSIN2ZF.js");
+  const subcommand = rest[0] || "run";
+  if (subcommand === "run") {
+    const target = rest[1];
+    const toolName = rest[2];
+    if (!target || !toolName) {
+      throw new Error(
+        "usage: backtest run <handle>/<repo> <tool> [--body <json>] [--branch <branch>] [--deployment-id <id>]"
+      );
+    }
+    await runBacktestRun(options, target, toolName);
+    return;
+  }
+  if (subcommand === "events") {
+    const target = rest[1];
+    if (!target) {
+      throw new Error(
+        "usage: backtest events <handle>/<repo> [--run-id <id>] [--limit <n>]"
+      );
+    }
+    await runBacktestEvents(options, target);
+    return;
+  }
+  if (subcommand === "get") {
+    const target = rest[1];
+    if (!target) {
+      throw new Error("usage: backtest get <handle>/<repo> --run-id <id>");
+    }
+    await runBacktestGet(options, target);
+    return;
+  }
+  throw new Error("usage: backtest <run|events|get> <handle>/<repo> [args]");
+}
+async function runDeployCommand({ options, rest }) {
+  const { runDeployWatch } = await import("./core-commands-IM2UKLU4.js");
+  const subcommand = rest[0] || "watch";
+  if (subcommand !== "watch") {
+    throw new Error(
+      "usage: deploy watch <handle>/<repo> [--branch <branch>]"
+    );
+  }
+  const target = rest[1];
+  if (!target) {
+    throw new Error(
+      "usage: deploy watch <handle>/<repo> [--branch <branch>]"
+    );
+  }
+  await runDeployWatch(options, target);
+}
+async function runTemplateCommand({ options, rest }) {
+  const { runTemplateBranches, runTemplateStatus, runTemplateUpdate } = await import("./core-commands-IM2UKLU4.js");
+  const subcommand = rest[0] || "status";
+  const target = rest[1];
+  if (!target) {
+    throw new Error(
+      "usage: template <status|branches|update> <handle>/<repo> [--env preview|production]"
+    );
+  }
+  if (subcommand === "status") {
+    await runTemplateStatus(options, target);
+    return;
+  }
+  if (subcommand === "branches") {
+    await runTemplateBranches(options, target);
+    return;
+  }
+  if (subcommand === "update") {
+    await runTemplateUpdate(options, target);
+    return;
+  }
+  throw new Error(
+    "usage: template <status|branches|update> <handle>/<repo> [--env preview|production]"
+  );
+}
+async function runRepoCommand({ options, rest }) {
+  const { runRepoCreate, runRepoPush } = await import("./core-commands-IM2UKLU4.js");
+  const subcommand = rest[0] || "create";
+  if (subcommand === "create") {
+    await runRepoCreate(options, rest.slice(1));
+    return;
+  }
+  if (subcommand === "push") {
+    await runRepoPush(options);
+    return;
+  }
+  throw new Error(
+    "usage: repo <create|push> [--name <name>] [--path <dir>] [--branch <branch>]"
+  );
+}
+async function runAppsCommand({ options, rest }) {
+  const {
+    runAppsAgentCreate,
+    runAppsAssistant,
+    runAppsCodeVisibility,
+    runAppsDeploy,
+    runAppsEnvGet,
+    runAppsEnvSet,
+    runAppsList,
+    runAppsPerformance,
+    runAppsPositionsTx,
+    runAppsStoreEvents,
+    runAppsSummary,
+    runAppsTools,
+    runAppsToolsExecute,
+    runAppsTradeFacts
+  } = await import("./apps-GGSIN2ZF.js");
+  const subcommand = rest[0];
+  if (subcommand === "list") {
+    await runAppsList(options);
+    return;
+  }
+  if (subcommand === "code-visibility") {
+    const target = rest[1];
+    if (!target) {
+      throw new Error(
+        "usage: apps code-visibility <handle>/<repo> --visibility public|private"
+      );
+    }
+    await runAppsCodeVisibility(options, target);
+    return;
+  }
+  if (subcommand === "tools") {
+    if (rest[1] === "execute") {
+      const appId = rest[2];
+      const deploymentId = rest[3];
+      const toolName = rest[4];
+      if (!appId || !deploymentId || !toolName) {
+        throw new Error(
+          "usage: apps tools execute <appId> <deploymentId> <tool> [--body <json>]"
+        );
+      }
+      await runAppsToolsExecute(options, appId, deploymentId, toolName);
+      return;
+    }
+    await runAppsTools();
+    return;
+  }
+  if (subcommand === "deploy") {
+    const target = rest[1];
+    if (!target) {
+      throw new Error(
+        "usage: apps deploy <handle>/<repo> [--env preview|production] [--watch]"
+      );
+    }
+    await runAppsDeploy(options, target);
+    return;
+  }
+  if (subcommand === "env" && rest[1] === "get") {
+    const target = rest[2];
+    if (!target) {
+      throw new Error("usage: apps env get <handle>/<repo>");
+    }
+    await runAppsEnvGet(options, target);
+    return;
+  }
+  if (subcommand === "env" && rest[1] === "set") {
+    const target = rest[2];
+    if (!target) {
+      throw new Error("usage: apps env set <handle>/<repo> --env <json>");
+    }
+    await runAppsEnvSet(options, target);
+    return;
+  }
+  if (subcommand === "performance") {
+    await runAppsPerformance(options);
+    return;
+  }
+  if (subcommand === "summary") {
+    const target = rest[1];
+    if (!target) {
+      throw new Error("usage: apps summary <handle>/<repo>");
+    }
+    await runAppsSummary(options, target);
+    return;
+  }
+  if (subcommand === "assistant") {
+    const mode = rest[1];
+    const target = rest[2];
+    if (mode !== "plan" && mode !== "performance" || !target) {
+      throw new Error(
+        "usage: apps assistant <plan|performance> <handle>/<repo> --prompt <text>"
+      );
+    }
+    await runAppsAssistant(options, mode, target, rest.slice(3));
+    return;
+  }
+  if (subcommand === "store" && rest[1] === "events") {
+    await runAppsStoreEvents(options);
+    return;
+  }
+  if (subcommand === "trade-facts") {
+    await runAppsTradeFacts(options);
+    return;
+  }
+  if (subcommand === "agent" && rest[1] === "create") {
+    await runAppsAgentCreate(options, rest.slice(2));
+    return;
+  }
+  if (subcommand === "positions" && rest[1] === "tx") {
+    await runAppsPositionsTx(options);
+    return;
+  }
+  throw new Error(
+    "usage: apps <list|code-visibility|tools|deploy|env get|env set|performance|summary|assistant|store events|trade-facts|agent create|positions tx> [args]"
+  );
+}
+
+export {
+  parseJsonOption,
+  parseJsonObjectOption,
+  optionString,
+  requiredTeamId,
+  optionalJsonObject,
+  parseBooleanOption,
+  parseNumberOption,
+  parseIntegerOption,
+  parseCsvOption,
+  parseTimeOption,
+  resolveTemplateEnvironment,
+  getInstalledCliVersion,
+  compareSemver,
+  fetchLatestNpmVersion,
+  CLI_GLOBAL_OPTION_SCHEMA,
+  CLI_SHORT_OPTION_ALIASES,
+  listCliCommandDefinitions,
+  getCliCommandDefinition,
+  getCliOptionKind,
+  getAnyCliOptionKind,
+  runCliCommand,
+  formatCliCommandUsage
+};