openpond-code 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# openpond-code
+
+## 0.1.0
+
+- Initial release of the API key CLI.

package/README.md

@@ -0,0 +1,121 @@
+# openpond-code
+
+API-key CLI + local TUI client for OpenPond.
+
+## API key CLI (openpond/op)
+
+Install:
+
+```bash
+npm i -g openpond-code
+# or
+npx --package openpond-code openpond tool list handle/repo
+# or (curl installer)
+curl -fsSL https://openpond.ai/install.sh | bash
+```
+
+Login (stores key in `~/.openpond/config.json`):
+
+```bash
+openpond login
+# or (non-interactive)
+openpond login --api-key opk_...
+```
+
+Commands:
+
+```bash
+openpond tool list <handle>/<repo>
+openpond tool run <handle>/<repo> <tool> --body '{"foo":"bar"}'
+openpond deploy watch <handle>/<repo> --branch main
+openpond template status <handle>/<repo>
+openpond template branches <handle>/<repo>
+openpond template update <handle>/<repo> --env production
+openpond repo create --name my-repo --path .
+openpond repo push --path . --branch main
+openpond apps list [--handle <handle>] [--refresh]
+openpond apps tools
+openpond apps deploy <handle>/<repo> --env production --watch
+openpond apps env get <handle>/<repo>
+openpond apps env set <handle>/<repo> --env '{"OPENTOOL_PUBLIC_HL_SIGNAL_BOT_CONFIG":"..."}'
+openpond apps performance [--app-id <id>]
+openpond apps agent create --prompt "Build a daily digest agent"
+openpond apps tools execute <appId> <deploymentId> <tool> --body '{"foo":"bar"}'
+openpond apps positions tx --method GET --params '{"status":"open"}'
+openpond opentool init --dir .
+```
+
+Command reference:
+
+- `openpond login`: prompt for API key and save to `~/.openpond/config.json`.
+- `openpond login --api-key <key>`: save the API key without prompting.
+- `openpond tool list <handle>/<repo>`: list tools for the latest deployment.
+- `openpond tool run <handle>/<repo> <tool> [--body <json>] [--method <METHOD>]`: run a tool on the latest deployment.
+- `openpond deploy watch <handle>/<repo> [--branch <branch>]`: stream deployment logs for the latest deployment.
+- `openpond template status <handle>/<repo>`: check whether a template update is available.
+- `openpond template branches <handle>/<repo>`: list available template branches.
+- `openpond template update <handle>/<repo> [--env preview|production]`: deploy the latest template commit.
+- `openpond repo create --name <name> [--path <dir>] [--empty|--opentool] [--deploy-on-push]`: create an internal repo and attach the git remote.
+- `openpond repo push [--path <dir>] [--branch <branch>]`: push the current git branch using a tokenized remote (non-interactive, restores origin after push).
+- `openpond apps list [--handle <handle>] [--refresh]`: list apps for your account, optionally filtered by handle.
+- `openpond apps tools`: list tools for your account (public API).
+- `openpond apps deploy <handle>/<repo> [--env preview|production] [--watch]`: trigger a deployment for an app.
+- `openpond apps env get <handle>/<repo>`: get OPENTOOL_PUBLIC_* env vars for an app.
+- `openpond apps env set <handle>/<repo> --env <json>`: set OPENTOOL_PUBLIC_* env vars for an app.
+- `openpond apps performance [--app-id <id>]`: fetch performance summary, optionally scoped to an app.
+- `openpond apps agent create --prompt <text> [--template-id <id>]`: create an agent from a prompt (streams deploy logs by default).
+- `openpond apps tools execute <appId> <deploymentId> <tool> [--body <json>] [--method <METHOD>] [--headers <json>]`: execute a tool for a specific deployment.
+- `openpond apps positions tx [--method <GET|POST>] [--body <json>] [--params <json>]`: read or submit positions.
+- `openpond opentool <init|validate|build> [args]`: run OpenTool CLI commands via `npx opentool`.
+
+## TypeScript package
+
+Programmatic API that mirrors the CLI command surface:
+
+```ts
+import { createClient } from "openpond-code";
+
+const client = createClient({ apiKey: process.env.OPENPOND_API_KEY! });
+
+const { tools } = await client.tool.list("handle/repo");
+const result = await client.tool.run("handle/repo", "myTool", {
+  body: { foo: "bar" },
+});
+
+const apps = await client.apps.list();
+const accountTools = await client.apps.tools();
+const performance = await client.apps.performance({ appId: "app_123" });
+const repo = await client.repo.create({ name: "my-repo", repoInit: "empty" });
+
+await client.apps.agentCreate(
+  { prompt: "Build a daily digest agent" },
+  {
+    onItems: (items) => {
+      for (const item of items) {
+        console.log(item);
+      }
+    },
+  }
+);
+```
+
+You can override hosts with `baseUrl`, `apiUrl`, and `toolUrl` in `createClient`, or
+via `OPENPOND_BASE_URL`, `OPENPOND_API_URL`, and `OPENPOND_TOOL_URL`.
+
+Examples live in `openpond-code/examples`.
+
+## Local TUI
+
+Minimal terminal client for OpenPond chat + history. This is a standalone folder intended
+to be extracted into its own repo later.
+
+## Run
+
+```bash
+bun install
+bun run dev
+```
+
+Cache:
+
+- `~/.openpond/cache.json` caches app/tool lists for 1 hour and refreshes automatically on next use.

package/RELEASE.md

@@ -0,0 +1,24 @@
+# Release Workflow
+
+This package uses [Changesets](https://github.com/changesets/changesets) for version management and publishing to npm.
+
+## Setup required
+
+### 1) npm trusted publisher
+Configure npm trusted publishing for this GitHub repository/workflow.
+
+### 2) GitHub token
+`GITHUB_TOKEN` is provided by GitHub Actions.
+
+## Development workflow
+
+1) Make your changes
+2) Create a changeset:
+   ```bash
+   npm run changeset
+   ```
+3) Commit code + changeset
+4) Open a PR to `master`
+
+When changesets are merged into `master`, the release workflow will open a Version Packages PR.
+Merging that PR publishes to npm and updates `CHANGELOG.md`.

package/dist/api.d.ts

@@ -0,0 +1,247 @@
+import type { ChatRequestBody } from "./types";
+export type DeviceStartResponse = {
+    deviceCode: string;
+    userCode: string;
+    verificationUrl: string;
+    expiresAt: string;
+};
+export type DevicePollResponse = {
+    accessToken?: string;
+};
+export type ToolManifest = {
+    version?: string;
+    tools: Array<{
+        type: "function";
+        function: {
+            name: string;
+            description?: string;
+            parameters?: unknown;
+        };
+    }>;
+};
+export declare function apiFetch(baseUrl: string, token: string | null, path: string, init?: RequestInit): Promise<Response>;
+export declare function startDeviceLogin(baseUrl: string): Promise<DeviceStartResponse>;
+export declare function pollDeviceLogin(baseUrl: string, deviceCode?: string, userCode?: string): Promise<DevicePollResponse>;
+export type CreateLocalProjectInput = {
+    name: string;
+    templateId?: string;
+    templateRepoUrl?: string;
+    templateBranch?: string;
+    envVars?: Record<string, string>;
+};
+export type CreateRepoRequest = {
+    name: string;
+    description?: string;
+    repoInit?: "opentool" | "empty";
+    templateRepoUrl?: string;
+    templateBranch?: string;
+    envVars?: Record<string, string>;
+    deployOnPush?: boolean;
+    autoScheduleMigration?: boolean;
+};
+export type CreateRepoResponse = {
+    appId: string;
+    gitOwner?: string | null;
+    gitRepo?: string | null;
+    gitHost?: string | null;
+    repoUrl?: string | null;
+    defaultBranch?: string;
+};
+export type HeadlessAppRequest = {
+    name?: string;
+    description?: string;
+    templateId?: string;
+    templateRepoUrl?: string;
+    templateBranch?: string;
+    templateName?: string;
+    envVars?: Record<string, string>;
+    visibility?: "private" | "public";
+};
+export type HeadlessAppResponse = {
+    status: "ok" | "error";
+    appId?: string;
+    deploymentId?: string;
+    conversationId?: string;
+    error?: string;
+};
+export type HeadlessAppsResponse = {
+    items: HeadlessAppResponse[];
+};
+export type TemplateStatusResponse = {
+    templateRepoUrl: string;
+    templateBranch: string;
+    remoteSha: string;
+    lastAppliedSha: string | null;
+    updateAvailable: boolean;
+};
+export type TemplateBranchesResponse = {
+    templateRepoUrl: string;
+    templateBranch: string;
+    defaultBranch: string;
+    branches: string[];
+};
+export type TemplateDeployLatestRequest = {
+    environment: "preview" | "production";
+};
+export type TemplateDeployLatestResponse = {
+    deploymentId: string;
+    version: number;
+    templateCommitSha: string;
+};
+export type AppEnvironmentUpdateRequest = {
+    envVars: Record<string, string>;
+};
+export type AppEnvironmentUpdateResponse = {
+    environment: Record<string, string>;
+};
+export type AppEnvironmentGetResponse = {
+    environment: Record<string, string>;
+};
+export type AppListItem = {
+    id: string;
+    name: string;
+    description: string | null;
+    appType: string | null;
+    visibility: "public" | "private";
+    gitOwner: string | null;
+    gitRepo: string | null;
+    gitProvider: string | null;
+    gitHost: string | null;
+    internalToolName: string | null;
+    defaultBranch: string | null;
+    createdAt: string;
+    updatedAt: string;
+    teamId: string | null;
+    teamName: string | null;
+    handle: string | null;
+    repo: string | null;
+    latestDeployment: {
+        id: string;
+        status: string;
+        deploymentDomain: string | null;
+        internalUrl: string | null;
+        createdAt: string;
+        isProduction: boolean | null;
+        gitBranch: string | null;
+    } | null;
+};
+export declare function listApps(apiBase: string, token: string, options?: {
+    handle?: string;
+}): 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 createHeadlessApps(baseUrl: string, token: string, items: HeadlessAppRequest[]): 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 type AgentCreateRequest = {
+    prompt: string;
+    template?: {
+        name?: string;
+        description?: string;
+        templateId?: string;
+        templateRepoUrl?: string;
+        templateBranch?: string;
+        envVars?: Record<string, string>;
+    };
+    deployEnvironment?: "preview" | "production";
+    deployDisabled?: boolean;
+    autoDeployOnFinish?: boolean;
+    streamDeployLogs?: boolean;
+};
+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 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 chatRequest(baseUrl: string, token: string, body: ChatRequestBody): Promise<Response>;
+export declare function commitFiles(baseUrl: string, token: string, appId: string, files: Record<string, string>, commitMessage: string): Promise<{
+    commitSha: string;
+}>;
+export declare function deployApp(baseUrl: string, token: string, appId: string, input?: {
+    environment?: "preview" | "production";
+    commitSha?: string;
+    branch?: string;
+}): Promise<{
+    deploymentId: string;
+    environment?: "preview" | "production";
+    url?: string;
+    version?: number;
+    commitSha?: string;
+}>;
+export type DeploymentLogEntry = {
+    id: string;
+    type?: string;
+    message: string;
+    createdAt: string;
+};
+export declare function getDeploymentLogs(apiBase: string, token: string, deploymentId: string): Promise<DeploymentLogEntry[]>;
+export declare function getDeploymentStatus(apiBase: string, token: string, deploymentId: string): Promise<{
+    status?: string;
+}>;
+export declare function getLatestDeploymentForApp(apiBase: string, token: string, appId: string, options?: {
+    status?: string[];
+    createdAfter?: string;
+    branch?: string;
+}): Promise<{
+    id?: string;
+    status?: string;
+} | null>;
+export type DeploymentDetail = {
+    id: string;
+    appId: string;
+    status: string;
+    createdAt: string;
+    gitBranch: string | null;
+    toolsJson?: unknown;
+    metadataJson?: unknown;
+};
+export declare function getDeploymentDetail(apiBase: string, token: string, deploymentId: string): Promise<DeploymentDetail | null>;
+export type ToolExecuteRequest = {
+    appId: string;
+    deploymentId: string;
+    toolName: string;
+    method?: "GET" | "POST" | "PUT" | "DELETE";
+    body?: unknown;
+    headers?: Record<string, string>;
+};
+export type ToolExecuteResponse = {
+    ok: boolean;
+    status: number;
+    data?: unknown;
+    error?: string;
+};
+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";
+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>;