feat: move api cli commands under api subcommand

examples/daytona/daytona.ts

@@ -1,76 +0,0 @@
-import { Daytona } from "@daytonaio/sdk";
-import { pathToFileURL, fileURLToPath } from "node:url";
-import { dirname, resolve } from "node:path";
-import {
-  ensureUrl,
-  logInspectorUrl,
-  runPrompt,
-  waitForHealth,
-} from "@sandbox-agent/example-shared";
-
-const DEFAULT_PORT = 3000;
-const BINARY_PATH = resolve(dirname(fileURLToPath(import.meta.url)), "../../target/release/sandbox-agent");
-
-export async function setupDaytonaSandboxAgent(): Promise<{
-  baseUrl: string;
-  token: string;
-  extraHeaders: Record<string, string>;
-  cleanup: () => Promise<void>;
-}> {
-  const token = process.env.SANDBOX_TOKEN || "";
-  const port = Number.parseInt(process.env.SANDBOX_PORT || "", 10) || DEFAULT_PORT;
-  const language = process.env.DAYTONA_LANGUAGE || "typescript";
-
-  const daytona = new Daytona();
-  console.log("Creating sandbox...");
-  const sandbox = await daytona.create({ language });
-
-  // Daytona sandboxes can't reach releases.rivet.dev, so upload binary directly
-  console.log("Uploading sandbox-agent...");
-  await sandbox.fs.uploadFile(BINARY_PATH, "/home/daytona/sandbox-agent");
-  await sandbox.process.executeCommand("chmod +x /home/daytona/sandbox-agent");
-
-  console.log("Starting server...");
-  const tokenFlag = token ? `--token ${token}` : "--no-token";
-  await sandbox.process.executeCommand(
-    `nohup /home/daytona/sandbox-agent server ${tokenFlag} --host 0.0.0.0 --port ${port} >/tmp/sandbox-agent.log 2>&1 &`
-  );
-
-  const preview = await sandbox.getPreviewLink(port);
-  const extraHeaders: Record<string, string> = {
-    "x-daytona-skip-preview-warning": "true",
-  };
-  if (preview.token) {
-    extraHeaders["x-daytona-preview-token"] = preview.token;
-  }
-
-  const baseUrl = ensureUrl(preview.url);
-  console.log("Waiting for health...");
-  await waitForHealth({ baseUrl, token, extraHeaders });
-  logInspectorUrl({ baseUrl, token });
-
-  return {
-    baseUrl,
-    token,
-    extraHeaders,
-    cleanup: async () => {
-      try { await sandbox.delete(60); } catch {}
-    },
-  };
-}
-
-async function main(): Promise<void> {
-  const { baseUrl, token, extraHeaders, cleanup } = await setupDaytonaSandboxAgent();
-
-  process.on("SIGINT", () => void cleanup().then(() => process.exit(0)));
-  process.on("SIGTERM", () => void cleanup().then(() => process.exit(0)));
-
-  await runPrompt({ baseUrl, token, extraHeaders });
-}
-
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
-  main().catch((error) => {
-    console.error(error);
-    process.exit(1);
-  });
-}

examples/daytona/package.json

@@ -3,7 +3,7 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "start": "tsx daytona.ts"
+    "start": "tsx src/daytona.ts"
   },
   "dependencies": {
     "@daytonaio/sdk": "latest",

examples/daytona/src/daytona.ts

@@ -0,0 +1,65 @@
+import { Daytona, Image } from "@daytonaio/sdk";
+import { logInspectorUrl, runPrompt } from "@sandbox-agent/example-shared";
+
+if (
+	!process.env.DAYTONA_API_KEY ||
+	(!process.env.OPENAI_API_KEY && !process.env.ANTHROPIC_API_KEY)
+) {
+	throw new Error(
+		"DAYTONA_API_KEY and (OPENAI_API_KEY or ANTHROPIC_API_KEY) required",
+	);
+}
+
+const SNAPSHOT = "sandbox-agent-ready";
+const BINARY = "/usr/local/bin/sandbox-agent";
+
+const daytona = new Daytona();
+
+const hasSnapshot = await daytona.snapshot.get(SNAPSHOT).then(
+	() => true,
+	() => false,
+);
+if (!hasSnapshot) {
+	console.log(`Creating snapshot '${SNAPSHOT}' (one-time setup, ~1-2min)...`);
+	await daytona.snapshot.create(
+		{
+			name: SNAPSHOT,
+			image: Image.base("ubuntu:22.04").runCommands(
+				"apt-get update && apt-get install -y curl ca-certificates",
+				`curl -fsSL -o ${BINARY} https://releases.rivet.dev/sandbox-agent/latest/binaries/sandbox-agent-x86_64-unknown-linux-musl`,
+				`chmod +x ${BINARY}`,
+			),
+		},
+		{ onLogs: (log) => console.log(`  ${log}`) },
+	);
+	console.log("Snapshot created. Future runs will be instant.");
+}
+
+console.log("Creating sandbox...");
+const sandbox = await daytona.create({
+	snapshot: SNAPSHOT,
+	envVars: {
+		ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
+		OPENAI_API_KEY: process.env.OPENAI_API_KEY,
+	},
+	autoStopInterval: 0,
+});
+
+console.log("Starting server...");
+await sandbox.process.executeCommand(
+	`nohup ${BINARY} server --no-token --host 0.0.0.0 --port 3000 >/tmp/sandbox-agent.log 2>&1 &`,
+);
+
+const baseUrl = (await sandbox.getSignedPreviewUrl(3000, 4 * 60 * 60)).url;
+logInspectorUrl({ baseUrl });
+
+const cleanup = async () => {
+	console.log("Cleaning up...");
+	await sandbox.delete(60);
+	process.exit(0);
+};
+process.once("SIGINT", cleanup);
+process.once("SIGTERM", cleanup);
+
+await runPrompt({ baseUrl });
+await cleanup();

examples/docker/package.json

@@ -3,7 +3,7 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "start": "tsx docker.ts"
+    "start": "tsx src/docker.ts"
   },
   "dependencies": {
     "dockerode": "latest",

examples/e2b/package.json

@@ -3,7 +3,7 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "start": "tsx e2b.ts"
+    "start": "tsx src/e2b.ts"
   },
   "dependencies": {
     "@e2b/code-interpreter": "latest",

examples/shared/package.json

@@ -3,6 +3,6 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./sandbox-agent-client.ts"
+    ".": "./src/sandbox-agent-client.ts"
   }
 }

examples/shared/src/sandbox-agent-client.ts

@@ -140,7 +140,7 @@ export async function createSession({
   const normalized = normalizeBaseUrl(baseUrl);
   const sessionId = randomUUID();
   const body: Record<string, string> = {
-    agent: agentId || process.env.SANDBOX_AGENT || "codex",
+    agent: agentId || process.env.SANDBOX_AGENT || "claude",
   };
   const envAgentMode = agentMode || process.env.SANDBOX_AGENT_MODE;
   const envPermissionMode = permissionMode || process.env.SANDBOX_PERMISSION_MODE;
@@ -163,28 +163,6 @@ export async function createSession({
   return sessionId;
 }
 
-export async function sendMessage({
-  baseUrl,
-  token,
-  extraHeaders,
-  sessionId,
-  message,
-}: {
-  baseUrl: string;
-  token?: string;
-  extraHeaders?: Record<string, string>;
-  sessionId: string;
-  message: string;
-}): Promise<void> {
-  const normalized = normalizeBaseUrl(baseUrl);
-  await fetchJson(`${normalized}/v1/sessions/${sessionId}/messages`, {
-    token,
-    extraHeaders,
-    method: "POST",
-    body: { message },
-  });
-}
-
 function extractTextFromItem(item: any): string {
   if (!item?.content) return "";
   const textParts = item.content
@@ -197,53 +175,81 @@ function extractTextFromItem(item: any): string {
   return JSON.stringify(item.content, null, 2);
 }
 
-export async function waitForAssistantComplete({
+export async function sendMessageStream({
   baseUrl,
   token,
   extraHeaders,
   sessionId,
-  offset = 0,
-  timeoutMs = 120_000,
+  message,
+  onText,
 }: {
   baseUrl: string;
   token?: string;
   extraHeaders?: Record<string, string>;
   sessionId: string;
-  offset?: number;
-  timeoutMs?: number;
-}): Promise<{ text: string; offset: number }> {
+  message: string;
+  onText?: (text: string) => void;
+}): Promise<string> {
   const normalized = normalizeBaseUrl(baseUrl);
-  const deadline = Date.now() + timeoutMs;
-  let currentOffset = offset;
+  const headers = buildHeaders({ token, extraHeaders, contentType: true });
 
-  while (Date.now() < deadline) {
-    const data = await fetchJson(
-      `${normalized}/v1/sessions/${sessionId}/events?offset=${currentOffset}&limit=100`,
-      { token, extraHeaders }
-    );
+  const response = await fetch(`${normalized}/v1/sessions/${sessionId}/messages/stream`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ message }),
+  });
 
-    for (const event of data.events || []) {
-      if (typeof event.sequence === "number") {
-        currentOffset = Math.max(currentOffset, event.sequence);
+  if (!response.ok || !response.body) {
+    const text = await response.text();
+    throw new Error(`HTTP ${response.status} ${response.statusText}: ${text}`);
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let fullText = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      if (!line.startsWith("data: ")) continue;
+      const data = line.slice(6);
+      if (data === "[DONE]") continue;
+
+      try {
+        const event = JSON.parse(data);
+
+        // Handle text deltas
+        if (event.type === "item.delta" && event.data?.delta?.type === "text") {
+          const text = event.data.delta.text || "";
+          fullText += text;
+          onText?.(text);
+        }
+
+        // Handle completed assistant message
+        if (
+          event.type === "item.completed" &&
+          event.data?.item?.kind === "message" &&
+          event.data?.item?.role === "assistant"
+        ) {
+          const itemText = extractTextFromItem(event.data.item);
+          if (itemText && !fullText) {
+            fullText = itemText;
+          }
+        }
+      } catch {
+        // Ignore parse errors
       }
-      if (
-        event.type === "item.completed" &&
-        event.data?.item?.kind === "message" &&
-        event.data?.item?.role === "assistant"
-      ) {
-        return {
-          text: extractTextFromItem(event.data.item),
-          offset: currentOffset,
-        };
-      }
-    }
-
-    if (!data.hasMore) {
-      await delay(300);
     }
   }
 
-  throw new Error("Timed out waiting for assistant response");
+  return fullText;
 }
 
 export async function runPrompt({
@@ -258,7 +264,6 @@ export async function runPrompt({
   agentId?: string;
 }): Promise<void> {
   const sessionId = await createSession({ baseUrl, token, extraHeaders, agentId });
-  let offset = 0;
 
   console.log(`Session ${sessionId} ready. Type /exit to quit.`);
 
@@ -280,16 +285,15 @@ export async function runPrompt({
     }
 
     try {
-      await sendMessage({ baseUrl, token, extraHeaders, sessionId, message: trimmed });
-      const result = await waitForAssistantComplete({
+      await sendMessageStream({
         baseUrl,
         token,
         extraHeaders,
         sessionId,
-        offset,
+        message: trimmed,
+        onText: (text) => process.stdout.write(text),
       });
-      offset = result.offset;
-      process.stdout.write(`${result.text}\n`);
+      process.stdout.write("\n");
     } catch (error) {
       console.error(error instanceof Error ? error.message : error);
     }

examples/vercel/package.json

@@ -3,7 +3,7 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "start": "tsx vercel-sandbox.ts"
+    "start": "tsx src/vercel-sandbox.ts"
   },
   "dependencies": {
     "@vercel/sandbox": "latest",