openpond-code 0.1.0

package/dist/index.js

@@ -0,0 +1,1346 @@
+// 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 startDeviceLogin(baseUrl) {
+  const response = await apiFetch(baseUrl, null, "/api/auth/device/start", {
+    method: "POST",
+    body: JSON.stringify({})
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Device login start failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function pollDeviceLogin(baseUrl, deviceCode, userCode) {
+  const payload = userCode && typeof userCode === "string" ? { userCode } : { deviceCode };
+  const response = await apiFetch(baseUrl, null, "/api/auth/device/poll", {
+    method: "POST",
+    body: JSON.stringify(payload)
+  });
+  if (response.status === 202) {
+    return {};
+  }
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Device login poll failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+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 createLocalProject(baseUrl, token, input) {
+  const response = await apiFetch(baseUrl, token, "/api/projects/local", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Create project failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+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 fetchToolManifest(baseUrl, token) {
+  const response = await apiFetch(baseUrl, token, "/api/tools/manifest", {
+    method: "GET"
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Manifest fetch 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 postAgentDigest(baseUrl, token, body) {
+  const response = await apiFetch(baseUrl, token, "/apps/agent/digest", {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Agent digest 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 commitFiles(baseUrl, token, appId, files, commitMessage) {
+  const response = await apiFetch(baseUrl, token, `/v4/apps/${appId}/commits`, {
+    method: "POST",
+    body: JSON.stringify({ files, message: commitMessage })
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Commit 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/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/indicators.ts
+function computeRsi(values, period = 14) {
+  if (values.length < period + 1)
+    return null;
+  let gains = 0;
+  let losses = 0;
+  for (let i = 1;i <= period; i += 1) {
+    const delta = values[i] - values[i - 1];
+    if (delta >= 0) {
+      gains += delta;
+    } else {
+      losses -= delta;
+    }
+  }
+  let avgGain = gains / period;
+  let avgLoss = losses / period;
+  for (let i = period + 1;i < values.length; i += 1) {
+    const delta = values[i] - values[i - 1];
+    const gain = delta > 0 ? delta : 0;
+    const loss = delta < 0 ? -delta : 0;
+    avgGain = (avgGain * (period - 1) + gain) / period;
+    avgLoss = (avgLoss * (period - 1) + loss) / period;
+  }
+  if (avgLoss === 0)
+    return 100;
+  const rs = avgGain / avgLoss;
+  return 100 - 100 / (1 + rs);
+}
+function computeSmaSeries(values, period) {
+  if (values.length < period)
+    return [];
+  const series = [];
+  let sum = 0;
+  for (let i = 0;i < values.length; i += 1) {
+    sum += values[i];
+    if (i >= period) {
+      sum -= values[i - period];
+    }
+    if (i >= period - 1) {
+      series.push(sum / period);
+    }
+  }
+  return series;
+}
+function computeSma(values, period) {
+  const series = computeSmaSeries(values, period);
+  return series.length > 0 ? series[series.length - 1] : null;
+}
+function computeEmaSeries(values, period) {
+  if (values.length < period)
+    return [];
+  const k = 2 / (period + 1);
+  const start = values.slice(0, period);
+  let ema = start.reduce((sum, value) => sum + value, 0) / period;
+  const series = [ema];
+  for (let i = period;i < values.length; i += 1) {
+    ema = values[i] * k + ema * (1 - k);
+    series.push(ema);
+  }
+  return series;
+}
+function computeEma(values, period) {
+  const series = computeEmaSeries(values, period);
+  return series.length > 0 ? series[series.length - 1] : null;
+}
+function computeMacd(values) {
+  const emaFast = computeEmaSeries(values, 12);
+  const emaSlow = computeEmaSeries(values, 26);
+  if (emaFast.length === 0 || emaSlow.length === 0)
+    return null;
+  const offset = emaFast.length - emaSlow.length;
+  const macdSeries = emaSlow.map((value, idx) => emaFast[idx + offset] - value);
+  const signalSeries = computeEmaSeries(macdSeries, 9);
+  if (signalSeries.length === 0)
+    return null;
+  const macd = macdSeries[macdSeries.length - 1];
+  const signalLine = signalSeries[signalSeries.length - 1];
+  return {
+    macd,
+    signalLine,
+    histogram: macd - signalLine
+  };
+}
+function computeMaCross(values, type, fastPeriod, slowPeriod) {
+  if (values.length < slowPeriod)
+    return null;
+  const fastSeries = type === "ema" ? computeEmaSeries(values, fastPeriod) : computeSmaSeries(values, fastPeriod);
+  const slowSeries = type === "ema" ? computeEmaSeries(values, slowPeriod) : computeSmaSeries(values, slowPeriod);
+  if (fastSeries.length === 0 || slowSeries.length === 0)
+    return null;
+  const offset = fastSeries.length - slowSeries.length;
+  if (offset < 0)
+    return null;
+  const lastIndex = slowSeries.length - 1;
+  const fastNow = fastSeries[lastIndex + offset];
+  const slowNow = slowSeries[lastIndex];
+  const prevIndex = lastIndex - 1;
+  const fastPrev = prevIndex >= 0 ? fastSeries[prevIndex + offset] : null;
+  const slowPrev = prevIndex >= 0 ? slowSeries[prevIndex] : null;
+  let signal = "neutral";
+  if (fastPrev != null && slowPrev != null) {
+    if (fastPrev <= slowPrev && fastNow > slowNow) {
+      signal = "bullish-cross";
+    } else if (fastPrev >= slowPrev && fastNow < slowNow) {
+      signal = "bearish-cross";
+    } else if (fastNow > slowNow) {
+      signal = "bullish";
+    } else if (fastNow < slowNow) {
+      signal = "bearish";
+    }
+  } else if (fastNow > slowNow) {
+    signal = "bullish";
+  } else if (fastNow < slowNow) {
+    signal = "bearish";
+  }
+  return { fast: fastNow, slow: slowNow, signal };
+}
+function computeBollinger(values, period = 20, multiplier = 2) {
+  if (values.length < period)
+    return null;
+  const slice = values.slice(-period);
+  const mean = slice.reduce((sum, value) => sum + value, 0) / period;
+  const variance = slice.reduce((sum, value) => sum + Math.pow(value - mean, 2), 0) / period;
+  const stdDev = Math.sqrt(variance);
+  return {
+    middle: mean,
+    upper: mean + multiplier * stdDev,
+    lower: mean - multiplier * stdDev
+  };
+}
+function computePriceChange(values, lookback = 24) {
+  if (values.length < 2)
+    return null;
+  const current = values[values.length - 1];
+  const index = Math.max(0, values.length - 1 - lookback);
+  const previous = values[index];
+  if (previous === 0)
+    return null;
+  const percent = (current - previous) / previous * 100;
+  return {
+    previous,
+    percent
+  };
+}
+function computeAtr(bars, period = 14) {
+  if (bars.length < period + 1)
+    return null;
+  const ranges = [];
+  for (let i = 1;i < bars.length; i += 1) {
+    const current = bars[i];
+    const prev = bars[i - 1];
+    const rangeHighLow = current.high - current.low;
+    const rangeHighClose = Math.abs(current.high - prev.close);
+    const rangeLowClose = Math.abs(current.low - prev.close);
+    ranges.push(Math.max(rangeHighLow, rangeHighClose, rangeLowClose));
+  }
+  if (ranges.length < period)
+    return null;
+  const slice = ranges.slice(-period);
+  const sum = slice.reduce((total, value) => total + value, 0);
+  return sum / period;
+}
+// src/config.ts
+import {promises as fs2} from "node:fs";
+import os2 from "node:os";
+import path2 from "node:path";
+function getConfigPath() {
+  return getGlobalConfigPath();
+}
+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 saveConfig(next) {
+  const filePath = getGlobalConfigPath();
+  await fs2.mkdir(path2.dirname(filePath), { recursive: true });
+  const payload = JSON.stringify(Object.fromEntries(Object.entries(next).filter(([, value]) => value !== undefined && value !== null)), null, 2);
+  await fs2.writeFile(filePath, payload, "utf-8");
+}
+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/index.ts
+var resolveUrl = function(value) {
+  return value.replace(/\/$/, "");
+};
+var resolveBaseUrl = function(options) {
+  const envBase = process.env.OPENPOND_BASE_URL;
+  const base = options.baseUrl || envBase || DEFAULT_BASE_URL;
+  return resolveUrl(base.trim());
+};
+var resolveApiUrl = function(options) {
+  const envBase = process.env.OPENPOND_API_URL;
+  const base = options.apiUrl || envBase || DEFAULT_API_URL;
+  return resolveUrl(base.trim());
+};
+var resolveToolUrl = function(options, baseUrl) {
+  const envBase = process.env.OPENPOND_TOOL_URL;
+  const base = options.toolUrl || envBase || baseUrl;
+  return resolveUrl(base.trim());
+};
+var resolveApiKey = function(options) {
+  const explicit = options.apiKey?.trim();
+  if (explicit)
+    return explicit;
+  const envKey = process.env.OPENPOND_API_KEY?.trim();
+  if (envKey)
+    return envKey;
+  throw new Error("OPENPOND_API_KEY is required");
+};
+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();
+};
+var normalizeToolSummary = function(tool) {
+  if (!tool || typeof tool !== "object") {
+    return { name: "unknown", raw: tool };
+  }
+  const record = tool;
+  const profile = record.profile || record.function;
+  const name = typeof record.name === "string" ? record.name : typeof profile?.name === "string" ? profile.name : "unknown";
+  const description = typeof record.description === "string" ? record.description : typeof profile?.description === "string" ? profile.description : undefined;
+  return { name, description, raw: tool };
+};
+var extractDeploymentTools = function(detail) {
+  if (!detail)
+    return [];
+  if (Array.isArray(detail.toolsJson)) {
+    return detail.toolsJson;
+  }
+  if (detail.metadataJson && typeof detail.metadataJson === "object") {
+    const metadataTools = detail.metadataJson.tools;
+    if (Array.isArray(metadataTools)) {
+      return metadataTools;
+    }
+  }
+  return [];
+};
+async function resolveAppTarget(params) {
+  const { handle, repo } = parseHandleRepo(params.target);
+  const apps = await fetchAppsWithCache({
+    apiBase: params.apiBase,
+    apiKey: params.apiKey,
+    useCache: params.useCache,
+    cacheTtlMs: params.cacheTtlMs,
+    forceRefresh: params.forceRefresh
+  });
+  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 fetchAppsWithCache(params) {
+  if (params.useCache && !params.forceRefresh) {
+    const cached = await getCachedApps({
+      apiBase: params.apiBase,
+      apiKey: params.apiKey,
+      ttlMs: params.cacheTtlMs
+    });
+    if (cached) {
+      return cached;
+    }
+  }
+  const apps = await listApps(params.apiBase, params.apiKey);
+  if (params.useCache) {
+    await setCachedApps({
+      apiBase: params.apiBase,
+      apiKey: params.apiKey,
+      apps
+    });
+  }
+  return apps;
+}
+async function fetchToolsWithCache(params) {
+  if (params.useCache && !params.forceRefresh) {
+    const cached = await getCachedTools({
+      apiBase: params.apiBase,
+      apiKey: params.apiKey,
+      ttlMs: params.cacheTtlMs
+    });
+    if (cached) {
+      return cached;
+    }
+  }
+  const result = await listUserTools(params.apiBase, params.apiKey);
+  const tools = Array.isArray(result.tools) ? result.tools : [];
+  if (params.useCache) {
+    await setCachedTools({
+      apiBase: params.apiBase,
+      apiKey: params.apiKey,
+      tools
+    });
+  }
+  return tools;
+}
+var normalizeMethod = function(method) {
+  if (!method)
+    return "POST";
+  const upper = method.toUpperCase();
+  switch (upper) {
+    case "GET":
+    case "POST":
+    case "PUT":
+    case "DELETE":
+      return upper;
+    default:
+      throw new Error("method must be GET, POST, PUT, or DELETE");
+  }
+};
+async function consumeAgentCreateStream(response, callbacks) {
+  let conversationId;
+  let appId;
+  let deploymentId;
+  await consumeStream(response, {
+    ...callbacks,
+    onConversationId: (id) => {
+      conversationId = id;
+      callbacks?.onConversationId?.(id);
+    },
+    onItems: (items) => {
+      for (const item of items) {
+        const typed = item;
+        if (!appId && typeof typed.appId === "string") {
+          appId = typed.appId;
+          callbacks?.onAppId?.(typed.appId);
+        }
+        if (!deploymentId && typeof typed.deploymentId === "string") {
+          deploymentId = typed.deploymentId;
+          callbacks?.onDeploymentId?.(typed.deploymentId);
+        }
+      }
+      callbacks?.onItems?.(items);
+    }
+  });
+  return { conversationId, appId, deploymentId };
+}
+function createClient(options) {
+  const apiKey = resolveApiKey(options);
+  const baseUrl = resolveBaseUrl(options);
+  const apiUrl = resolveApiUrl(options);
+  const toolUrl = resolveToolUrl(options, baseUrl);
+  const cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+  const useCache = options.useCache !== false;
+  const refreshCache = async () => {
+    if (!useCache)
+      return;
+    await Promise.all([
+      fetchAppsWithCache({
+        apiBase: apiUrl,
+        apiKey,
+        useCache,
+        cacheTtlMs,
+        forceRefresh: true
+      }),
+      fetchToolsWithCache({
+        apiBase: apiUrl,
+        apiKey,
+        useCache,
+        cacheTtlMs,
+        forceRefresh: true
+      })
+    ]);
+  };
+  const resolveLatestDeploymentId = async (appId, branch) => {
+    const latest = await getLatestDeploymentForApp(apiUrl, apiKey, appId, {
+      branch
+    });
+    return latest?.id ?? null;
+  };
+  return {
+    baseUrl,
+    apiUrl,
+    toolUrl,
+    apiKey,
+    tool: {
+      list: async (target, options2) => {
+        const { app } = await resolveAppTarget({
+          apiBase: apiUrl,
+          apiKey,
+          target,
+          useCache,
+          cacheTtlMs,
+          forceRefresh: options2?.forceRefresh
+        });
+        const deploymentId = options2?.deploymentId || await resolveLatestDeploymentId(app.id, options2?.branch);
+        if (!deploymentId) {
+          return { app, deploymentId: null, tools: [] };
+        }
+        const detail = await getDeploymentDetail(apiUrl, apiKey, deploymentId);
+        const rawTools = extractDeploymentTools(detail);
+        const tools = rawTools.map(normalizeToolSummary);
+        return { app, deploymentId, tools };
+      },
+      run: async (target, toolName, options2) => {
+        const { app } = await resolveAppTarget({
+          apiBase: apiUrl,
+          apiKey,
+          target,
+          useCache,
+          cacheTtlMs,
+          forceRefresh: options2?.forceRefresh
+        });
+        const deploymentId = options2?.deploymentId || await resolveLatestDeploymentId(app.id, options2?.branch);
+        if (!deploymentId) {
+          throw new Error("no deployments found");
+        }
+        const method = normalizeMethod(options2?.method);
+        return executeHostedTool(toolUrl, apiKey, {
+          appId: app.id,
+          deploymentId,
+          toolName,
+          method,
+          body: options2?.body,
+          headers: options2?.headers
+        });
+      }
+    },
+    deploy: {
+      watch: async (target, options2) => {
+        const { app } = await resolveAppTarget({
+          apiBase: apiUrl,
+          apiKey,
+          target,
+          useCache,
+          cacheTtlMs,
+          forceRefresh: options2?.forceRefresh
+        });
+        const deploymentId = options2?.deploymentId || await resolveLatestDeploymentId(app.id, options2?.branch);
+        if (!deploymentId) {
+          throw new Error("no deployments found");
+        }
+        const intervalMs = options2?.intervalMs ?? 5000;
+        const timeoutMs = options2?.timeoutMs ?? 4 * 60 * 1000;
+        const logs = [];
+        const seen = new Set;
+        const startedAt = Date.now();
+        let status = null;
+        while (Date.now() - startedAt < timeoutMs) {
+          const batch = await getDeploymentLogs(apiUrl, apiKey, deploymentId);
+          for (const log of batch) {
+            if (seen.has(log.id))
+              continue;
+            seen.add(log.id);
+            logs.push(log);
+            options2?.onLog?.(log);
+          }
+          const statusResponse = await getDeploymentStatus(apiUrl, apiKey, deploymentId);
+          status = statusResponse.status ?? null;
+          options2?.onStatus?.(status);
+          if (status === "failed") {
+            return { deploymentId, status, logs };
+          }
+          if (status === "running" || status === "deployed") {
+            return { deploymentId, status, logs };
+          }
+          await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+        return { deploymentId, status: "timeout", logs };
+      }
+    },
+    template: {
+      status: async (target, options2) => {
+        const { app } = await resolveAppTarget({
+          apiBase: apiUrl,
+          apiKey,
+          target,
+          useCache,
+          cacheTtlMs,
+          forceRefresh: options2?.forceRefresh
+        });
+        return getTemplateStatus(apiUrl, apiKey, app.id);
+      },
+      branches: async (target, options2) => {
+        const { app } = await resolveAppTarget({
+          apiBase: apiUrl,
+          apiKey,
+          target,
+          useCache,
+          cacheTtlMs,
+          forceRefresh: options2?.forceRefresh
+        });
+        return listTemplateBranches(apiUrl, apiKey, app.id);
+      },
+      update: async (target, options2) => {
+        const { app } = await resolveAppTarget({
+          apiBase: apiUrl,
+          apiKey,
+          target,
+          useCache,
+          cacheTtlMs,
+          forceRefresh: options2?.forceRefresh
+        });
+        const environment = options2?.environment === "preview" ? "preview" : "production";
+        return deployLatestTemplate(apiUrl, apiKey, app.id, { environment });
+      }
+    },
+    apps: {
+      list: async (options2) => {
+        const apps = await fetchAppsWithCache({
+          apiBase: apiUrl,
+          apiKey,
+          useCache,
+          cacheTtlMs,
+          forceRefresh: options2?.forceRefresh
+        });
+        if (!options2?.handle)
+          return apps;
+        return apps.filter((app) => app.handle === options2.handle);
+      },
+      tools: async (options2) => {
+        return fetchToolsWithCache({
+          apiBase: apiUrl,
+          apiKey,
+          useCache,
+          cacheTtlMs,
+          forceRefresh: options2?.forceRefresh
+        });
+      },
+      performance: async (options2) => {
+        return getUserPerformance(apiUrl, apiKey, { appId: options2?.appId });
+      },
+      agentCreate: async (input, callbacks) => {
+        const { refreshCache: refreshCacheFlag, ...rest } = input;
+        const payload = {
+          ...rest,
+          streamDeployLogs: rest.streamDeployLogs ?? true
+        };
+        const response = await createAgentFromPrompt(apiUrl, apiKey, payload);
+        if (!response.ok) {
+          const text = await response.text().catch(() => "");
+          throw new Error(`agent create failed: ${response.status} ${text}`);
+        }
+        const result = await consumeAgentCreateStream(response, callbacks);
+        if (useCache && refreshCacheFlag !== false) {
+          try {
+            await refreshCache();
+          } catch {
+          }
+        }
+        return result;
+      },
+      toolsExecute: async (input) => {
+        return executeUserTool(apiUrl, apiKey, input);
+      },
+      deploy: async (input) => {
+        return deployApp(apiUrl, apiKey, input.appId, {
+          environment: input.environment,
+          commitSha: input.commitSha,
+          branch: input.branch
+        });
+      },
+      envGet: async (input) => {
+        return getAppEnvironment(apiUrl, apiKey, input.appId);
+      },
+      envSet: async (input) => {
+        return updateAppEnvironment(apiUrl, apiKey, input.appId, {
+          envVars: input.envVars
+        });
+      },
+      positionsTx: async (input) => {
+        const method = input?.method ?? "POST";
+        if (method !== "GET" && method !== "POST") {
+          throw new Error("method must be GET or POST");
+        }
+        let query = input?.query;
+        if (!query && input?.params) {
+          query = {};
+          for (const [key, value] of Object.entries(input.params)) {
+            if (value === undefined)
+              continue;
+            query[key] = typeof value === "string" ? value : JSON.stringify(value);
+          }
+        }
+        return submitPositionsTx(apiUrl, apiKey, {
+          method,
+          body: method === "POST" ? input?.body : undefined,
+          query
+        });
+      }
+    },
+    repo: {
+      create: async (input) => {
+        const { refreshCache: refreshCacheFlag, ...rest } = input;
+        const result = await createRepo(apiUrl, apiKey, rest);
+        if (useCache && refreshCacheFlag !== false) {
+          try {
+            await refreshCache();
+          } catch {
+          }
+        }
+        return result;
+      }
+    },
+    cache: {
+      refresh: refreshCache
+    }
+  };
+}
+var DEFAULT_BASE_URL = "https://openpond.ai";
+var DEFAULT_API_URL = "https://api.openpond.ai";
+export {
+  updateAppEnvironment,
+  submitPositionsTx,
+  startDeviceLogin,
+  setCachedTools,
+  setCachedApps,
+  saveGlobalConfig,
+  saveConfig,
+  resolveWorkerBaseUrl,
+  postAgentDigest,
+  pollDeviceLogin,
+  normalizeDataFrames,
+  loadGlobalConfig,
+  loadConfig,
+  listUserTools,
+  listTemplateBranches,
+  listApps,
+  getUserPerformance,
+  getTemplateStatus,
+  getLatestDeploymentForApp,
+  getDeploymentStatus,
+  getDeploymentLogs,
+  getDeploymentDetail,
+  getConfigPath,
+  getCachedTools,
+  getCachedApps,
+  getAppEnvironment,
+  formatStreamItem,
+  fetchToolManifest,
+  executeUserTool,
+  executeHostedTool,
+  deployLatestTemplate,
+  deployApp,
+  createRepo,
+  createLocalProject,
+  createHeadlessApps,
+  createClient,
+  createAgentFromPrompt,
+  consumeStream,
+  consumeAgentCreateStream,
+  computeSmaSeries,
+  computeSma,
+  computeRsi,
+  computePriceChange,
+  computeMacd,
+  computeMaCross,
+  computeEmaSeries,
+  computeEma,
+  computeBollinger,
+  computeAtr,
+  commitFiles,
+  apiFetch,
+  DEFAULT_CACHE_TTL_MS
+};