openpond 0.0.30-bootstrap.0

package/dist/api.d.ts

@@ -0,0 +1,90 @@
+import type { AgentCreateRequest, AppCodeVisibilityUpdateResponse, AppEnvironmentGetResponse, AppEnvironmentUpdateRequest, AppEnvironmentUpdateResponse, AppExecutionTimelineResponse, AppListItem, AppRuntimeSummary, AppSchedulesResponse, AssistantRunRequest, AssistantRunResponse, BacktestRunRequest, CreateLocalProjectInput, CreateRepoRequest, CreateRepoResponse, HeadlessAppRequest, HeadlessAppsResponse, OpenPondAccountBalanceResponse, OpenPondAccountResponse, OpenPondApiHealth, OpenToolRecipe, OpenToolRecipeGetRequest, OpenToolRecipeListRequest, OpenToolRecipeListResponse, OpenToolRecipeSearchRequest, OpenToolRecipeSearchResponse, OpenToolRulesGetRequest, OpenToolRulesGetResponse, ScheduleDeleteResponse, ScheduleExecutionLog, ScheduleExecutionLogsResponse, ScheduleRunNowRequest, ScheduleRunNowResponse, ScheduleToggleRequest, ScheduleToggleResult, TemplateBranchesResponse, TemplateDeployLatestRequest, TemplateDeployLatestResponse, TemplateStatusResponse, ToolExecuteRequest, ToolExecuteResponse, ToolManifest } from "./api/types.js";
+import type { ChatRequestBody } from "./types.js";
+export { apiFetch } from "./api/core.js";
+export { commitFiles, deployApp, getDeploymentDetail, getDeploymentLogs, getDeploymentStatus, getLatestDeploymentForApp, promotePreviewToProduction, startAppLifecycle, } from "./api/deployments.js";
+export type { AgentCreateRequest, AppCodeVisibilityUpdateResponse, AppEnvironmentGetResponse, AppEnvironmentUpdateRequest, AppEnvironmentUpdateResponse, AppExecutionDeployment, AppExecutionTimelineResponse, AppExecutionToolRun, AppListItem, AppRuntimeSummary, AppSchedule, AppSchedulesResponse, AppScheduleSummary, AssistantMode, AssistantRunRequest, AssistantRunResponse, BacktestRunRequest, CreateLocalProjectInput, CreateRepoRequest, CreateRepoResponse, DeploymentDetail, DeploymentLogEntry, HeadlessAppRequest, HeadlessAppResponse, HeadlessAppsResponse, OpenPondAccount, OpenPondAccountBalanceResponse, OpenPondAccountProduct, OpenPondAccountResponse, OpenPondApiHealth, OpenPondApiHealthResponse, OpenToolRecipe, OpenToolRecipeDomain, OpenToolRecipeGetRequest, OpenToolRecipeListRequest, OpenToolRecipeListResponse, OpenToolRecipeSearchRequest, OpenToolRecipeSearchResponse, OpenToolRecipeSummary, OpenToolRulesGetRequest, OpenToolRulesGetResponse, PromotePreviewToProductionRequest, PromotePreviewToProductionResponse, ScheduleDeleteResponse, ScheduleExecutionLog, ScheduleExecutionLogsResponse, ScheduleExecutionStatus, ScheduleRunNowRequest, ScheduleRunNowResponse, ScheduleToggleRequest, ScheduleToggleResult, StartAppLifecycleRequest, StartAppLifecycleResponse, TemplateBranchesResponse, TemplateDeployLatestRequest, TemplateDeployLatestResponse, TemplateStatusResponse, ToolExecuteRequest, ToolExecuteResponse, ToolManifest, } from "./api/types.js";
+export declare function listApps(apiBase: string, token: string, options?: {
+    handle?: string;
+    limit?: number;
+    offset?: number;
+    includeScheduled?: boolean;
+}): Promise<AppListItem[]>;
+export declare function createLocalProject(baseUrl: string, token: string, input: CreateLocalProjectInput): Promise<{
+    appId: string;
+}>;
+export declare function createRepo(apiBase: string, apiKey: string, input: CreateRepoRequest): Promise<CreateRepoResponse>;
+export declare function updateAppCodeVisibility(apiBase: string, apiKey: string, appId: string, codeVisibility: "public" | "private"): Promise<AppCodeVisibilityUpdateResponse>;
+export declare function createHeadlessApps(baseUrl: string, token: string, items: HeadlessAppRequest[], teamId?: string): Promise<HeadlessAppsResponse>;
+export declare function getTemplateStatus(apiBase: string, token: string, appId: string): Promise<TemplateStatusResponse>;
+export declare function listTemplateBranches(apiBase: string, token: string, appId: string): Promise<TemplateBranchesResponse>;
+export declare function deployLatestTemplate(apiBase: string, token: string, appId: string, input: TemplateDeployLatestRequest): Promise<TemplateDeployLatestResponse>;
+export declare function updateAppEnvironment(apiBase: string, token: string, appId: string, input: AppEnvironmentUpdateRequest): Promise<AppEnvironmentUpdateResponse>;
+export declare function getAppEnvironment(apiBase: string, token: string, appId: string): Promise<AppEnvironmentGetResponse>;
+export declare function fetchToolManifest(baseUrl: string, token: string): Promise<ToolManifest>;
+export declare function listUserTools(baseUrl: string, token: string): Promise<{
+    tools?: unknown[];
+}>;
+export declare function listAppSchedules(baseUrl: string, token: string, appId: string): Promise<AppSchedulesResponse>;
+export declare function listOpenToolRecipes(baseUrl: string, token: string, input?: OpenToolRecipeListRequest): Promise<OpenToolRecipeListResponse>;
+export declare function searchOpenToolRecipes(baseUrl: string, token: string, input: OpenToolRecipeSearchRequest): Promise<OpenToolRecipeSearchResponse>;
+export declare function getOpenToolRecipe(baseUrl: string, token: string, input: OpenToolRecipeGetRequest): Promise<OpenToolRecipe>;
+export declare function getOpenToolRules(baseUrl: string, token: string, input: OpenToolRulesGetRequest): Promise<OpenToolRulesGetResponse>;
+export declare function startAppSchedules(baseUrl: string, token: string, appId: string, input?: ScheduleToggleRequest): Promise<ScheduleToggleResult>;
+export declare function stopAppSchedules(baseUrl: string, token: string, appId: string): Promise<ScheduleToggleResult>;
+export declare function stopCurrentAppSchedules(baseUrl: string, token: string): Promise<ScheduleToggleResult>;
+export declare function runScheduleNow(baseUrl: string, token: string, input: ScheduleRunNowRequest): Promise<ScheduleRunNowResponse>;
+export declare function deleteOrArchiveSchedule(baseUrl: string, token: string, appId: string, scheduleId: string): Promise<ScheduleDeleteResponse>;
+export declare function listScheduleExecutionLogs(baseUrl: string, token: string, scheduleId: string, options?: {
+    limit?: number;
+}): Promise<ScheduleExecutionLogsResponse>;
+export declare function listDeploymentScheduleExecutionLogs(baseUrl: string, token: string, deploymentId: string, options?: {
+    limit?: number;
+}): Promise<ScheduleExecutionLogsResponse>;
+export declare function getScheduleExecutionLog(baseUrl: string, token: string, runId: string): Promise<ScheduleExecutionLog>;
+export declare function getAppExecutionTimeline(baseUrl: string, token: string, appId: string, options?: {
+    limit?: number;
+}): Promise<AppExecutionTimelineResponse>;
+export declare function createAgentFromPrompt(baseUrl: string, token: string, payload: AgentCreateRequest): Promise<Response>;
+export declare function getUserPerformance(baseUrl: string, token: string, options?: {
+    appId?: string;
+}): Promise<unknown>;
+export declare function getAppRuntimeSummary(baseUrl: string, token: string, appId: string): Promise<AppRuntimeSummary>;
+export declare function getOpenPondAccount(baseUrl: string, token: string): Promise<OpenPondAccountResponse>;
+export declare function getOpenPondAccountBalance(baseUrl: string, token: string): Promise<OpenPondAccountBalanceResponse>;
+export declare function checkOpenPondApiHealth(baseUrl: string, token?: string | null): Promise<OpenPondApiHealth>;
+export declare function runAssistantMode(baseUrl: string, token: string, payload: AssistantRunRequest): Promise<AssistantRunResponse>;
+export declare function postAgentDigest(baseUrl: string, token: string, body: {
+    content: string;
+    runAt?: string;
+    metadata?: Record<string, unknown>;
+}): Promise<unknown>;
+export declare function executeUserTool(baseUrl: string, token: string, body: {
+    appId: string;
+    deploymentId: string;
+    toolName: string;
+    scheduleId?: string;
+    method?: "GET" | "POST" | "PUT" | "DELETE";
+    body?: unknown;
+    headers?: Record<string, string>;
+    notifyEmail?: boolean;
+}): Promise<{
+    ok: boolean;
+    status: number;
+    data?: unknown;
+    error?: string;
+}>;
+export declare function submitPositionsTx(baseUrl: string, token: string, params: {
+    method: "GET" | "POST";
+    body?: unknown;
+    query?: Record<string, string>;
+}): Promise<unknown>;
+export declare function submitBacktestRun(baseUrl: string, token: string, body: BacktestRunRequest): Promise<unknown>;
+export declare function submitBacktestTx(baseUrl: string, token: string, params: {
+    method: "GET" | "POST";
+    body?: unknown;
+    query?: Record<string, string>;
+}): Promise<unknown>;
+export declare function submitBacktestDetail(baseUrl: string, token: string, query: Record<string, string>): Promise<unknown>;
+export declare function chatRequest(baseUrl: string, token: string, body: ChatRequestBody): Promise<Response>;
+export declare function resolveWorkerBaseUrl(baseUrl: string): string;
+export declare function executeHostedTool(baseUrl: string, token: string, payload: ToolExecuteRequest): Promise<ToolExecuteResponse>;

package/dist/cache.d.ts

@@ -0,0 +1,22 @@
+import type { AppListItem } from "./api.js";
+export declare const DEFAULT_CACHE_TTL_MS: number;
+export declare function getCachedApps(params: {
+    apiBase: string;
+    apiKey: string;
+    ttlMs?: number;
+}): Promise<AppListItem[] | null>;
+export declare function setCachedApps(params: {
+    apiBase: string;
+    apiKey: string;
+    apps: AppListItem[];
+}): Promise<void>;
+export declare function getCachedTools(params: {
+    apiBase: string;
+    apiKey: string;
+    ttlMs?: number;
+}): Promise<unknown[] | null>;
+export declare function setCachedTools(params: {
+    apiBase: string;
+    apiKey: string;
+    tools: unknown[];
+}): Promise<void>;

package/dist/chunks/app-layer-YKXEQGOW.js

@@ -0,0 +1,163 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  runProcessCommand
+} from "./chunk-XSAXENQD.js";
+import {
+  CliUsageError
+} from "./chunk-5G4E547X.js";
+import "./chunk-3Y4EL3P6.js";
+import "./chunk-UACZUFIA.js";
+
+// src/cli/app-layer.ts
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/cli/build-mode.ts
+var IS_COMPILED_CLI = false;
+
+// src/cli/app-layer.ts
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var OpenPondChildProcessExitError = class extends Error {
+  constructor(message, exitCode) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "OpenPondChildProcessExitError";
+  }
+  exitCode;
+};
+async function runOpenPondServerCommand(mode, options, rest) {
+  const server = resolveAppEntrypoint("server");
+  const args = [...server.args, mode, ...forwardedOptions(options), ...rest];
+  const webRoot = mode === "web" && typeof options.webRoot !== "string" ? packagedWebRoot() : null;
+  if (webRoot) args.push("--web-root", webRoot);
+  await runChild(server.runner, args, server.cwd);
+}
+async function runOpenPondTerminalCommand(options, rest) {
+  validateTerminalForwardingOptions(options);
+  const terminal = resolveAppEntrypoint("terminal");
+  const server = resolveAppEntrypoint("server");
+  const args = [...terminal.args, "chat", ...forwardedOptions(normalizeTerminalPaths(options)), ...rest];
+  await runChild(terminal.runner, args, process.cwd(), {
+    OPENPOND_SERVER_RUNNER: server.runner,
+    OPENPOND_SERVER_ARGS: JSON.stringify(server.args),
+    OPENPOND_SERVER_CWD: server.cwd
+  });
+}
+function findWorkspaceRoot() {
+  if (process.env.OPENPOND_FORCE_EMBEDDED_COMPANIONS === "1") return null;
+  const candidates = [
+    path.resolve(__dirname, "../../../.."),
+    path.resolve(__dirname, "../../.."),
+    process.cwd()
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(path.join(candidate, "apps", "server")) && existsSync(path.join(candidate, "apps", "terminal"))) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveAppEntrypoint(app) {
+  const workspaceRoot = findWorkspaceRoot();
+  if (workspaceRoot) {
+    const source = path.join(workspaceRoot, "apps", app, "src", "index.ts");
+    if (existsSync(source)) {
+      const workspaceRequire = createRequire(path.join(workspaceRoot, "package.json"));
+      return {
+        runner: process.execPath,
+        args: [workspaceRequire.resolve("tsx/cli"), source],
+        cwd: workspaceRoot
+      };
+    }
+    const built = path.join(workspaceRoot, "apps", app, "dist", "index.js");
+    if (existsSync(built)) return { runner: process.execPath, args: [built], cwd: workspaceRoot };
+  }
+  const installedCli = installedCliEntrypoint();
+  const embeddedMode = app === "server" ? "__server" : "__terminal";
+  if (installedCli) {
+    return { runner: process.execPath, args: [installedCli, embeddedMode], cwd: path.dirname(path.dirname(installedCli)) };
+  }
+  if (isCompiledExecutable()) return { runner: process.execPath, args: [embeddedMode], cwd: process.cwd() };
+  throw new Error(`Could not find the installed OpenPond ${app} companion.`);
+}
+function installedCliEntrypoint() {
+  for (const candidate of [
+    path.resolve(__dirname, "../cli.js"),
+    path.resolve(__dirname, "../../dist/cli.js")
+  ]) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function packagedWebRoot() {
+  if (IS_COMPILED_CLI) {
+    const candidate2 = path.join(path.dirname(process.execPath), "web");
+    return existsSync(path.join(candidate2, "index.html")) ? candidate2 : null;
+  }
+  const installedCli = installedCliEntrypoint();
+  if (!installedCli) return null;
+  const candidate = path.join(path.dirname(installedCli), "web");
+  return existsSync(path.join(candidate, "index.html")) ? candidate : null;
+}
+function isCompiledExecutable() {
+  if (IS_COMPILED_CLI) return true;
+  const argvEntry = process.argv[1];
+  return Boolean(argvEntry && path.resolve(argvEntry) === path.resolve(process.execPath));
+}
+function forwardedOptions(options) {
+  const ignored = /* @__PURE__ */ new Set(["account", "handle", "baseUrl", "tui"]);
+  const args = [];
+  for (const [key, value] of Object.entries(options)) {
+    if (ignored.has(key)) continue;
+    const flag = `--${key.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`)}`;
+    if (value === true || value === "true") {
+      args.push(flag);
+    } else if (value === false || value === "false") {
+      continue;
+    } else {
+      args.push(flag, value);
+    }
+  }
+  return args;
+}
+function normalizeTerminalPaths(options) {
+  const callerCwd = process.cwd();
+  const next = { ...options };
+  if (typeof options.cwd === "string" && options.cwd.trim().length > 0) {
+    next.cwd = path.resolve(callerCwd, options.cwd);
+  }
+  if (typeof options.messageFile === "string" && options.messageFile.trim().length > 0) {
+    next.messageFile = path.resolve(callerCwd, options.messageFile);
+  }
+  return next;
+}
+function validateTerminalForwardingOptions(options) {
+  if (typeof options.approvalPolicy === "string" && !["on-request", "never", "on-failure", "untrusted"].includes(options.approvalPolicy)) {
+    throw new CliUsageError("approval-policy must be on-request, never, on-failure, or untrusted");
+  }
+  if (typeof options.sandbox === "string" && !["read-only", "workspace-write", "danger-full-access"].includes(options.sandbox)) {
+    throw new CliUsageError("sandbox must be read-only, workspace-write, or danger-full-access");
+  }
+}
+async function runChild(command, args, cwd, env) {
+  const result = await runProcessCommand(command, args, {
+    cwd,
+    // Keep embedded companions in the CLI's process group so an outer package
+    // runner can stop the complete installed CLI tree with one signal.
+    detached: false,
+    env,
+    inherit: true,
+    timeoutMs: 0
+  });
+  if (result.code !== 0 || result.signal) {
+    const detail = result.signal ? `signal ${result.signal}` : `code ${result.code ?? "unknown"}`;
+    throw new OpenPondChildProcessExitError(`${path.basename(command)} exited with ${detail}`, result.code ?? 1);
+  }
+}
+export {
+  OpenPondChildProcessExitError,
+  runOpenPondServerCommand,
+  runOpenPondTerminalCommand
+};