@castari/sdk 0.0.3 → 0.0.5

package/README.md

@@ -0,0 +1,39 @@
+# @castari/sdk
+
+The SDK for building Castari agents.
+
+## Installation
+
+```bash
+npm install @castari/sdk
+```
+
+## Usage
+
+See the [SDK Reference](../../docs/sdk-reference.md) for detailed documentation.
+
+### Defining an Agent
+
+```typescript
+import { serve, tool } from '@castari/sdk'
+
+const myTool = tool({ ... })
+
+serve({
+  tools: [myTool],
+  systemPrompt: 'You are a helpful assistant.'
+})
+```
+
+### Connecting to an Agent
+
+```typescript
+import { CastariClient } from '@castari/sdk/client'
+
+const client = new CastariClient({
+  snapshot: 'my-agent',
+  // platformUrl: '...' // Optional
+})
+
+await client.start()
+```

package/dist/client.d.ts

@@ -1,64 +1,35 @@
 import type { QueryConfig, WSInputMessage, WSOutputMessage } from './types';
 export * from './types';
-type DaytonaCreateOptions = {
-    snapshot?: string;
-    image?: unknown;
-    resources?: {
-        cpu?: number;
-        memory?: number;
-        disk?: number;
-    };
-    autoStopInterval?: number;
-    autoArchiveInterval?: number;
-    autoDeleteInterval?: number;
-    ephemeral?: boolean;
-    public?: boolean;
-    volumes?: {
-        volumeId: string;
-        mountPath: string;
-    }[];
-};
 /**
  * Configuration options for the Castari Client.
  */
 export interface ClientOptions extends Partial<QueryConfig> {
-    /** Local/custom connection URL (e.g., 'http://localhost:3000'). If omitted, Daytona mode is used. */
+    /** Local/custom connection URL (e.g., 'http://localhost:3000'). If omitted, Platform mode is used. */
     connectionUrl?: string;
     /** Anthropic API key (required unless present in process.env.ANTHROPIC_API_KEY) */
     anthropicApiKey?: string;
     /** Enable debug logging */
     debug?: boolean;
-    daytonaApiKey?: string;
-    daytonaApiUrl?: string;
-    daytonaTarget?: string;
-    /** Override to skip preview discovery; should be base URL to server (e.g., https://3000-<sandboxId>.<domain>) */
-    daytonaConnectionUrl?: string;
+    /** Snapshot name to deploy/start */
     snapshot?: string;
-    image?: unknown;
-    /** Optional override for preview domain if provider metadata is missing. Example: "preview.daytona.io" */
-    daytonaPreviewDomain?: string;
-    resources?: DaytonaCreateOptions['resources'];
-    autoStopInterval?: number;
-    autoArchiveInterval?: number;
-    autoDeleteInterval?: number;
-    ephemeral?: boolean;
-    /** Optional Daytona volume name to mount at /home/daytona/agent-workspace. Defaults to undefined (no volume). */
-    volume?: string;
     /** Optional labels to apply to the sandbox (and filter by for reuse) */
     labels?: Record<string, string>;
-    /** @deprecated Use `volume` instead */
-    workspaceVolumeName?: string;
+    /** Optional volume name to mount at /home/daytona/agent-workspace */
+    volume?: string;
+    /** Castari Platform API URL. Defaults to https://api.castari.com (or localhost in dev) */
+    platformUrl?: string;
+    /** Optional sessionId to resume */
+    resume?: string;
 }
 export declare class CastariClient {
     private ws?;
     private options;
     private messageHandlers;
-    private sandbox?;
-    private daytona?;
+    private sandboxId?;
     constructor(options?: ClientOptions);
     start(): Promise<void>;
     private setupLocalConnection;
-    private setupDaytonaConnection;
+    private setupPlatformConnection;
     private handleMessage;
     onMessage(handler: (message: WSOutputMessage) => void): () => void;
     send(message: WSInputMessage): void;

package/dist/client.js

@@ -1,12 +1,10 @@
 export * from './types';
 const DEFAULT_LOCAL_URL = 'http://localhost:3000';
-const DEFAULT_WORKSPACE_MOUNT = '/home/daytona/agent-workspace';
 export class CastariClient {
     ws;
     options;
     messageHandlers = [];
-    sandbox;
-    daytona;
+    sandboxId;
     constructor(options = {}) {
         this.options = {
             ...options,
@@ -19,7 +17,7 @@ export class CastariClient {
         }
         const connection = this.options.connectionUrl
             ? await this.setupLocalConnection()
-            : await this.setupDaytonaConnection();
+            : await this.setupPlatformConnection();
         if (this.options.debug) {
             console.log(`📡 Configuring server at ${connection.configUrl}...`);
         }
@@ -29,7 +27,11 @@ export class CastariClient {
             allowedTools: this.options.allowedTools,
             systemPrompt: this.options.systemPrompt,
             model: this.options.model,
+            resume: this.options.resume,
         };
+        if (this.options.debug) {
+            console.log(`📋 Config payload:`, JSON.stringify(configPayload, null, 2));
+        }
         const configHeaders = {
             'Content-Type': 'application/json',
         };
@@ -113,212 +115,39 @@ export class CastariClient {
             wsUrl: `${baseUrl.replace('http://', 'ws://').replace('https://', 'wss://')}/ws`,
         };
     }
-    async setupDaytonaConnection() {
-        const { Daytona } = await import('@daytonaio/sdk');
-        const apiKey = this.options.daytonaApiKey || process.env.DAYTONA_API_KEY;
-        if (!apiKey) {
-            throw new Error('DAYTONA_API_KEY is required for Daytona mode');
-        }
-        this.daytona = new Daytona({
-            apiKey,
-            apiUrl: this.options.daytonaApiUrl || process.env.DAYTONA_API_URL,
-            target: this.options.daytonaTarget || process.env.DAYTONA_TARGET,
-        });
-        const volumeName = this.options.volume || this.options.workspaceVolumeName;
-        let volumeMounts = [];
-        if (volumeName) {
-            const volumeService = this.daytona.volume;
-            if (volumeService && typeof volumeService.get === 'function') {
-                // Ensure volume exists
-                let volume;
-                try {
-                    volume = await volumeService.get(volumeName, true); // true = create if missing
-                }
-                catch (err) {
-                    // If get fails, try create explicitly if the SDK requires it, but usually get(name, true) handles it.
-                    // Assuming get(name, true) works as per previous implementation.
-                    console.error('Failed to get/create volume:', err);
-                    throw err;
-                }
-                volumeMounts = [
-                    {
-                        volumeId: volume.id,
-                        mountPath: DEFAULT_WORKSPACE_MOUNT,
-                    },
-                ];
-                if (this.options.debug) {
-                    console.log(`🗂️  Using Daytona volume ${volume.id} (${volumeName}) at ${DEFAULT_WORKSPACE_MOUNT}`);
-                }
-            }
-            else {
-                console.warn('Daytona SDK does not expose volume.get; skipping volume mount. Update @daytonaio/sdk or disable volume.');
-            }
-        }
+    async setupPlatformConnection() {
+        const platformUrl = this.options.platformUrl || process.env.CASTARI_PLATFORM_URL || 'http://localhost:3000';
         if (this.options.debug) {
-            console.log('🚀 Creating Daytona sandbox...');
-            if (volumeName) {
-                console.log(`📦 Mounting volume ${volumeName} at ${DEFAULT_WORKSPACE_MOUNT}`);
-            }
-            else {
-                console.log('📦 No volume configured; using ephemeral container filesystem.');
-            }
-        }
-        const createParams = {
-            snapshot: this.options.snapshot,
-            image: this.options.image,
-            resources: this.options.resources,
-            autoStopInterval: this.options.autoStopInterval,
-            autoArchiveInterval: this.options.autoArchiveInterval,
-            autoDeleteInterval: this.options.autoDeleteInterval,
-            ephemeral: this.options.ephemeral,
-            public: true,
-            volumes: volumeMounts,
-        };
-        // Check for existing sandbox if labels are provided
-        if (this.options.labels) {
-            const existing = await this.daytona.list(this.options.labels);
-            if (existing.items.length > 0) {
-                // Use the first matching sandbox
-                this.sandbox = existing.items[0];
-                if (this.options.debug) {
-                    console.log(`♻️  Found existing sandbox: ${this.sandbox.id} (${this.sandbox.state})`);
-                }
-                // Ensure it's started
-                if (this.sandbox.state !== 'started') {
-                    if (this.options.debug) {
-                        console.log('▶️ Starting existing sandbox...');
-                    }
-                    await this.sandbox.start();
-                }
-            }
+            console.log(`🚀 Requesting sandbox from ${platformUrl}...`);
         }
-        // Create new if not found
-        if (!this.sandbox) {
-            // Add labels to create params
-            const paramsWithLabels = {
-                ...createParams,
+        const response = await fetch(`${platformUrl}/sandbox/start`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                snapshot: this.options.snapshot,
                 labels: this.options.labels,
-            };
-            this.sandbox = await this.daytona.create(paramsWithLabels);
-            if (this.options.debug) {
-                console.log(`✅ Sandbox created: ${this.sandbox.id}`);
-            }
-        }
-        // Wait for sandbox to reach STARTED state before interacting with it
-        const sandboxAny = this.sandbox;
-        if (typeof sandboxAny.waitUntilStarted === 'function') {
-            if (this.options.debug) {
-                console.log('⏳ Waiting for sandbox to reach STARTED state...');
-            }
-            await sandboxAny.waitUntilStarted(60);
-        }
-        // Start the Castari server process inside the sandbox.
-        // We keep the container's default ENTRYPOINT as a no-op ('sleep infinity') for snapshot validation,
-        // and explicitly start the server here via Daytona's process API, invoking the server entrypoint directly.
-        const serverCommand = `sh -lc "cd /home/daytona/app && CASTARI_WORKSPACE=${DEFAULT_WORKSPACE_MOUNT} bun start"`;
-        try {
-            const sessionId = `castari-server-${this.sandbox.id}`;
-            const processApi = this.sandbox.process;
-            if (processApi &&
-                typeof processApi.createSession === 'function' &&
-                typeof processApi.executeSessionCommand === 'function') {
-                if (this.options.debug) {
-                    console.log(`▶️ Creating process session ${sessionId} and starting server...`);
-                }
-                await processApi.createSession(sessionId);
-                await processApi.executeSessionCommand(sessionId, {
-                    command: serverCommand,
-                    async: true,
-                });
-            }
-            else if (processApi && typeof processApi.executeCommand === 'function') {
-                if (this.options.debug) {
-                    console.log('▶️ Starting server via executeCommand...');
-                }
-                await processApi.executeCommand({
-                    command: serverCommand,
-                    async: true,
-                });
-            }
-            else {
-                console.warn('Daytona SDK process API is not available; unable to start server automatically inside sandbox.');
-            }
-            // Give the server a brief moment to start listening on port 3000 before configuring it.
-            if (this.options.debug) {
-                console.log('⏳ Waiting briefly for Castari server to start inside sandbox...');
-            }
-            await new Promise(resolve => setTimeout(resolve, 3000));
-        }
-        catch (err) {
-            console.error('Failed to start Castari server inside sandbox:', err);
+                volume: this.options.volume
+            })
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to start sandbox: ${errorText}`);
         }
-        // If user supplies a direct connection URL, use it to avoid preview discovery
-        let baseUrl = this.options.daytonaConnectionUrl || process.env.DAYTONA_CONNECTION_URL || null;
-        let previewToken;
-        if (!baseUrl) {
-            // Try getPreviewUrl (newer SDKs), then getPreviewLink (older SDKs)
-            let preview = null;
-            if (typeof this.sandbox.getPreviewUrl === 'function') {
-                try {
-                    preview = await this.sandbox.getPreviewUrl(3000);
-                }
-                catch (err) {
-                    if (this.options.debug) {
-                        console.warn('⚠️ getPreviewUrl failed; will fall back to getPreviewLink or manual domain.', err);
-                    }
-                }
-            }
-            if (!preview?.url && typeof this.sandbox.getPreviewLink === 'function') {
-                try {
-                    preview = await this.sandbox.getPreviewLink(3000);
-                }
-                catch (err) {
-                    if (this.options.debug) {
-                        console.warn('⚠️ getPreviewLink failed; will attempt fallback domain if provided.', err);
-                    }
-                }
-            }
-            baseUrl = preview?.url || null;
-            previewToken = preview?.token;
-            if (!baseUrl) {
-                // Fallback: construct from provided preview domain if available
-                const previewDomain = this.options.daytonaPreviewDomain || process.env.DAYTONA_PREVIEW_DOMAIN;
-                if (previewDomain) {
-                    baseUrl = `https://${3000}-${this.sandbox.id}.${previewDomain}`;
-                    if (this.options.debug) {
-                        console.warn(`⚠️ Preview URL not provided by SDK; using fallback domain ${previewDomain}`);
-                    }
-                }
-                else {
-                    throw new Error('Failed to get preview URL from Daytona sandbox. Provide daytonaConnectionUrl or DAYTONA_PREVIEW_DOMAIN.');
-                }
-            }
+        const { id, url, token } = await response.json();
+        this.sandboxId = id;
+        if (this.options.debug) {
+            console.log(`✅ Sandbox started: ${id} at ${url}`);
         }
-        baseUrl = baseUrl.replace(/\/$/, '');
+        const baseUrl = url.replace(/\/$/, '');
         const configUrl = `${baseUrl.replace('ws://', 'http://').replace('wss://', 'https://')}/config`;
         const wsUrlBase = `${baseUrl.replace('https://', 'wss://').replace('http://', 'ws://')}/ws`;
         return {
             configUrl,
             wsUrl: wsUrlBase,
-            previewToken,
+            previewToken: token,
             cleanup: async () => {
-                try {
-                    await this.sandbox?.delete();
-                    if (this.options.debug)
-                        console.log('🧹 Sandbox deleted');
-                }
-                catch (err) {
-                    const msg = err?.response?.data?.message || err?.message || String(err);
-                    if (msg.includes('state change in progress')) {
-                        if (this.options.debug) {
-                            console.warn('⚠️ Sandbox deletion skipped (state change in progress)');
-                        }
-                    }
-                    else {
-                        console.error('Failed to delete sandbox:', err);
-                    }
-                }
-            },
+                await this.stop({ delete: true });
+            }
         };
     }
     handleMessage(message) {
@@ -343,29 +172,26 @@ export class CastariClient {
         if (this.ws) {
             this.ws.close();
         }
-        if (this.sandbox) {
+        if (this.sandboxId) {
+            const platformUrl = this.options.platformUrl || process.env.CASTARI_PLATFORM_URL || 'http://localhost:3000';
             try {
-                if (options.delete) {
-                    await this.sandbox.delete();
-                    if (this.options.debug)
-                        console.log('🧹 Sandbox deleted');
+                const response = await fetch(`${platformUrl}/sandbox/stop`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        sandboxId: this.sandboxId,
+                        delete: options.delete
+                    })
+                });
+                if (!response.ok) {
+                    console.error(`Failed to stop sandbox: ${await response.text()}`);
                 }
-                else {
-                    await this.sandbox.stop();
-                    if (this.options.debug)
-                        console.log('🛑 Sandbox stopped (preserved)');
+                else if (this.options.debug) {
+                    console.log(`🛑 Sandbox ${options.delete ? 'deleted' : 'stopped'}`);
                 }
             }
             catch (err) {
-                const msg = err?.response?.data?.message || err?.message || String(err);
-                if (msg.includes('state change in progress')) {
-                    if (this.options.debug) {
-                        console.warn(`⚠️ Sandbox ${options.delete ? 'deletion' : 'stop'} skipped (state change in progress)`);
-                    }
-                }
-                else {
-                    console.error(`Failed to ${options.delete ? 'delete' : 'stop'} sandbox:`, err);
-                }
+                console.error('Failed to call stop endpoint:', err);
             }
         }
     }

package/dist/server.js

@@ -115,6 +115,12 @@ async function processMessages(initialOptions) {
             ...options,
             prompt: '[generator]', // avoid logging generator internals
         });
+        if (options.resume) {
+            console.info(`📋 Resuming session: ${options.resume}`);
+        }
+        else {
+            console.info('📋 Starting new session');
+        }
         activeStream = query({
             prompt: generateMessages(),
             options,

package/dist/types.d.ts

@@ -55,4 +55,5 @@ export type QueryConfig = {
     };
     model?: string;
     anthropicApiKey?: string;
+    resume?: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@castari/sdk",
-    "version": "0.0.3",
+    "version": "0.0.5",
     "type": "module",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -29,8 +29,7 @@
         }
     },
     "dependencies": {
-        "@anthropic-ai/claude-agent-sdk": "^0.1.44",
-        "@daytonaio/sdk": "^0.115.2"
+        "@anthropic-ai/claude-agent-sdk": "^0.1.44"
     },
     "devDependencies": {
         "@types/bun": "latest"