openpond 0.1.1 → 0.2.1

package/dist/chunks/chunk-N3TGCM7J.js

@@ -1,1135 +0,0 @@
-import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
-import {
-  parseBooleanOption
-} from "./chunk-MUMPWI4O.js";
-
-// 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 = {
-  agent: string,
-  approvalPolicy: string,
-  cwd: string,
-  json: boolean,
-  maxOutputBytes: integer,
-  message: string,
-  messageFile: string,
-  model: string,
-  noServerStart: boolean,
-  nonInteractive: boolean,
-  project: string,
-  provider: string,
-  resume: 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,
-  env: string,
-  environment: 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,
-  allowedActions: string,
-  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,
-  provider: 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,
-  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-JNGJJFU5.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-MAN3CSJQ.js")).runCheckUpdate()
-  },
-  {
-    name: "login",
-    usage: "openpond login [--base-url <url>]",
-    optionSchema: CLI_GLOBAL_OPTION_SCHEMA,
-    handler: async ({ options }) => (await import("./core-commands-MAN3CSJQ.js")).runLogin(options)
-  },
-  {
-    name: "init",
-    usage: "openpond init [--path <dir>] [--profile <name>] [--template <name>] [--force] [--json]",
-    optionSchema: {
-      ...CLI_GLOBAL_OPTION_SCHEMA,
-      force: "boolean",
-      path: "string",
-      template: "string"
-    },
-    handler: async ({ options }) => (await import("./profile-P7HMONTZ.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"
-    },
-    handler: async ({ options, rest }) => (await import("./profile-P7HMONTZ.js")).runOpenPondProfileCommand(options, rest)
-  },
-  {
-    name: "agents",
-    usage: "openpond agents [--json]",
-    optionSchema: { json: "boolean" },
-    handler: async ({ options, rest }) => (await import("./profile-P7HMONTZ.js")).runOpenPondAgentsCommand(options, rest)
-  },
-  {
-    name: "actions",
-    usage: "openpond actions <check|build|run|dev|publish> [action-id] [--cwd DIR] [--input JSON|--input-file PATH]",
-    optionSchema: {
-      apiKey: "string",
-      baseUrl: "string",
-      cwd: "string",
-      input: "string",
-      inputFile: "string",
-      json: "boolean",
-      outputDirectory: "string",
-      sourceDirectory: "string",
-      sourceCommitSha: "string",
-      sourceRef: "string",
-      projectId: "string",
-      teamId: "string",
-      timeoutMs: "integer"
-    },
-    handler: async ({ options, rest }) => (await import("./actions-command-6N5XWMR6.js")).runProjectActionsCommand(options, rest)
-  },
-  ...profileSdkAliasDefinitions(),
-  {
-    name: "extension",
-    usage: "openpond extension <add|preview|list|inspect|update|remove> [owner/repo]",
-    usages: [
-      "openpond extension add <owner/repo> [--ref <branch|tag|sha>] [--json]",
-      "openpond extension update <owner/repo> [--ref <branch|tag|sha>] [--json]",
-      "openpond extension update --all [--json]",
-      "openpond extension remove <owner/repo> [--json]"
-    ],
-    optionSchema: { all: "boolean", json: "boolean", ref: "string" },
-    handler: async ({ options, rest }) => (await import("./extension-J3CIEDP4.js")).runOpenPondExtensionCommand(options, rest)
-  },
-  {
-    name: "profiles",
-    usage: "openpond profiles [args]",
-    optionSchema: { json: "boolean" },
-    handler: async ({ options, rest }) => (await import("./core-commands-MAN3CSJQ.js")).runProfiles(options, rest)
-  },
-  {
-    name: "account",
-    usage: "openpond account",
-    optionSchema: { json: "boolean" },
-    handler: async () => (await import("./core-commands-MAN3CSJQ.js")).runAccount()
-  },
-  {
-    name: "health",
-    usage: "openpond health",
-    optionSchema: { json: "boolean" },
-    handler: async ({ options }) => (await import("./core-commands-MAN3CSJQ.js")).runHealth(options)
-  },
-  {
-    name: "app-server",
-    usage: "openpond app-server [--store-dir DIR]",
-    optionSchema: {
-      storeDir: "string"
-    },
-    handler: async ({ options, rest }) => (await import("./app-layer-XEYHFJHI.js")).runOpenPondServerCommand("app-server", options, rest)
-  },
-  {
-    name: "serve",
-    usage: "openpond serve [args]",
-    optionSchema: {
-      host: "string",
-      hostname: "string",
-      listen: "string",
-      port: "integer"
-    },
-    handler: async ({ options, rest }) => (await import("./app-layer-XEYHFJHI.js")).runOpenPondServerCommand("serve", options, rest)
-  },
-  {
-    name: "ui",
-    usage: "openpond ui [--no-open] [--hostname HOST] [--port PORT]",
-    optionSchema: {
-      host: "string",
-      hostname: "string",
-      listen: "string",
-      noOpen: "boolean",
-      port: "integer",
-      webRoot: "string"
-    },
-    handler: async ({ options, rest }) => (await import("./app-layer-XEYHFJHI.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-XEYHFJHI.js")).runOpenPondTerminalCommand(options, rest)
-  },
-  {
-    name: "chat",
-    usage: "openpond chat (--message-file <path>|--message <text>|--stdin) --non-interactive [--provider <id>] [--model <id>] [--agent <id>] [--project <id>] [--resume <session-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-XEYHFJHI.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-S4WRUWJ6.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: {
-      accessToken: "string",
-      arguments: "json",
-      callbackPort: "integer",
-      clientId: "string",
-      customDomain: "string",
-      displayName: "string",
-      email: "string",
-      env: "string",
-      environment: "string",
-      json: "boolean",
-      name: "string",
-      open: "boolean",
-      origin: "string",
-      primaryContactEmail: "string",
-      printToken: "boolean",
-      resourceUrl: "string",
-      role: "string",
-      scope: "string",
-      scopes: "string",
-      slug: "string",
-      status: "string",
-      timeout: "integer",
-      timeoutSeconds: "integer",
-      tool: "string",
-      toolName: "string",
-      toolset: "string",
-      url: "string"
-    },
-    handler: async ({ options, rest }) => (await import("./organizations-MWAPNOCK.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-2RAK7GAZ.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|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 checks <agentId> --team-id <id> [--check-kind <kind>]",
-      "openpond agent source publish <agentId> --team-id <id> [--expected-manifest-hash <hash>]"
-    ],
-    optionSchema: AGENT_OPTION_SCHEMA,
-    handler: async ({ options, rest }) => (await import("./project-agent-2RAK7GAZ.js")).runAgentCommand(options, rest)
-  },
-  {
-    name: "desktop-test",
-    usage: "openpond desktop-test <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("./desktop-test-OE5SST2W.js")).runDesktopTestCommand(options, rest)
-  },
-  {
-    name: "sandbox",
-    usage: "openpond sandbox <command> [args]",
-    optionSchema: SANDBOX_OPTION_SCHEMA,
-    handler: async ({ options, rest }) => (await import("./sandbox-command-G22CPFNK.js")).runSandboxCommand(options, rest)
-  },
-  {
-    name: "continual",
-    usage: "openpond continual <init|validate|run|report> [manifest-or-series-id]",
-    usages: [
-      "openpond continual init --from <tasks.jsonl> [--output <continual-support.yaml>] [--non-interactive]",
-      "openpond continual validate <continual-support.yaml> [--json]",
-      "openpond continual run <continual-support.yaml> [--api-base-url <url>] [--json]",
-      "openpond continual report <comparison-series-id> [--output <report.json>] [--json]"
-    ],
-    optionSchema: {
-      apiBaseUrl: "string",
-      commit: "string",
-      correctionCasesPerFamily: "integer",
-      correctionSelection: "string",
-      description: "string",
-      from: "string",
-      grader: "string",
-      id: "string",
-      json: "boolean",
-      license: "string",
-      name: "string",
-      nonInteractive: "boolean",
-      output: "string",
-      repository: "string",
-      seed: "string",
-      semanticSimilarityThreshold: "number"
-    },
-    handler: async ({ options, rest }) => (await import("./continual-FYDKLCO7.js")).runContinualCommand(options, rest)
-  },
-  {
-    name: "training",
-    usage: "openpond training <create-project|start|status|watch|logs|cancel|resume|artifacts|benchmark> <taskset-id|model-run-id|run-id|model-id>",
-    usages: [
-      "openpond training create-project <taskset-id> --recipe <path> [--project-id <id>] [--profile <id>] [--name <name>] [--objective <text>] [--destination <id>] [--rollout-placement <local|remote>] [--gpu-placement-objective <fast|balanced|economical>] [--run-preset <preset>] [--max-spend <usd>] [--retention-days <days>] [--json]",
-      "openpond training start <model-project-id> [--comparison-series-entry <entry-id>] [--manifest <path>] [--yes] [--export-approved] [--max-spend <usd>] [--retention-days <days>] [--detach] [--json]",
-      "openpond training status <run-id> [--json]",
-      "openpond training watch <run-id> [--interval-ms <ms>] [--json]",
-      "openpond training logs <run-id> [--json]",
-      "openpond training cancel <run-id> [--json]",
-      "openpond training resume <model-run-id> [--json]",
-      "openpond training artifacts <run-id> [--json]",
-      "openpond training benchmark <model-id> [--provider <id>] [--model <id>] [--reasoning-effort <level>] [--max-spend <usd>] [--json]"
-    ],
-    optionSchema: {
-      apiBaseUrl: "string",
-      comparisonSeriesEntry: "string",
-      detach: "boolean",
-      destination: "string",
-      exportApproved: "boolean",
-      gpuPlacementObjective: "string",
-      intervalMs: "integer",
-      json: "boolean",
-      manifest: "string",
-      maxSpend: "number",
-      model: "string",
-      name: "string",
-      objective: "string",
-      profile: "string",
-      projectId: "string",
-      provider: "string",
-      recipe: "string",
-      reasoningEffort: "string",
-      retentionDays: "integer",
-      rolloutPlacement: "string",
-      runPreset: "string",
-      yes: "boolean"
-    },
-    handler: async ({ options, rest }) => (await import("./training-UPVSGDTB.js")).runTrainingCommand(options, rest)
-  },
-  {
-    name: "taskset",
-    usage: "openpond taskset <import|publish|readiness|delete-draft> <package-path|draft-id|taskset-id> [--profile <id>] [--model <id>] [--json]",
-    usages: [
-      "openpond taskset import <package-directory|taskset.json> [--profile <id>] [--json]",
-      "openpond taskset publish <draft-id> [--model <id>] [--json]",
-      "openpond taskset readiness <taskset-id> [--json]",
-      "openpond taskset delete-draft <draft-id> [--json]"
-    ],
-    optionSchema: {
-      apiBaseUrl: "string",
-      json: "boolean",
-      model: "string",
-      profile: "string"
-    },
-    handler: async ({ options, rest }) => (await import("./taskset-BMI7KOWP.js")).runTasksetCommand(options, rest)
-  },
-  {
-    name: "opchat",
-    usage: "openpond opchat <command> [args]",
-    optionSchema: {
-      compatModel: "string",
-      compatibilityModel: "string",
-      env: "string",
-      environment: "string",
-      json: "boolean",
-      message: "string",
-      model: "string",
-      opchatApiBaseUrl: "string",
-      opchatApiUrl: "string",
-      prompt: "string",
-      skipStream: "boolean",
-      skipTool: "boolean",
-      stream: "boolean"
-    },
-    handler: async ({ options, rest }) => (await import("./opchat-6HEQJFLL.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-5VBYEN7M.js")).runTeamsBotCommand(options, rest)
-  },
-  {
-    name: "apps",
-    usage: "openpond apps <list|code-visibility|tools|deploy|env get|env set|performance|summary|assistant|agent create> [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-MAN3CSJQ.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) : getCliCommandDefinition("ui");
-  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-P7HMONTZ.js")).runOpenPondProfileSdkAlias(name, options, rest)
-  }));
-}
-async function runToolCommand({ options, rest }) {
-  const { runToolList, runToolRun } = await import("./core-commands-MAN3CSJQ.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-MAN3CSJQ.js");
-  const { runBacktestEvents, runBacktestGet } = await import("./apps-GSXUDK6V.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-MAN3CSJQ.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-MAN3CSJQ.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-MAN3CSJQ.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,
-    runAppsSummary,
-    runAppsTools,
-    runAppsToolsExecute
-  } = await import("./apps-GSXUDK6V.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 === "agent" && rest[1] === "create") {
-    await runAppsAgentCreate(options, rest.slice(2));
-    return;
-  }
-  throw new Error(
-    "usage: apps <list|code-visibility|tools|deploy|env get|env set|performance|summary|assistant|agent create> [args]"
-  );
-}
-
-export {
-  getInstalledCliVersion,
-  compareSemver,
-  fetchLatestNpmVersion,
-  CLI_GLOBAL_OPTION_SCHEMA,
-  CLI_SHORT_OPTION_ALIASES,
-  listCliCommandDefinitions,
-  getCliCommandDefinition,
-  getCliOptionKind,
-  getAnyCliOptionKind,
-  runCliCommand,
-  formatCliCommandUsage
-};