openpond 0.0.30-bootstrap.0

package/dist/chunks/chunk-Y6G6WRTG.js

@@ -0,0 +1,210 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  getBundledRuntimeVersion
+} from "./chunk-Q57SVPEH.js";
+
+// ../server/src/cli.ts
+import { existsSync } from "node:fs";
+import path2 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// ../server/src/constants.ts
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 17874;
+var VERSION = "0.0.30-bootstrap.0";
+var HOSTED_CHAT_SYSTEM_PROMPT = "You are OpenPond Chat. Respond in the user's language. If the user's latest message is language-neutral, ambiguous, or only a short test, respond in English. Be concise and directly answer the latest request. Do not use emojis. Use Markdown when it improves scanability. If you emit reasoning or thinking content, keep it sparse and user-readable: at most one short sentence for major progress, decisions, or blockers. Omit reasoning for routine searches, reads, tool calls, and obvious next steps. Do not restate the user request, narrate every action, or include code blocks, code excerpts, diffs, raw tool payloads, or markdown examples in reasoning. Put necessary code or exact snippets only in the final assistant answer. When the user asks to show or preview an image that is available as a workspace path or signed image URL, use Markdown image syntax like ![description](path-or-url) instead of a bare path or raw HTML. For workspace-backed answers, use a Codex-style shape: brief outcome first, then Changed Files if files changed, then Verification if checks ran. End with a concise final answer that summarizes the result and verification when relevant. Do not mention raw tool JSON, internal repo paths, or origin/remote URLs unless the user explicitly asks for them or they are necessary to explain a git/deploy failure.";
+var APP_PREFERENCES_CACHE_TYPE = "app_preferences";
+var APP_PREFERENCES_CACHE_KEY = "global";
+
+// ../server/src/utils.ts
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function textFromUnknown(value) {
+  if (typeof value === "string") return value;
+  if (value instanceof Error) return value.message || value.name;
+  if (value === null || value === void 0) return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function extractDelta(params) {
+  if (!params || typeof params !== "object") return "";
+  const record = params;
+  for (const key of ["delta", "text", "output", "chunk", "message"]) {
+    if (typeof record[key] === "string") return record[key];
+  }
+  if (record.delta && typeof record.delta === "object") return textFromUnknown(record.delta);
+  return "";
+}
+function event(input) {
+  return {
+    id: randomUUID(),
+    timestamp: now(),
+    ...input
+  };
+}
+function parseListen(input) {
+  const value = input.replace(/^https?:\/\//, "");
+  const [host, port] = value.split(":");
+  return {
+    host: host || DEFAULT_HOST,
+    port: port ? Number.parseInt(port, 10) : DEFAULT_PORT
+  };
+}
+function isCliEntrypoint(metaUrl) {
+  const entry = process.argv[1] ? path.resolve(process.argv[1]) : "";
+  return entry === path.resolve(fileURLToPath(metaUrl));
+}
+
+// ../server/src/cli.ts
+var __dirname = path2.dirname(fileURLToPath2(import.meta.url));
+function requireValue(args, index, flag) {
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) throw new Error(`${flag} requires a value.`);
+  return value;
+}
+function parsePort(value, flag) {
+  const port = Number.parseInt(value, 10);
+  if (!Number.isFinite(port) || port < 0 || port > 65535) throw new Error(`${flag} must be a port from 0 to 65535.`);
+  return port;
+}
+function parseCliArgs(args) {
+  let mode = "serve";
+  let host = DEFAULT_HOST;
+  let port = DEFAULT_PORT;
+  let webRoot = null;
+  let index = 0;
+  const command = args[0];
+  if (command && !command.startsWith("-")) {
+    if (command === "serve" || command === "server") mode = "serve";
+    else if (command === "web") mode = "web";
+    else if (command === "help") return { mode, host, port, webRoot, help: true };
+    else throw new Error(`Unknown command: ${command}`);
+    index = 1;
+  }
+  for (let i = index; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") return { mode, host, port, webRoot, help: true };
+    if (arg === "--listen") {
+      const listen = parseListen(requireValue(args, i, arg));
+      host = listen.host;
+      port = parsePort(String(listen.port), arg);
+      i += 1;
+    } else if (arg === "--hostname" || arg === "--host") {
+      host = requireValue(args, i, arg);
+      i += 1;
+    } else if (arg === "--port") {
+      port = parsePort(requireValue(args, i, arg), arg);
+      i += 1;
+    } else if (arg === "--web-root") {
+      webRoot = path2.resolve(requireValue(args, i, arg));
+      i += 1;
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return { mode, host, port, webRoot, help: false };
+}
+function defaultWebRootCandidates() {
+  return [
+    process.env.OPENPOND_WEB_ROOT,
+    path2.resolve(process.cwd(), "apps/web/dist"),
+    path2.resolve(__dirname, "../../web/dist"),
+    path2.resolve(process.cwd(), "web"),
+    path2.resolve(__dirname, "../web")
+  ].filter((candidate) => Boolean(candidate));
+}
+function resolveWebRoot(explicitWebRoot) {
+  const candidates = explicitWebRoot ? [explicitWebRoot] : defaultWebRootCandidates();
+  for (const candidate of candidates) {
+    const resolved = path2.resolve(candidate);
+    if (existsSync(path2.join(resolved, "index.html"))) return resolved;
+  }
+  return null;
+}
+function formatHostForUrl(host) {
+  const browserHost = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
+  return browserHost.includes(":") && !browserHost.startsWith("[") ? `[${browserHost}]` : browserHost;
+}
+function browserBaseUrl(instance) {
+  return `http://${formatHostForUrl(instance.status.host)}:${instance.status.port}`;
+}
+function tokenizedWebUrl(baseUrl, token) {
+  const url = new URL(baseUrl);
+  const params = new URLSearchParams();
+  params.set("openpondServerUrl", baseUrl);
+  params.set("openpondToken", token);
+  url.hash = params.toString();
+  return url.toString();
+}
+function printHelp() {
+  console.log(`Usage:
+  openpond-app-server serve [--hostname HOST] [--port PORT]
+  openpond-app-server web [--hostname HOST] [--port PORT] [--web-root DIR]
+
+Options:
+  --listen HOST:PORT     Set host and port together
+  --hostname HOST        Bind host (default ${DEFAULT_HOST})
+  --port PORT            Bind port, or 0 for any free port (default ${DEFAULT_PORT})
+  --web-root DIR         Directory containing the built web UI for web mode
+`);
+}
+async function runOpenPondServerCli(createOpenPondServer) {
+  const args = parseCliArgs(process.argv.slice(2));
+  if (args.help) {
+    printHelp();
+    return;
+  }
+  const webRoot = args.mode === "web" ? resolveWebRoot(args.webRoot) : null;
+  if (args.mode === "web" && !webRoot) {
+    throw new Error("Could not find a built OpenPond web UI. Run `pnpm build:web` or pass --web-root.");
+  }
+  const instance = await createOpenPondServer({ host: args.host, port: args.port, webRoot });
+  const webUrl = args.mode === "web" ? tokenizedWebUrl(browserBaseUrl(instance), instance.token) : null;
+  console.log(
+    `OPENPOND_APP_SERVER_READY ${JSON.stringify({
+      mode: args.mode,
+      url: instance.url,
+      webUrl,
+      webRoot,
+      tokenFile: instance.tokenFile,
+      storePath: instance.storePath,
+      runtime: getBundledRuntimeVersion()
+    })}`
+  );
+  if (webUrl) {
+    console.log(`OpenPond web UI: ${webUrl}`);
+    console.log(`Tailscale Serve URL token: #openpondToken=${encodeURIComponent(instance.token)}`);
+  } else {
+    console.log(`OpenPond API server: ${instance.url}`);
+  }
+  const shutdown = async () => {
+    await instance.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => void shutdown());
+  process.on("SIGTERM", () => void shutdown());
+  await new Promise(() => {
+  });
+}
+
+export {
+  DEFAULT_HOST,
+  DEFAULT_PORT,
+  VERSION,
+  HOSTED_CHAT_SYSTEM_PROMPT,
+  APP_PREFERENCES_CACHE_TYPE,
+  APP_PREFERENCES_CACHE_KEY,
+  now,
+  textFromUnknown,
+  extractDelta,
+  event,
+  isCliEntrypoint,
+  runOpenPondServerCli
+};

package/dist/chunks/cli-NVKNE4AZ.js

@@ -0,0 +1,11 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  runOpenPondServerCli
+} from "./chunk-Y6G6WRTG.js";
+import "./chunk-Q57SVPEH.js";
+import "./chunk-LHYK6QO2.js";
+import "./chunk-WYDVQOBL.js";
+import "./chunk-UACZUFIA.js";
+export {
+  runOpenPondServerCli
+};

package/dist/chunks/cli-X3HPLSOV.js

@@ -0,0 +1,19 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  createLocalGoal,
+  printGoalHelp,
+  runGoalCommand
+} from "./chunk-4HYJG2JE.js";
+import "./chunk-NLBKZZEK.js";
+import "./chunk-VQX33YAG.js";
+import "./chunk-LHYK6QO2.js";
+import "./chunk-WYDVQOBL.js";
+import "./chunk-XSAXENQD.js";
+import "./chunk-5G4E547X.js";
+import "./chunk-3Y4EL3P6.js";
+import "./chunk-UACZUFIA.js";
+export {
+  createLocalGoal,
+  printGoalHelp,
+  runGoalCommand
+};

package/dist/chunks/core-commands-IM2UKLU4.js

@@ -0,0 +1,41 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  resolveGitBranch,
+  runAccount,
+  runBacktestRun,
+  runCheckUpdate,
+  runDeployWatch,
+  runHealth,
+  runLogin,
+  runOpentool,
+  runProfiles,
+  runRepoCreate,
+  runRepoPush,
+  runTemplateBranches,
+  runTemplateStatus,
+  runTemplateUpdate,
+  runToolList,
+  runToolRun
+} from "./chunk-74O6FGVN.js";
+import "./chunk-XSAXENQD.js";
+import "./chunk-5G4E547X.js";
+import "./chunk-3Y4EL3P6.js";
+import "./chunk-UACZUFIA.js";
+export {
+  resolveGitBranch,
+  runAccount,
+  runBacktestRun,
+  runCheckUpdate,
+  runDeployWatch,
+  runHealth,
+  runLogin,
+  runOpentool,
+  runProfiles,
+  runRepoCreate,
+  runRepoPush,
+  runTemplateBranches,
+  runTemplateStatus,
+  runTemplateUpdate,
+  runToolList,
+  runToolRun
+};

package/dist/chunks/extend-YXCBULPO.js

@@ -0,0 +1,84 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import "./chunk-KRKGHVMQ.js";
+import "./chunk-W5GKHH77.js";
+import {
+  loadOpenPondProfileState
+} from "./chunk-FUP7EGT7.js";
+import "./chunk-I6HN3ZGW.js";
+import {
+  createLocalGoal,
+  runGoalCommand
+} from "./chunk-4HYJG2JE.js";
+import "./chunk-NLBKZZEK.js";
+import "./chunk-VQX33YAG.js";
+import "./chunk-LHYK6QO2.js";
+import "./chunk-BYAPLT37.js";
+import "./chunk-WYDVQOBL.js";
+import "./chunk-XSAXENQD.js";
+import "./chunk-5G4E547X.js";
+import "./chunk-3Y4EL3P6.js";
+import "./chunk-UACZUFIA.js";
+
+// src/cli/extend.ts
+async function runOpenPondExtendCommand(options, rest) {
+  await runOpenPondAgentPipelineCommand({
+    options,
+    rest,
+    kind: "create_agent",
+    command: "openpond extend",
+    surface: "local_extend",
+    usage: 'usage: extend "<profile capability change>" [--run]'
+  });
+}
+async function runOpenPondEditCommand(options, rest) {
+  await runOpenPondAgentPipelineCommand({
+    options,
+    rest,
+    kind: "update_agent",
+    command: "/edit",
+    surface: "direct_prompt_edit",
+    usage: 'usage: edit "<profile agent change>" [--agent-id <id>] [--run]'
+  });
+}
+async function runOpenPondAgentPipelineCommand(params) {
+  const { options, rest } = params;
+  const state = await loadOpenPondProfileState();
+  if (state.error) throw new Error(state.error);
+  if (!state.sourcePath) {
+    throw new Error("No active OpenPond profile. Run `openpond init` or `openpond profile load --path <dir>`.");
+  }
+  const goalOptions = { ...options };
+  if (typeof goalOptions.cwd !== "string" || goalOptions.cwd.trim().length === 0) {
+    goalOptions.cwd = state.sourcePath;
+  }
+  if (params.kind === "update_agent") {
+    const selectedAgentId = typeof goalOptions.agentId === "string" && goalOptions.agentId.trim() ? goalOptions.agentId.trim() : state.agents[0]?.id ?? "default";
+    goalOptions.agentId = selectedAgentId;
+  }
+  const objective = rest.join(" ").trim();
+  if (!objective) {
+    throw new Error(params.usage);
+  }
+  const goal = await createLocalGoal({
+    options: goalOptions,
+    objective,
+    kind: params.kind,
+    createPipeline: {
+      command: params.command,
+      surface: params.surface,
+      profile: {
+        activeProfile: state.activeProfile,
+        repoPath: state.repoPath,
+        sourcePath: state.sourcePath,
+        localHead: state.git?.head ?? null
+      }
+    }
+  });
+  if (options.run === true || options.run === "true") {
+    await runGoalCommand({ ...goalOptions, goalId: goal.id }, ["run"]);
+  }
+}
+export {
+  runOpenPondEditCommand,
+  runOpenPondExtendCommand
+};

package/dist/chunks/harness-GMK6IY2U.js

@@ -0,0 +1,140 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  runProcessCommand
+} from "./chunk-XSAXENQD.js";
+import {
+  CliUsageError
+} from "./chunk-5G4E547X.js";
+import {
+  optionString,
+  parseBooleanOption
+} from "./chunk-3Y4EL3P6.js";
+import "./chunk-UACZUFIA.js";
+
+// src/cli/harness.ts
+import path from "node:path";
+import { access } from "node:fs/promises";
+import { constants } from "node:fs";
+import { createRequire } from "node:module";
+var DESKTOP_HARNESS_SCRIPT = path.join("scripts", "desktop-harness.ts");
+async function runHarnessCommand(options, rest) {
+  const invocation = await buildDesktopHarnessInvocation({ options, rest });
+  const result = await runProcessCommand(invocation.command, invocation.args, {
+    cwd: invocation.cwd,
+    inherit: true,
+    timeoutMs: 0
+  });
+  if (result.code !== 0) {
+    throw new HarnessCommandFailedError(result.code);
+  }
+}
+async function buildDesktopHarnessInvocation(input) {
+  const options = input.options;
+  const rest = input.rest;
+  const surface = rest[0];
+  const action = rest[1];
+  if (surface !== "desktop" || action !== "run" && action !== "attach") {
+    throw new CliUsageError(desktopHarnessCliUsage());
+  }
+  const scenarios = rest.slice(2);
+  if (scenarios.length === 0) {
+    throw new CliUsageError("usage: openpond harness desktop run <scenario...> [options]");
+  }
+  const startCwd = optionString(options, "cwd") || input.cwd || process.cwd();
+  const repoRoot = await resolveDesktopHarnessRepoRoot(startCwd);
+  const env = input.env ?? process.env;
+  const command = env.OPENPOND_NODE_BINARY?.trim() || process.execPath;
+  const tsxCli = createRequire(import.meta.url).resolve("tsx/cli");
+  const args = [tsxCli, DESKTOP_HARNESS_SCRIPT, "run", ...scenarios];
+  const launchMode = resolveLaunchMode(options, action);
+  if (launchMode) args.push(`--${launchMode}`);
+  appendStringFlag(args, "--app", options, "app");
+  appendStringFlag(args, "--server", options, "server");
+  appendStringFlag(args, "--token", options, "token");
+  appendStringFlag(args, "--token-file", options, "tokenFile");
+  appendStringFlag(args, "--devtools-port", options, "devtoolsPort");
+  appendStringFlag(args, "--artifacts-dir", options, "artifactsDir");
+  appendJsonFlag(args, options);
+  appendStringFlag(args, "--grep", options, "grep");
+  appendStringFlag(args, "--timeout-ms", options, "timeoutMs");
+  if (parseBooleanOption(options.keepHome)) args.push("--keep-home");
+  return { command, args, cwd: repoRoot };
+}
+async function resolveDesktopHarnessRepoRoot(startCwd) {
+  let current = path.resolve(startCwd);
+  while (true) {
+    const scriptPath = path.join(current, DESKTOP_HARNESS_SCRIPT);
+    if (await fileExists(scriptPath)) return current;
+    const parent = path.dirname(current);
+    if (parent === current) {
+      throw new CliUsageError(
+        `Could not find ${DESKTOP_HARNESS_SCRIPT}. Run this command from the OpenPond source checkout or pass --cwd <repo>.`
+      );
+    }
+    current = parent;
+  }
+}
+function resolveLaunchMode(options, action) {
+  let mode = action === "attach" ? "attach" : null;
+  for (const candidate of ["isolated", "attach", "packaged", "none"]) {
+    if (!parseBooleanOption(options[candidate])) continue;
+    if (mode && mode !== candidate) {
+      throw new CliUsageError("Choose only one desktop harness launch mode: --isolated, --attach, --packaged, or --none.");
+    }
+    mode = candidate;
+  }
+  return mode;
+}
+function appendStringFlag(args, flag, options, key) {
+  const value = optionString(options, key);
+  if (!value) return;
+  args.push(flag, value);
+}
+function appendJsonFlag(args, options) {
+  const json = optionString(options, "json");
+  const jsonPath = optionString(options, "jsonPath");
+  if (json && isBooleanLiteral(json)) {
+    throw new CliUsageError("harness --json requires a report path. Use --json <path> or --json-path <path>.");
+  }
+  if (json && jsonPath && json !== jsonPath) {
+    throw new CliUsageError("Use only one JSON report path: --json <path> or --json-path <path>.");
+  }
+  const value = json || jsonPath;
+  if (value) args.push("--json", value);
+}
+function isBooleanLiteral(value) {
+  return /^(true|false|1|0|yes|no)$/i.test(value);
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath, constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function desktopHarnessCliUsage() {
+  return [
+    "usage: openpond harness desktop run <scenario...> [options]",
+    "       openpond harness desktop attach <scenario...> [options]",
+    "",
+    "Options include --isolated, --attach, --packaged, --none, --app <path>,",
+    "--server <url>, --token <token>, --token-file <path>, --devtools-port <port>, --artifacts-dir <path>,",
+    "--json <path>, --json-path <path>, --grep <pattern>, --timeout-ms <ms>,",
+    "--keep-home, and --cwd <repo>."
+  ].join("\n");
+}
+var HarnessCommandFailedError = class extends Error {
+  exitCode;
+  constructor(code) {
+    const exitCode = typeof code === "number" && code > 0 ? code : 1;
+    super(`desktop harness failed with exit code ${exitCode}`);
+    this.name = "HarnessCommandFailedError";
+    this.exitCode = exitCode;
+  }
+};
+export {
+  buildDesktopHarnessInvocation,
+  resolveDesktopHarnessRepoRoot,
+  runHarnessCommand
+};

package/dist/chunks/help-LMH5FGT2.js

@@ -0,0 +1,65 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  CLI_GLOBAL_OPTION_SCHEMA,
+  formatCliCommandUsage,
+  listCliCommandDefinitions
+} from "./chunk-3Y4EL3P6.js";
+import "./chunk-UACZUFIA.js";
+
+// src/cli/help.ts
+function printHelp() {
+  console.log(formatCliHelp());
+}
+function formatCliHelp() {
+  const lines = [
+    "OpenPond CLI",
+    "",
+    "Usage:",
+    "  openpond <command> [options] [-- passthrough...]",
+    "  openpond --version",
+    "",
+    "Commands:"
+  ];
+  for (const definition of listCliCommandDefinitions()) {
+    const aliases = definition.aliases?.length ? ` (aliases: ${definition.aliases.join(", ")})` : "";
+    lines.push(`  ${definition.usage}${aliases}`);
+    for (const usage of definition.usages ?? []) lines.push(`    ${usage}`);
+  }
+  lines.push("", "Global options:");
+  for (const [name, kind] of Object.entries(CLI_GLOBAL_OPTION_SCHEMA).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    const flag = name.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`);
+    lines.push(kind === "boolean" ? `  --${flag}` : `  --${flag} <${kind}>`);
+  }
+  lines.push(
+    "",
+    "Run `openpond <command> --help` for the selected command schema.",
+    "Arguments after `--` are passed through without option parsing."
+  );
+  return lines.join("\n");
+}
+function formatCliCommandReference() {
+  const sections = listCliCommandDefinitions().map(
+    (definition) => `## ${definition.name}
+
+\`\`\`text
+${formatCliCommandUsage(definition)}
+\`\`\``
+  );
+  return [
+    "# OpenPond CLI command reference",
+    "",
+    "<!-- Generated by `pnpm --dir apps/cli docs:commands`; do not edit by hand. -->",
+    "",
+    "Parsing, aliases, command help, and this reference use the same authoritative registry.",
+    "",
+    ...sections,
+    ""
+  ].join("\n");
+}
+export {
+  formatCliCommandReference,
+  formatCliHelp,
+  printHelp
+};