openpond-code 0.1.0

package/dist/cli.js

@@ -0,0 +1,1767 @@
+#!/usr/bin/env node
+
+// src/cli-package.ts
+import {spawn} from "node:child_process";
+import {promises as fs3, existsSync} from "node:fs";
+import path3 from "node:path";
+import {stdin as input, stdout as output} from "node:process";
+import {createInterface} from "node:readline/promises";
+
+// src/api.ts
+async function apiFetch(baseUrl, token, path, init) {
+  const headers = new Headers(init?.headers || {});
+  headers.set("Content-Type", "application/json");
+  const apiKey = process.env.OPENPOND_API_KEY;
+  const trimmedToken = token?.trim() || "";
+  const tokenIsApiKey = trimmedToken.startsWith("opk_");
+  const effectiveApiKey = apiKey || (tokenIsApiKey ? trimmedToken : null);
+  if (effectiveApiKey && !headers.has("openpond-api-key")) {
+    headers.set("openpond-api-key", effectiveApiKey);
+  }
+  if (token) {
+    headers.set("Authorization", tokenIsApiKey ? `ApiKey ${trimmedToken}` : `Bearer ${token}`);
+  } else if (apiKey && !headers.has("Authorization")) {
+    headers.set("Authorization", `ApiKey ${apiKey}`);
+  }
+  return fetch(`${baseUrl}${path}`, {
+    ...init,
+    headers
+  });
+}
+async function listApps(apiBase, token, options) {
+  const params = new URLSearchParams;
+  if (options?.handle) {
+    params.set("handle", options.handle);
+  }
+  const query = params.toString();
+  const response = await apiFetch(apiBase, token, `/apps/list${query ? `?${query}` : ""}`, { method: "GET" });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Apps list failed: ${response.status} ${text}`);
+  }
+  const payload = await response.json().catch(() => ({}));
+  return Array.isArray(payload.apps) ? payload.apps : [];
+}
+async function createRepo(apiBase, apiKey, input) {
+  const response = await apiFetch(apiBase, apiKey, "/apps/repo/create", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Repo create failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function createHeadlessApps(baseUrl, token, items) {
+  const response = await apiFetch(baseUrl, token, "/v4/apps/headless", {
+    method: "POST",
+    body: JSON.stringify({ items })
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Headless create failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function getTemplateStatus(apiBase, token, appId) {
+  const response = await apiFetch(apiBase, token, `/v4/apps/${appId}/template/status`, { method: "GET" });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Template status failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function listTemplateBranches(apiBase, token, appId) {
+  const response = await apiFetch(apiBase, token, `/v4/apps/${appId}/template/branches`, { method: "GET" });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Template branches failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function deployLatestTemplate(apiBase, token, appId, input) {
+  const response = await apiFetch(apiBase, token, `/v4/apps/${appId}/template/deploy-latest`, {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Template deploy failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function updateAppEnvironment(apiBase, token, appId, input) {
+  const response = await apiFetch(apiBase, token, `/v4/apps/${appId}/environment`, {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Environment update failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function getAppEnvironment(apiBase, token, appId) {
+  const response = await apiFetch(apiBase, token, `/v4/apps/${appId}/environment`, {
+    method: "GET"
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Environment get failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function listUserTools(baseUrl, token) {
+  const response = await apiFetch(baseUrl, token, "/apps/tools", {
+    method: "GET"
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Tools lookup failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function createAgentFromPrompt(baseUrl, token, payload) {
+  return apiFetch(baseUrl, token, "/apps/agent/create", {
+    method: "POST",
+    body: JSON.stringify(payload)
+  });
+}
+async function getUserPerformance(baseUrl, token, options) {
+  const params = new URLSearchParams;
+  if (options?.appId) {
+    params.set("appId", options.appId);
+  }
+  const qs = params.toString();
+  const response = await apiFetch(baseUrl, token, `/apps/performance${qs ? `?${qs}` : ""}`, {
+    method: "GET"
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Performance lookup failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function executeUserTool(baseUrl, token, body) {
+  const response = await apiFetch(baseUrl, token, "/apps/tools/execute", {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+  const text = await response.text().catch(() => "");
+  let payload = null;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = text;
+  }
+  if (!response.ok) {
+    return {
+      ok: false,
+      status: response.status,
+      error: payload && typeof payload === "object" && "error" in payload ? String(payload.error) : text || response.statusText
+    };
+  }
+  return {
+    ok: true,
+    status: response.status,
+    data: payload
+  };
+}
+async function submitPositionsTx(baseUrl, token, params) {
+  const qs = params.query && Object.keys(params.query).length > 0 ? `?${new URLSearchParams(params.query).toString()}` : "";
+  const response = await apiFetch(baseUrl, token, `/apps/positions/tx${qs}`, {
+    method: params.method,
+    body: params.method === "POST" && params.body !== undefined ? JSON.stringify(params.body) : undefined
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Positions request failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function deployApp(baseUrl, token, appId, input) {
+  const environment = input?.environment ?? "production";
+  const response = await apiFetch(baseUrl, token, `/v4/apps/${appId}/deployments`, {
+    method: "POST",
+    body: JSON.stringify({
+      environment,
+      ...input?.commitSha ? { commitSha: input.commitSha } : {},
+      ...input?.branch ? { branch: input.branch } : {}
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Deploy failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function getDeploymentLogs(apiBase, token, deploymentId) {
+  const response = await apiFetch(apiBase, token, `/apps/deployments/${deploymentId}/logs`, { method: "GET" });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Deployment logs failed: ${response.status} ${text}`);
+  }
+  const payload = await response.json().catch(() => ({}));
+  const logs = Array.isArray(payload.logs) ? payload.logs : [];
+  return logs.map((log) => {
+    const createdAt = typeof log.createdAt === "string" ? log.createdAt : log.createdAt instanceof Date ? log.createdAt.toISOString() : new Date().toISOString();
+    return {
+      id: typeof log.id === "string" ? log.id : `${Math.random()}`,
+      type: typeof log.type === "string" ? log.type : undefined,
+      message: typeof log.message === "string" ? log.message : "",
+      createdAt
+    };
+  });
+}
+async function getDeploymentStatus(apiBase, token, deploymentId) {
+  const response = await apiFetch(apiBase, token, `/apps/deployments/${deploymentId}/status`, { method: "GET" });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Deployment status failed: ${response.status} ${text}`);
+  }
+  const payload = await response.json().catch(() => ({}));
+  return { status: payload.deployment?.status };
+}
+async function getLatestDeploymentForApp(apiBase, token, appId, options) {
+  const params = new URLSearchParams;
+  if (options?.status && options.status.length > 0) {
+    params.set("status", options.status.join(","));
+  }
+  if (options?.createdAfter) {
+    params.set("createdAfter", options.createdAfter);
+  }
+  if (options?.branch) {
+    params.set("branch", options.branch);
+  }
+  const query = params.toString();
+  const response = await apiFetch(apiBase, token, `/apps/${appId}/deployments/latest${query ? `?${query}` : ""}`, { method: "GET" });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Latest deployment lookup failed: ${response.status} ${text}`);
+  }
+  const payload = await response.json().catch(() => ({}));
+  if (!payload.deployment)
+    return null;
+  return {
+    id: payload.deployment.id,
+    status: payload.deployment.status
+  };
+}
+async function getDeploymentDetail(apiBase, token, deploymentId) {
+  const response = await apiFetch(apiBase, token, `/apps/deployments/${deploymentId}`, { method: "GET" });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Deployment fetch failed: ${response.status} ${text}`);
+  }
+  const payload = await response.json().catch(() => ({}));
+  return payload.deployment ?? null;
+}
+var normalizeToolPathSegment = function(toolName) {
+  const trimmed = toolName.trim().replace(/^\/+/, "");
+  return encodeURIComponent(trimmed || "tool");
+};
+function resolveWorkerBaseUrl(baseUrl) {
+  const trimmed = baseUrl.replace(/\/$/, "");
+  const workerEnv = process.env.OPENPOND_TOOL_URL;
+  if (workerEnv) {
+    return workerEnv.replace(/\/$/, "");
+  }
+  try {
+    const url = new URL(trimmed);
+    const host = url.hostname.toLowerCase();
+    const mappedHost = (() => {
+      if (host === "apps.openpond.live") {
+        return null;
+      }
+      if (host === "api.openpond.ai" || host === "openpond.live" || host === "www.openpond.live") {
+        return "https://apps.openpond.live";
+      }
+      return null;
+    })();
+    if (mappedHost) {
+      return mappedHost;
+    }
+    const isLocal = host === "localhost" || host === "127.0.0.1";
+    const port = url.port || (url.protocol === "https:" ? "443" : "80");
+    if (isLocal && port === "3000") {
+      return trimmed;
+    }
+  } catch {
+  }
+  return trimmed;
+}
+async function executeHostedTool(baseUrl, token, payload) {
+  const workerBase = resolveWorkerBaseUrl(baseUrl);
+  const toolPath = normalizeToolPathSegment(payload.toolName);
+  const deploymentPrefix = payload.deploymentId ? `/${payload.appId}/deployments/${payload.deploymentId}` : `/${payload.appId}`;
+  const requestPath = `${deploymentPrefix}/${toolPath}`;
+  const headers = new Headers(payload.headers || {});
+  const method = payload.method ?? "POST";
+  const body = payload.body === undefined || method === "GET" ? undefined : JSON.stringify(payload.body);
+  const response = await apiFetch(workerBase, token, requestPath, {
+    method,
+    body,
+    headers
+  });
+  const text = await response.text().catch(() => "");
+  let data = null;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+    data = text;
+  }
+  const dataOk = data && typeof data === "object" && "ok" in data ? Boolean(data.ok) : true;
+  const ok = response.ok && dataOk;
+  const status = data && typeof data === "object" && "status" in data ? Number(data.status) || response.status : response.status;
+  const error = data && typeof data === "object" && "error" in data ? String(data.error) : response.ok ? undefined : text || response.statusText;
+  const payloadData = data && typeof data === "object" && "data" in data ? data.data : data;
+  return { ok, status, data: payloadData, error };
+}
+
+// src/cache.ts
+import {promises as fs} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var getCachePath = function() {
+  return path.join(os.homedir(), CACHE_DIR, CACHE_FILENAME);
+};
+var buildCacheKey = function(apiBase, apiKey) {
+  const trimmed = apiKey.trim();
+  const hint = trimmed.length > 12 ? `${trimmed.slice(0, 8)}_${trimmed.slice(-4)}` : trimmed;
+  try {
+    const host = new URL(apiBase).host;
+    return `${host}:${hint}`;
+  } catch {
+    return `${apiBase}:${hint}`;
+  }
+};
+var isFresh = function(updatedAt, ttlMs) {
+  const timestamp = Date.parse(updatedAt);
+  if (Number.isNaN(timestamp)) {
+    return false;
+  }
+  return Date.now() - timestamp < ttlMs;
+};
+async function loadCache() {
+  try {
+    const raw = await fs.readFile(getCachePath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || !parsed.byKey) {
+      return DEFAULT_STORE;
+    }
+    return parsed;
+  } catch {
+    return DEFAULT_STORE;
+  }
+}
+async function saveCache(store) {
+  const filePath = getCachePath();
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify(store, null, 2), "utf-8");
+}
+async function getCachedApps(params) {
+  const ttlMs = params.ttlMs ?? DEFAULT_CACHE_TTL_MS;
+  const store = await loadCache();
+  const cacheKey = buildCacheKey(params.apiBase, params.apiKey);
+  const entry = store.byKey[cacheKey]?.apps;
+  if (!entry || !isFresh(entry.updatedAt, ttlMs)) {
+    return null;
+  }
+  return Array.isArray(entry.items) ? entry.items : null;
+}
+async function setCachedApps(params) {
+  const store = await loadCache();
+  const cacheKey = buildCacheKey(params.apiBase, params.apiKey);
+  const bucket = store.byKey[cacheKey] || {};
+  bucket.apps = {
+    items: params.apps,
+    updatedAt: new Date().toISOString()
+  };
+  store.byKey[cacheKey] = bucket;
+  await saveCache(store);
+}
+async function getCachedTools(params) {
+  const ttlMs = params.ttlMs ?? DEFAULT_CACHE_TTL_MS;
+  const store = await loadCache();
+  const cacheKey = buildCacheKey(params.apiBase, params.apiKey);
+  const entry = store.byKey[cacheKey]?.tools;
+  if (!entry || !isFresh(entry.updatedAt, ttlMs)) {
+    return null;
+  }
+  return Array.isArray(entry.items) ? entry.items : null;
+}
+async function setCachedTools(params) {
+  const store = await loadCache();
+  const cacheKey = buildCacheKey(params.apiBase, params.apiKey);
+  const bucket = store.byKey[cacheKey] || {};
+  bucket.tools = {
+    items: params.tools,
+    updatedAt: new Date().toISOString()
+  };
+  store.byKey[cacheKey] = bucket;
+  await saveCache(store);
+}
+var CACHE_DIR = ".openpond";
+var CACHE_FILENAME = "cache.json";
+var DEFAULT_STORE = { version: 1, byKey: {} };
+var DEFAULT_CACHE_TTL_MS = 60 * 60 * 1000;
+
+// src/config.ts
+import {promises as fs2} from "node:fs";
+import os2 from "node:os";
+import path2 from "node:path";
+var getGlobalConfigPath = function() {
+  return path2.join(os2.homedir(), GLOBAL_DIRNAME, GLOBAL_CONFIG_FILENAME);
+};
+async function loadConfigFile(filePath) {
+  try {
+    const raw = await fs2.readFile(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function loadGlobalConfig() {
+  return loadConfigFile(getGlobalConfigPath());
+}
+async function loadConfig() {
+  return loadGlobalConfig();
+}
+async function saveGlobalConfig(next) {
+  const filePath = getGlobalConfigPath();
+  await fs2.mkdir(path2.dirname(filePath), { recursive: true });
+  const current = await loadGlobalConfig();
+  const merged = { ...current };
+  for (const [key, value] of Object.entries(next)) {
+    if (value === undefined)
+      continue;
+    if (value === null) {
+      delete merged[key];
+    } else {
+      merged[key] = value;
+    }
+  }
+  const payload = JSON.stringify(merged, null, 2);
+  await fs2.writeFile(filePath, payload, "utf-8");
+}
+var GLOBAL_DIRNAME = ".openpond";
+var GLOBAL_CONFIG_FILENAME = "config.json";
+
+// src/stream.ts
+function normalizeDataFrames(raw) {
+  const frames = Array.isArray(raw) ? raw : raw && typeof raw === "object" && Array.isArray(raw.data) ? raw.data : [raw];
+  const items = [];
+  let conversationId;
+  for (const frame of frames) {
+    if (!frame || typeof frame !== "object")
+      continue;
+    const typed = frame;
+    const type = typeof typed.type === "string" ? typed.type : undefined;
+    if (type === "conversation-created") {
+      const cid = typed.conversationId;
+      if (typeof cid === "string") {
+        conversationId = cid;
+      }
+      continue;
+    }
+    if (type === "response_items" && Array.isArray(typed.items)) {
+      items.push(...typed.items);
+      continue;
+    }
+    if (type === "response_item" && typed.item) {
+      items.push(typed.item);
+      continue;
+    }
+    if (type === "assistant-message" && typeof typed.content === "string") {
+      items.push({
+        type: "message",
+        role: "assistant",
+        id: `assistant-${Date.now()}`,
+        content: [{ type: "markdown", text: typed.content }],
+        createdAt: typeof typed.createdAt === "string" ? typed.createdAt : new Date().toISOString()
+      });
+    }
+  }
+  return { conversationId, items };
+}
+var extractUsage = function(raw) {
+  const frames = Array.isArray(raw) ? raw : raw && typeof raw === "object" && Array.isArray(raw.data) ? raw.data : [raw];
+  for (const frame of frames) {
+    if (!frame || typeof frame !== "object")
+      continue;
+    const typed = frame;
+    if (typed.type !== "usage")
+      continue;
+    const usage = typed.usage;
+    if (!usage)
+      continue;
+    const promptTokens = typeof usage.promptTokens === "number" ? usage.promptTokens : typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : undefined;
+    const completionTokens = typeof usage.completionTokens === "number" ? usage.completionTokens : typeof usage.completion_tokens === "number" ? usage.completion_tokens : undefined;
+    const totalTokens = typeof usage.totalTokens === "number" ? usage.totalTokens : typeof usage.total_tokens === "number" ? usage.total_tokens : undefined;
+    return { promptTokens, completionTokens, totalTokens };
+  }
+  return null;
+};
+async function consumeStream(response, callbacks) {
+  if (!response.body) {
+    throw new Error("Missing response body");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  let remainder = "";
+  const shouldStop = callbacks.shouldStop;
+  const stopIfNeeded = async () => {
+    if (!shouldStop || !shouldStop()) {
+      return false;
+    }
+    try {
+      await reader.cancel();
+    } catch {
+    }
+    callbacks.onStop?.();
+    return true;
+  };
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    const chunk = decoder.decode(value, { stream: true });
+    const textChunk = remainder + chunk;
+    const lines = textChunk.split("\n");
+    remainder = lines.pop() || "";
+    for (const line of lines) {
+      if (!line)
+        continue;
+      if (line.startsWith("0:")) {
+        const payload = line.slice(2).trim();
+        if (!payload)
+          continue;
+        const delta = JSON.parse(payload);
+        if (typeof delta === "string") {
+          callbacks.onTextDelta?.(delta);
+        }
+        continue;
+      }
+      if (line.startsWith("g:")) {
+        const payload = line.slice(2).trim();
+        if (!payload)
+          continue;
+        const delta = JSON.parse(payload);
+        if (typeof delta === "string") {
+          callbacks.onReasoningDelta?.(delta);
+        }
+        continue;
+      }
+      if (line.startsWith("d:")) {
+        continue;
+      }
+      if (line.startsWith("3:")) {
+        const payload = line.slice(2).trim();
+        if (!payload)
+          continue;
+        try {
+          const message = JSON.parse(payload);
+          if (typeof message === "string") {
+            throw new Error(message);
+          }
+        } catch {
+        }
+        continue;
+      }
+      if (line.startsWith("2:")) {
+        const payload = line.slice(2).trim();
+        if (!payload)
+          continue;
+        try {
+          const dataItems = JSON.parse(payload);
+          const usage = extractUsage(dataItems);
+          if (usage) {
+            callbacks.onUsage?.(usage);
+          }
+          const { conversationId, items } = normalizeDataFrames(dataItems);
+          if (conversationId) {
+            callbacks.onConversationId?.(conversationId);
+          }
+          if (items.length > 0) {
+            await Promise.resolve(callbacks.onItems?.(items));
+          }
+          if (await stopIfNeeded()) {
+            return;
+          }
+        } catch {
+        }
+      }
+      if (await stopIfNeeded()) {
+        return;
+      }
+    }
+  }
+}
+function formatStreamItem(item) {
+  if (!item || typeof item !== "object")
+    return null;
+  const type = item.type;
+  if (typeof type !== "string")
+    return null;
+  if (type === "app_creation_started") {
+    const name = item.appName || item.name || item.appId || "app";
+    const templateId = typeof item.templateId === "string" ? item.templateId : null;
+    const suffix = templateId ? ` template=${templateId}` : "";
+    return `app_creation_started: ${name}${suffix}`;
+  }
+  if (type === "app_created") {
+    const appId = typeof item.appId === "string" ? item.appId : "unknown";
+    const name = typeof item.appName === "string" ? item.appName : null;
+    return name ? `app_created: ${name} (${appId})` : `app_created: ${appId}`;
+  }
+  if (type.startsWith("tool_creation_")) {
+    const message = item.message || item.content || "";
+    return message ? `${type}: ${message}` : type;
+  }
+  return null;
+}
+
+// src/cli-package.ts
+var parseArgs = function(argv) {
+  const args = [...argv];
+  const command = args.shift() || "";
+  const options = {};
+  const rest = [];
+  while (args.length > 0) {
+    const next = args.shift();
+    if (next.startsWith("--")) {
+      const rawKey = next.slice(2);
+      const key = rawKey.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+      const value = args[0] && !args[0].startsWith("--") ? args.shift() : "true";
+      options[key] = value;
+    } else {
+      rest.push(next);
+    }
+  }
+  return { command, options, rest };
+};
+var resolveBaseUrl = function(config2) {
+  const envBase = process.env.OPENPOND_BASE_URL;
+  const base = envBase || config2.baseUrl || "https://openpond.ai";
+  return base.replace(/\/$/, "");
+};
+var resolvePublicApiBaseUrl = function() {
+  const envBase = process.env.OPENPOND_API_URL;
+  const base = envBase || "https://api.openpond.ai";
+  return base.replace(/\/$/, "");
+};
+var normalizeTemplateRepoUrl = function(input2, baseUrl) {
+  const trimmed = input2.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`;
+};
+var parseJsonOption = function(value, label) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new Error(`${label} must be valid JSON`);
+  }
+};
+var parseBooleanOption = function(value) {
+  if (value === true)
+    return true;
+  if (typeof value === "string") {
+    return value.toLowerCase() === "true";
+  }
+  return false;
+};
+var parseTimeOption = function(value, label) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  if (!trimmed)
+    return;
+  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`);
+};
+var resolveApiKey = function(config2) {
+  const envKey = process.env.OPENPOND_API_KEY?.trim();
+  if (envKey)
+    return envKey;
+  const stored = config2.apiKey?.trim();
+  if (stored)
+    return stored;
+  const legacy = config2.token?.trim();
+  if (legacy && legacy.startsWith("opk_"))
+    return legacy;
+  return null;
+};
+var resolveTemplateEnvironment = function(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");
+};
+async function promptForApiKey() {
+  console.log("Open the OpenPond UI to create an API key:");
+  console.log(UI_API_KEY_URL);
+  const rl = createInterface({ input, output });
+  try {
+    const value = (await rl.question("Paste your OpenPond API key: ")).trim();
+    if (!value) {
+      throw new Error("API key is required");
+    }
+    if (!value.startsWith("opk_")) {
+      console.log("warning: API keys usually start with opk_.");
+    }
+    return value;
+  } finally {
+    rl.close();
+  }
+}
+async function ensureApiKey(config2, baseUrl) {
+  const existing = resolveApiKey(config2);
+  if (existing)
+    return existing;
+  const apiKey = await promptForApiKey();
+  await saveGlobalConfig({ apiKey, baseUrl });
+  console.log("saved api key to ~/.openpond/config.json");
+  return apiKey;
+}
+async function promptConfirm(question, defaultValue = false) {
+  const rl = createInterface({ input, output });
+  try {
+    const suffix = defaultValue ? "[Y/n]" : "[y/N]";
+    const answer = (await rl.question(`${question} ${suffix} `)).trim().toLowerCase();
+    if (!answer)
+      return defaultValue;
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function promptForPath(defaultPath) {
+  const rl = createInterface({ input, output });
+  try {
+    const answer = (await rl.question(`Local path (default: ${defaultPath}): `)).trim();
+    return answer || defaultPath;
+  } finally {
+    rl.close();
+  }
+}
+async function runCommand(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      cwd: options.cwd,
+      stdio: options.inherit ? "inherit" : "pipe"
+    });
+    let stdout = "";
+    let stderr = "";
+    if (!options.inherit) {
+      proc.stdout?.on("data", (chunk) => {
+        stdout += String(chunk);
+      });
+      proc.stderr?.on("data", (chunk) => {
+        stderr += String(chunk);
+      });
+    }
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      resolve({ code, stdout, stderr });
+    });
+  });
+}
+async function getGitRemoteUrl(cwd, remoteName) {
+  const result = await runCommand("git", ["remote", "get-url", remoteName], { cwd });
+  if (result.code !== 0)
+    return null;
+  const url = result.stdout.trim();
+  return url.length > 0 ? url : null;
+}
+var resolveRepoUrl = function(response) {
+  if (response.repoUrl)
+    return response.repoUrl;
+  if (response.gitHost && response.gitOwner && response.gitRepo) {
+    return `https://${response.gitHost}/${response.gitOwner}/${response.gitRepo}.git`;
+  }
+  throw new Error("repoUrl missing from API response");
+};
+var formatTokenizedRepoUrl = function(repoUrl, token) {
+  const url = new URL(repoUrl);
+  const encodedToken = encodeURIComponent(token);
+  return `${url.protocol}//x-access-token:${encodedToken}@${url.host}${url.pathname}`;
+};
+var formatTokenizedRepoUrlForPrint = function(repoUrl) {
+  const url = new URL(repoUrl);
+  return `${url.protocol}//x-access-token:\$OPENPOND_API_KEY@${url.host}${url.pathname}`;
+};
+var redactToken = function(value) {
+  return value.replace(/x-access-token:[^@]+@/g, "x-access-token:***@");
+};
+var warnOnRepoHostMismatch = function(repoUrl) {
+  const envBase = process.env.OPENPOND_BASE_URL;
+  if (!envBase)
+    return;
+  try {
+    const baseHost = new URL(envBase).hostname;
+    const repoHost = new URL(repoUrl).hostname;
+    if (baseHost && repoHost && baseHost !== repoHost) {
+      console.warn(`warning: repo host (${repoHost}) does not match OPENPOND_BASE_URL (${baseHost})`);
+      console.warn("warning: if this is staging, ensure INTERNAL_GIT_HOST is set on the deployment worker.");
+    }
+  } catch {
+  }
+};
+var parseHandleRepo = function(value) {
+  const parts = value.split("/").filter(Boolean);
+  if (parts.length !== 2) {
+    throw new Error("expected <handle>/<repo>");
+  }
+  return { handle: parts[0], repo: parts[1] };
+};
+var normalizeRepoName = function(value) {
+  return (value || "").trim().toLowerCase();
+};
+async function fetchAppsWithCache(params) {
+  if (!params.forceRefresh) {
+    const cached = await getCachedApps({
+      apiBase: params.apiBase,
+      apiKey: params.apiKey,
+      ttlMs: DEFAULT_CACHE_TTL_MS
+    });
+    if (cached) {
+      return cached;
+    }
+  }
+  const apps = await listApps(params.apiBase, params.apiKey);
+  await setCachedApps({
+    apiBase: params.apiBase,
+    apiKey: params.apiKey,
+    apps
+  });
+  return apps;
+}
+async function fetchToolsWithCache(params) {
+  if (!params.forceRefresh) {
+    const cached = await getCachedTools({
+      apiBase: params.apiBase,
+      apiKey: params.apiKey,
+      ttlMs: DEFAULT_CACHE_TTL_MS
+    });
+    if (cached) {
+      return cached;
+    }
+  }
+  const result = await listUserTools(params.apiBase, params.apiKey);
+  const tools = Array.isArray(result.tools) ? result.tools : [];
+  await setCachedTools({
+    apiBase: params.apiBase,
+    apiKey: params.apiKey,
+    tools
+  });
+  return tools;
+}
+async function resolveAppTarget(apiBase, apiKey, target) {
+  const { handle, repo } = parseHandleRepo(target);
+  const apps = await fetchAppsWithCache({ apiBase, apiKey });
+  const normalizedRepo = normalizeRepoName(repo);
+  const match = apps.find((app) => {
+    if (app.handle && app.handle !== handle) {
+      return false;
+    }
+    const candidates = [
+      app.repo,
+      app.gitRepo,
+      app.internalToolName,
+      app.name,
+      app.id
+    ].map(normalizeRepoName);
+    return candidates.includes(normalizedRepo);
+  });
+  if (!match) {
+    throw new Error(`app not found for ${handle}/${repo}`);
+  }
+  return { app: match, handle, repo };
+}
+async function pollDeploymentLogs(params) {
+  const intervalMs = params.intervalMs ?? 5000;
+  const timeoutMs = params.timeoutMs ?? 4 * 60 * 1000;
+  const seen = new Set;
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const logs = await getDeploymentLogs(params.baseUrl, params.apiKey, params.deploymentId);
+    const newLogs = logs.filter((log) => !seen.has(log.id));
+    for (const log of newLogs) {
+      seen.add(log.id);
+    }
+    for (const log of newLogs) {
+      console.log(`${params.prefix}${log.message}`);
+    }
+    const status = await getDeploymentStatus(params.baseUrl, params.apiKey, params.deploymentId);
+    if (status.status === "failed") {
+      console.log(`${params.prefix}deployment failed`);
+      return;
+    }
+    if (status.status === "running" || status.status === "deployed") {
+      console.log(`${params.prefix}deployment complete`);
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  console.log(`${params.prefix}deployment still in progress`);
+}
+async function runTemplateStatus(_options, target) {
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiBase = resolvePublicApiBaseUrl();
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const { app } = await resolveAppTarget(apiBase, apiKey, target);
+  const status = await getTemplateStatus(apiBase, apiKey, app.id);
+  console.log(JSON.stringify(status, null, 2));
+}
+async function runTemplateBranches(_options, target) {
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiBase = resolvePublicApiBaseUrl();
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const { app } = await resolveAppTarget(apiBase, apiKey, target);
+  const branches = await listTemplateBranches(apiBase, apiKey, app.id);
+  console.log(JSON.stringify(branches, null, 2));
+}
+async function runTemplateUpdate(options, target) {
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiBase = resolvePublicApiBaseUrl();
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const { app } = await resolveAppTarget(apiBase, apiKey, target);
+  const envRaw = typeof options.env === "string" ? options.env : typeof options.environment === "string" ? options.environment : undefined;
+  const environment = resolveTemplateEnvironment(envRaw);
+  const result = await deployLatestTemplate(apiBase, apiKey, app.id, {
+    environment
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+var printHelp = function() {
+  console.log("OpenPond CLI (API key only)");
+  console.log("");
+  console.log("Usage:");
+  console.log("  openpond login [--api-key <key>]");
+  console.log("  openpond tool list <handle>/<repo>");
+  console.log("  openpond tool run <handle>/<repo> <tool> [--body <json>] [--method <METHOD>]");
+  console.log("  openpond deploy watch <handle>/<repo> [--branch <branch>]");
+  console.log("  openpond template status <handle>/<repo>");
+  console.log("  openpond template branches <handle>/<repo>");
+  console.log("  openpond template update <handle>/<repo> [--env preview|production]");
+  console.log("  openpond repo create --name <name> [--path <dir>] [--template <owner/repo|url>] [--template-branch <branch>] [--env <json>] [--empty|--opentool] [--token] [--auto-schedule-migration <true|false>]");
+  console.log("  openpond repo push [--path <dir>] [--branch <branch>]");
+  console.log("  openpond apps list [--handle <handle>] [--refresh]");
+  console.log("  openpond apps tools");
+  console.log("  openpond apps deploy <handle>/<repo> [--env preview|production] [--watch]");
+  console.log("  openpond apps env get <handle>/<repo>");
+  console.log("  openpond apps env set <handle>/<repo> --env <json>");
+  console.log("  openpond apps performance [--app-id <id>]");
+  console.log("  openpond apps store events [--source <source>] [--status <csv>] [--symbol <symbol>] [--wallet-address <0x...>] [--since <ms|iso>] [--until <ms|iso>] [--limit <n>] [--cursor <cursor>] [--history <true|false>] [--params <json>]");
+  console.log("  openpond apps trade-facts [--app-id <id>]");
+  console.log("  openpond apps agent create --prompt <text> [--template-id <id>]");
+  console.log("  openpond apps tools execute <appId> <deploymentId> <tool> [--body <json>] [--method <METHOD>] [--headers <json>]");
+  console.log("  openpond apps positions tx [--method <GET|POST>] [--body <json>] [--params <json>]");
+  console.log("  openpond opentool <init|validate|build> [args]");
+  console.log("");
+  console.log("Env:");
+  console.log("  OPENPOND_API_KEY, OPENPOND_BASE_URL, OPENPOND_API_URL, OPENPOND_TOOL_URL");
+};
+async function runLogin(options) {
+  const config2 = await loadConfig();
+  const baseUrl = resolveBaseUrl(config2);
+  const rawApiKey = typeof options.apiKey === "string" ? options.apiKey : typeof options.key === "string" ? options.key : null;
+  const apiKey = rawApiKey ? rawApiKey.trim() : await promptForApiKey();
+  if (!apiKey) {
+    throw new Error("API key is required");
+  }
+  if (!apiKey.startsWith("opk_")) {
+    console.log("warning: API keys usually start with opk_.");
+  }
+  await saveGlobalConfig({ apiKey, baseUrl });
+  console.log("saved api key to ~/.openpond/config.json");
+}
+async function runToolList(options, target) {
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiBase = resolvePublicApiBaseUrl();
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const { app } = await resolveAppTarget(apiBase, apiKey, target);
+  const branch = typeof options.branch === "string" ? String(options.branch) : undefined;
+  const latest = await getLatestDeploymentForApp(apiBase, apiKey, app.id, { branch });
+  if (!latest?.id) {
+    console.log("no deployments found");
+    return;
+  }
+  const detail = await getDeploymentDetail(apiBase, apiKey, latest.id);
+  const toolsRaw = (detail && Array.isArray(detail.toolsJson) ? detail.toolsJson : null) || (detail && typeof detail.metadataJson === "object" && detail.metadataJson ? detail.metadataJson.tools : null);
+  const tools = Array.isArray(toolsRaw) ? toolsRaw : [];
+  if (tools.length === 0) {
+    console.log("no tools found");
+    return;
+  }
+  for (const tool of tools) {
+    const record = tool;
+    const profile = record.profile || record.function;
+    const name = record.name || profile?.name || "unknown";
+    const description = record.description || profile?.description || "";
+    console.log(description ? `${name} - ${description}` : name);
+  }
+}
+async function runToolRun(options, target, toolName) {
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiBase = resolvePublicApiBaseUrl();
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const { app } = await resolveAppTarget(apiBase, apiKey, target);
+  const branch = typeof options.branch === "string" ? String(options.branch) : undefined;
+  const latest = await getLatestDeploymentForApp(apiBase, apiKey, app.id, { branch });
+  if (!latest?.id) {
+    throw new Error("no deployments found");
+  }
+  let body = undefined;
+  if (typeof options.body === "string") {
+    try {
+      body = JSON.parse(options.body);
+    } catch {
+      throw new Error("tool body must be valid JSON");
+    }
+  }
+  const method = typeof options.method === "string" ? String(options.method).toUpperCase() : "POST";
+  const result = await executeHostedTool(uiBase, apiKey, {
+    appId: app.id,
+    deploymentId: latest.id,
+    toolName,
+    method,
+    body,
+    headers: apiKey ? { "openpond-api-key": apiKey } : undefined
+  });
+  if (!result.ok) {
+    throw new Error(result.error || `tool failed (${result.status})`);
+  }
+  const output2 = result.data ?? { ok: true };
+  console.log(JSON.stringify(output2, null, 2));
+}
+async function runDeployWatch(options, target) {
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiBase = resolvePublicApiBaseUrl();
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const { app, handle, repo } = await resolveAppTarget(apiBase, apiKey, target);
+  const branch = typeof options.branch === "string" ? String(options.branch) : undefined;
+  const deploymentId = typeof options.deploymentId === "string" ? String(options.deploymentId) : undefined;
+  const latest = deploymentId ? { id: deploymentId } : await getLatestDeploymentForApp(apiBase, apiKey, app.id, {
+    branch
+  });
+  if (!latest?.id) {
+    console.log("no deployments found");
+    return;
+  }
+  await pollDeploymentLogs({
+    baseUrl: apiBase,
+    apiKey,
+    deploymentId: latest.id,
+    prefix: `[${handle}/${repo}] `,
+    intervalMs: options.interval ? Number(options.interval) : undefined,
+    timeoutMs: options.timeout ? Number(options.timeout) : undefined
+  });
+}
+async function runRepoCreate(options, nameParts) {
+  const name = (typeof options.name === "string" ? options.name : null) || nameParts.join(" ");
+  const trimmedName = name.trim();
+  if (!trimmedName) {
+    throw new Error("usage: repo create --name <name> [--path <dir>] [--template <owner/repo|url>] [--template-branch <branch>] [--empty|--opentool] [--token] [--auto-schedule-migration <true|false>]");
+  }
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const apiBase = resolvePublicApiBaseUrl();
+  const templateInput = typeof options.template === "string" ? options.template.trim() : "";
+  if (templateInput && (options.empty === "true" || options.opentool === "true")) {
+    throw new Error("choose one: --template or --empty/--opentool");
+  }
+  if (options.empty === "true" && options.opentool === "true") {
+    throw new Error("choose one: --empty or --opentool");
+  }
+  const description = typeof options.description === "string" ? options.description.trim() : undefined;
+  const templateBranch = typeof options.templateBranch === "string" && options.templateBranch.trim().length > 0 ? options.templateBranch.trim() : undefined;
+  const envVars = typeof options.env === "string" ? parseJsonOption(options.env, "env") : undefined;
+  if (envVars) {
+    if (typeof envVars !== "object" || Array.isArray(envVars)) {
+      throw new Error("env must be a JSON object");
+    }
+    for (const [key, value] of Object.entries(envVars)) {
+      if (typeof value !== "string") {
+        throw new Error(`env value for ${key} must be a string`);
+      }
+    }
+  }
+  if (templateInput) {
+    if (options.deployOnPush !== undefined) {
+      console.warn("deploy-on-push is not used for template create (auto deploys)");
+    }
+    const templateRepoUrl = normalizeTemplateRepoUrl(templateInput, uiBase);
+    const response2 = await createHeadlessApps(apiBase, apiKey, [
+      {
+        name: trimmedName,
+        ...description ? { description } : {},
+        templateRepoUrl,
+        ...templateBranch ? { templateBranch } : {},
+        ...envVars ? { envVars } : {}
+      }
+    ]);
+    const item = response2.items?.[0];
+    if (!item || item.status !== "ok" || !item.appId) {
+      throw new Error(item?.error || "Template create failed");
+    }
+    console.log(`app_id: ${item.appId}`);
+    if (item.deploymentId) {
+      console.log(`deployment_id: ${item.deploymentId}`);
+    }
+    if (item.conversationId) {
+      console.log(`conversation_id: ${item.conversationId}`);
+    }
+    return;
+  }
+  const defaultPath = process.cwd();
+  const rawPath = typeof options.path === "string" ? options.path : typeof options.dir === "string" ? options.dir : null;
+  const targetPath = rawPath && rawPath.trim().length > 0 ? rawPath.trim() : input.isTTY ? await promptForPath(defaultPath) : defaultPath;
+  const repoPath = path3.resolve(targetPath);
+  if (existsSync(repoPath)) {
+    const stats = await fs3.stat(repoPath);
+    if (!stats.isDirectory()) {
+      throw new Error(`path is not a directory: ${repoPath}`);
+    }
+  } else {
+    await fs3.mkdir(repoPath, { recursive: true });
+  }
+  const entries = await fs3.readdir(repoPath);
+  const nonGitEntries = entries.filter((entry) => entry !== ".git");
+  const isEmpty = nonGitEntries.length === 0;
+  const force = parseBooleanOption(options.yes) || parseBooleanOption(options.force);
+  if (!isEmpty && !force) {
+    const proceed = await promptConfirm(`Directory is not empty (${repoPath}). Continue?`, false);
+    if (!proceed) {
+      console.log("aborted");
+      return;
+    }
+  }
+  const gitDir = path3.join(repoPath, ".git");
+  const hasGit = existsSync(gitDir);
+  if (!hasGit) {
+    const proceed = force ? true : await promptConfirm("Initialize git repository here?", true);
+    if (!proceed) {
+      console.log("aborted");
+      return;
+    }
+    const result = await runCommand("git", ["init"], { cwd: repoPath });
+    if (result.code !== 0) {
+      throw new Error(`git init failed: ${result.stderr.trim() || result.stdout.trim() || "unknown error"}`);
+    }
+  }
+  const originUrl = await getGitRemoteUrl(repoPath, "origin");
+  if (originUrl && !force) {
+    const proceed = await promptConfirm(`Remote "origin" already set (${originUrl}). Replace it?`, false);
+    if (!proceed) {
+      console.log("aborted");
+      return;
+    }
+  }
+  const repoInit = options.opentool === "true" ? "opentool" : "empty";
+  const deployOnPush = parseBooleanOption(options.deployOnPush);
+  const autoScheduleMigrationOption = options.autoScheduleMigration;
+  const autoScheduleMigrationSpecified = typeof autoScheduleMigrationOption === "string" || typeof autoScheduleMigrationOption === "boolean";
+  const autoScheduleMigration = autoScheduleMigrationSpecified ? parseBooleanOption(autoScheduleMigrationOption) : undefined;
+  const response = await createRepo(apiBase, apiKey, {
+    name: trimmedName,
+    ...description ? { description } : {},
+    ...repoInit ? { repoInit } : {},
+    ...envVars ? { envVars } : {},
+    ...deployOnPush ? { deployOnPush: true } : {},
+    ...autoScheduleMigrationSpecified ? { autoScheduleMigration } : {}
+  });
+  const repoUrl = resolveRepoUrl(response);
+  warnOnRepoHostMismatch(repoUrl);
+  const useTokenRemote = parseBooleanOption(options.token) || parseBooleanOption(options.setRemoteToken);
+  const tokenRemote = formatTokenizedRepoUrl(repoUrl, apiKey);
+  const remoteUrl = useTokenRemote ? tokenRemote : repoUrl;
+  const remoteArgs = originUrl ? ["remote", "set-url", "origin", remoteUrl] : ["remote", "add", "origin", remoteUrl];
+  const remoteResult = await runCommand("git", remoteArgs, { cwd: repoPath });
+  if (remoteResult.code !== 0) {
+    throw new Error(`git remote failed: ${redactToken(remoteResult.stderr.trim() || remoteResult.stdout.trim() || "unknown error")}`);
+  }
+  const displayRemote = useTokenRemote ? formatTokenizedRepoUrlForPrint(repoUrl) : repoUrl;
+  console.log(`app_id: ${response.appId}`);
+  if (response.gitOwner && response.gitRepo) {
+    console.log(`repo: ${response.gitOwner}/${response.gitRepo}`);
+  }
+  console.log(`remote: ${displayRemote}`);
+  console.log("next: git add . && git commit -m \"init\"");
+  const defaultBranch = response.defaultBranch || "master";
+  console.log(`next: openpond repo push --path ${repoPath} --branch ${defaultBranch}`);
+  if (!useTokenRemote) {
+    console.log(`token-remote (non-interactive): git -C ${repoPath} remote set-url origin ${formatTokenizedRepoUrlForPrint(repoUrl)}`);
+  }
+  try {
+    await fetchAppsWithCache({ apiBase, apiKey, forceRefresh: true });
+  } catch (error) {
+    console.warn("cache refresh failed", error);
+  }
+}
+async function resolveGitBranch(repoPath) {
+  const result = await runCommand("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+    cwd: repoPath
+  });
+  if (result.code !== 0)
+    return null;
+  const branch = result.stdout.trim();
+  return branch.length > 0 ? branch : null;
+}
+async function runRepoPush(options) {
+  const config2 = await loadConfig();
+  const baseUrl = resolveBaseUrl(config2);
+  const apiKey = await ensureApiKey(config2, baseUrl);
+  const rawPath = typeof options.path === "string" ? options.path : typeof options.dir === "string" ? options.dir : null;
+  const repoPath = path3.resolve(rawPath && rawPath.trim().length > 0 ? rawPath.trim() : ".");
+  const gitDir = path3.join(repoPath, ".git");
+  if (!existsSync(gitDir)) {
+    throw new Error(`git repo not found at ${repoPath} (missing .git)`);
+  }
+  const originUrl = await getGitRemoteUrl(repoPath, "origin");
+  if (!originUrl) {
+    throw new Error("origin remote not set; run `openpond repo create` first");
+  }
+  warnOnRepoHostMismatch(originUrl);
+  const branchOption = typeof options.branch === "string" ? options.branch.trim() : "";
+  const resolvedBranch = branchOption || await resolveGitBranch(repoPath);
+  if (!resolvedBranch) {
+    throw new Error("unable to resolve git branch; pass --branch");
+  }
+  let tokenRemote;
+  try {
+    tokenRemote = formatTokenizedRepoUrl(originUrl, apiKey);
+  } catch {
+    throw new Error("origin remote must be https for tokenized pushes");
+  }
+  const keepTokenRemote = parseBooleanOption(options.keepTokenRemote) || parseBooleanOption(options.token) || parseBooleanOption(options.setRemoteToken);
+  const alreadyTokenized = originUrl.includes("x-access-token:");
+  const restoreUrl = !keepTokenRemote && !alreadyTokenized ? originUrl : null;
+  const previousPrompt = process.env.GIT_TERMINAL_PROMPT;
+  process.env.GIT_TERMINAL_PROMPT = "0";
+  try {
+    if (!alreadyTokenized) {
+      const setResult = await runCommand("git", ["remote", "set-url", "origin", tokenRemote], { cwd: repoPath });
+      if (setResult.code !== 0) {
+        throw new Error(`git remote set-url failed: ${redactToken(setResult.stderr.trim() || setResult.stdout.trim() || "unknown error")}`);
+      }
+    }
+    const pushResult = await runCommand("git", ["push", "-u", "origin", resolvedBranch], { cwd: repoPath, inherit: true });
+    if (pushResult.code !== 0) {
+      throw new Error("git push failed");
+    }
+  } finally {
+    if (restoreUrl) {
+      await runCommand("git", ["remote", "set-url", "origin", restoreUrl], {
+        cwd: repoPath
+      }).catch(() => null);
+    }
+    if (previousPrompt === undefined) {
+      delete process.env.GIT_TERMINAL_PROMPT;
+    } else {
+      process.env.GIT_TERMINAL_PROMPT = previousPrompt;
+    }
+  }
+}
+async function runOpentool(rawArgs) {
+  if (rawArgs.length === 0) {
+    throw new Error("usage: opentool <init|validate|build> [args]");
+  }
+  const command = process.platform === "win32" ? "npx.cmd" : "npx";
+  const result = await runCommand(command, ["opentool", ...rawArgs], {
+    inherit: true
+  });
+  if (result.code !== 0) {
+    throw new Error("opentool command failed");
+  }
+}
+async function runAppsTools() {
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const apiBase = resolvePublicApiBaseUrl();
+  const tools = await fetchToolsWithCache({ apiBase, apiKey });
+  console.log(JSON.stringify(tools, null, 2));
+}
+async function runAppsList(options) {
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiBase = resolvePublicApiBaseUrl();
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const handle = typeof options.handle === "string" ? String(options.handle) : undefined;
+  const normalizedHandle = handle ? normalizeRepoName(handle) : null;
+  const forceRefresh = options.refresh !== undefined ? parseBooleanOption(options.refresh) : undefined;
+  const apps = await fetchAppsWithCache({
+    apiBase,
+    apiKey,
+    forceRefresh
+  });
+  const filtered = normalizedHandle ? apps.filter((app) => {
+    const candidate = normalizeRepoName(app.handle || app.gitOwner);
+    return candidate === normalizedHandle;
+  }) : apps;
+  if (filtered.length === 0) {
+    console.log("no apps found");
+    return;
+  }
+  for (const app of filtered) {
+    const owner = app.handle || app.gitOwner || "unknown";
+    const repo = app.repo || app.gitRepo || app.name || app.id;
+    const status = app.latestDeployment?.status || "no-deploy";
+    const branch = app.latestDeployment?.gitBranch || app.defaultBranch || "-";
+    console.log(`${owner}/${repo}  ${status}  ${branch}  ${app.id}`);
+  }
+}
+async function runAppsPerformance(options) {
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const apiBase = resolvePublicApiBaseUrl();
+  const appId = typeof options.appId === "string" ? String(options.appId) : undefined;
+  const performance = await getUserPerformance(apiBase, apiKey, { appId });
+  console.log(JSON.stringify(performance, null, 2));
+}
+async function runAppsAgentCreate(options, contentParts) {
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const apiBase = resolvePublicApiBaseUrl();
+  const prompt = (typeof options.prompt === "string" ? options.prompt : null) || contentParts.join(" ");
+  if (!prompt.trim()) {
+    throw new Error("usage: apps agent create --prompt <text>");
+  }
+  const templateId = typeof options.templateId === "string" ? options.templateId : undefined;
+  const templateRepoUrl = typeof options.templateRepoUrl === "string" ? options.templateRepoUrl : undefined;
+  const templateBranch = typeof options.templateBranch === "string" ? options.templateBranch : undefined;
+  const templateLocalPath = typeof options.templateLocalPath === "string" ? options.templateLocalPath : undefined;
+  if (templateLocalPath && String(templateLocalPath).trim().length > 0) {
+    throw new Error("templateLocalPath is not supported; use templateId or templateRepoUrl");
+  }
+  const envVars = typeof options.env === "string" ? parseJsonOption(options.env, "env") : undefined;
+  if (envVars) {
+    if (typeof envVars !== "object" || Array.isArray(envVars)) {
+      throw new Error("env must be a JSON object");
+    }
+    for (const [key, value] of Object.entries(envVars)) {
+      if (typeof value !== "string") {
+        throw new Error(`env value for ${key} must be a string`);
+      }
+    }
+  }
+  const template = templateId || templateRepoUrl || templateBranch || envVars ? {
+    templateId,
+    templateRepoUrl,
+    templateBranch,
+    envVars
+  } : undefined;
+  const deployEnvironment = typeof options.deployEnvironment === "string" ? options.deployEnvironment === "preview" ? "preview" : "production" : undefined;
+  const deployDisabled = options.deployDisabled !== undefined ? parseBooleanOption(options.deployDisabled) : undefined;
+  const streamDeployLogs = options.streamDeployLogs !== undefined ? parseBooleanOption(options.streamDeployLogs) : true;
+  const response = await createAgentFromPrompt(apiBase, apiKey, {
+    prompt: prompt.trim(),
+    ...template ? { template } : {},
+    ...deployEnvironment ? { deployEnvironment } : {},
+    ...deployDisabled !== undefined ? { deployDisabled } : {},
+    streamDeployLogs
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`agent create failed: ${response.status} ${text}`);
+  }
+  let conversationId = null;
+  let appId = null;
+  let deploymentId = null;
+  await consumeStream(response, {
+    onConversationId: (id) => {
+      conversationId = id;
+    },
+    onItems: (items) => {
+      for (const item of items) {
+        const line = formatStreamItem(item);
+        if (line) {
+          console.log(line);
+        }
+        const typed = item;
+        if (!appId && typeof typed.appId === "string") {
+          appId = typed.appId;
+        }
+        if (!deploymentId && typeof typed.deploymentId === "string") {
+          deploymentId = typed.deploymentId;
+        }
+      }
+    }
+  });
+  if (conversationId) {
+    console.log(`conversation_id: ${conversationId}`);
+  }
+  if (appId) {
+    console.log(`app_id: ${appId}`);
+  }
+  if (deploymentId) {
+    console.log(`deployment_id: ${deploymentId}`);
+  }
+  try {
+    await fetchAppsWithCache({ apiBase, apiKey, forceRefresh: true });
+    await fetchToolsWithCache({ apiBase, apiKey, forceRefresh: true });
+  } catch (error) {
+    console.warn("cache refresh failed", error);
+  }
+}
+async function runAppsToolsExecute(options, appId, deploymentId, toolName) {
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const apiBase = resolvePublicApiBaseUrl();
+  const methodRaw = typeof options.method === "string" ? String(options.method).toUpperCase() : undefined;
+  const method = methodRaw && ["GET", "POST", "PUT", "DELETE"].includes(methodRaw) ? methodRaw : undefined;
+  if (methodRaw && !method) {
+    throw new Error("method must be GET, POST, PUT, or DELETE");
+  }
+  const body = typeof options.body === "string" ? parseJsonOption(String(options.body), "body") : undefined;
+  const headers = typeof options.headers === "string" ? parseJsonOption(String(options.headers), "headers") : undefined;
+  const scheduleId = typeof options.scheduleId === "string" ? String(options.scheduleId) : undefined;
+  const notifyEmail = parseBooleanOption(options.notifyEmail);
+  const result = await executeUserTool(apiBase, apiKey, {
+    appId,
+    deploymentId,
+    toolName,
+    scheduleId,
+    method,
+    body,
+    headers,
+    notifyEmail: notifyEmail || undefined
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+async function runAppsEnvSet(options, target) {
+  const rawEnv = typeof options.env === "string" ? options.env : typeof options.vars === "string" ? options.vars : typeof options.envVars === "string" ? options.envVars : null;
+  if (!rawEnv) {
+    throw new Error("usage: apps env set <handle>/<repo> --env <json>");
+  }
+  const parsed = parseJsonOption(rawEnv, "env");
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("env must be a JSON object");
+  }
+  const envVars = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (typeof value !== "string") {
+      throw new Error(`env value for ${key} must be a string`);
+    }
+    if (!key.startsWith("OPENTOOL_PUBLIC_")) {
+      throw new Error("only OPENTOOL_PUBLIC_ env vars can be set");
+    }
+    envVars[key] = value;
+  }
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiBase = resolvePublicApiBaseUrl();
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const { app } = await resolveAppTarget(apiBase, apiKey, target);
+  const result = await updateAppEnvironment(apiBase, apiKey, app.id, { envVars });
+  console.log(JSON.stringify(result, null, 2));
+}
+async function runAppsEnvGet(_options, target) {
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiBase = resolvePublicApiBaseUrl();
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const { app } = await resolveAppTarget(apiBase, apiKey, target);
+  const result = await getAppEnvironment(apiBase, apiKey, app.id);
+  console.log(JSON.stringify(result, null, 2));
+}
+async function runAppsDeploy(options, target) {
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiBase = resolvePublicApiBaseUrl();
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const { app, handle, repo } = await resolveAppTarget(apiBase, apiKey, target);
+  const envRaw = typeof options.env === "string" ? options.env : typeof options.environment === "string" ? options.environment : undefined;
+  const environment = resolveTemplateEnvironment(envRaw);
+  const result = await deployApp(apiBase, apiKey, app.id, { environment });
+  console.log(JSON.stringify(result, null, 2));
+  const shouldWatch = parseBooleanOption(options.watch) || parseBooleanOption(options.wait) || parseBooleanOption(options.follow);
+  if (!shouldWatch)
+    return;
+  await pollDeploymentLogs({
+    baseUrl: apiBase,
+    apiKey,
+    deploymentId: result.deploymentId,
+    prefix: `[${handle}/${repo}] `,
+    intervalMs: options.interval ? Number(options.interval) : undefined,
+    timeoutMs: options.timeout ? Number(options.timeout) : undefined
+  });
+}
+async function runAppsPositionsTx(options) {
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const apiBase = resolvePublicApiBaseUrl();
+  const methodRaw = typeof options.method === "string" ? String(options.method).toUpperCase() : "POST";
+  const method = methodRaw === "GET" ? "GET" : "POST";
+  if (methodRaw !== "GET" && methodRaw !== "POST") {
+    throw new Error("method must be GET or POST");
+  }
+  let query;
+  if (method === "GET" && typeof options.params === "string") {
+    const parsed = parseJsonOption(String(options.params), "params");
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("params must be a JSON object");
+    }
+    query = {};
+    for (const [key, value] of Object.entries(parsed)) {
+      if (value === undefined)
+        continue;
+      query[key] = typeof value === "string" ? value : JSON.stringify(value);
+    }
+  }
+  const body = method === "POST" && typeof options.body === "string" ? parseJsonOption(String(options.body), "body") : undefined;
+  const result = await submitPositionsTx(apiBase, apiKey, {
+    method,
+    body,
+    query
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+var resolveStoreEventsParams = function(options) {
+  let params = {};
+  if (typeof options.params === "string") {
+    const parsed = parseJsonOption(String(options.params), "params");
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("params must be a JSON object");
+    }
+    for (const [key, value] of Object.entries(parsed)) {
+      if (value === undefined)
+        continue;
+      params[key] = typeof value === "string" ? value : JSON.stringify(value);
+    }
+  }
+  const addParam = (key, value) => {
+    if (value === undefined || value === "")
+      return;
+    params[key] = value;
+  };
+  addParam("source", typeof options.source === "string" ? options.source.trim() : undefined);
+  addParam("walletAddress", typeof options.walletAddress === "string" ? options.walletAddress.trim() : undefined);
+  addParam("symbol", typeof options.symbol === "string" ? options.symbol.trim() : undefined);
+  addParam("cursor", typeof options.cursor === "string" ? options.cursor.trim() : undefined);
+  addParam("status", typeof options.status === "string" ? options.status.trim() : undefined);
+  addParam("since", parseTimeOption(options.since, "since"));
+  addParam("until", parseTimeOption(options.until, "until"));
+  if (typeof options.limit === "string" && options.limit.trim().length > 0) {
+    const parsed = Number.parseInt(options.limit, 10);
+    if (!Number.isFinite(parsed)) {
+      throw new Error("limit must be a number");
+    }
+    addParam("limit", String(parsed));
+  }
+  if (options.history !== undefined) {
+    addParam("history", parseBooleanOption(options.history) ? "true" : "false");
+  }
+  return Object.keys(params).length ? params : undefined;
+};
+async function runAppsStoreEvents(options) {
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const apiBase = resolvePublicApiBaseUrl();
+  const query = resolveStoreEventsParams(options);
+  const result = await submitPositionsTx(apiBase, apiKey, {
+    method: "GET",
+    query
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+async function runAppsTradeFacts(options) {
+  const config2 = await loadConfig();
+  const uiBase = resolveBaseUrl(config2);
+  const apiKey = await ensureApiKey(config2, uiBase);
+  const apiBase = resolvePublicApiBaseUrl();
+  const appId = typeof options.appId === "string" ? options.appId : undefined;
+  const performance = await getUserPerformance(apiBase, apiKey, { appId });
+  if (performance && typeof performance === "object" && "trades" in performance && Array.isArray(performance.trades)) {
+    console.log(JSON.stringify(performance.trades, null, 2));
+    return;
+  }
+  console.log(JSON.stringify(performance, null, 2));
+}
+async function main() {
+  const { command, options, rest } = parseArgs(process.argv.slice(2));
+  if (!command || command === "help") {
+    printHelp();
+    return;
+  }
+  if (command === "login") {
+    await runLogin(options);
+    return;
+  }
+  if (command === "tool") {
+    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]");
+  }
+  if (command === "deploy") {
+    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);
+    return;
+  }
+  if (command === "template") {
+    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]");
+  }
+  if (command === "repo") {
+    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>]");
+  }
+  if (command === "apps") {
+    const subcommand = rest[0];
+    if (subcommand === "list") {
+      await runAppsList(options);
+      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 === "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|tools|deploy|env get|env set|performance|store events|trade-facts|agent create|positions tx> [args]");
+  }
+  if (command === "opentool") {
+    await runOpentool(process.argv.slice(3));
+    return;
+  }
+  printHelp();
+  process.exit(1);
+}
+var UI_API_KEY_URL = "https://openpond.ai/settings/api-keys";
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
+  process.exit(1);
+});