@castari/sdk 0.0.1

package/dist/client.d.ts

@@ -0,0 +1,64 @@
+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. */
+    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?: 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;
+    /** @deprecated Use `volume` instead */
+    workspaceVolumeName?: string;
+}
+export declare class CastariClient {
+    private ws?;
+    private options;
+    private messageHandlers;
+    private sandbox?;
+    private daytona?;
+    constructor(options?: ClientOptions);
+    start(): Promise<void>;
+    private setupLocalConnection;
+    private setupDaytonaConnection;
+    private handleMessage;
+    onMessage(handler: (message: WSOutputMessage) => void): () => void;
+    send(message: WSInputMessage): void;
+    stop(): Promise<void>;
+}

package/dist/client.js

@@ -0,0 +1,339 @@
+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;
+    constructor(options = {}) {
+        this.options = {
+            ...options,
+        };
+    }
+    async start() {
+        const anthropicApiKey = this.options.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+        if (!anthropicApiKey) {
+            throw new Error('ANTHROPIC_API_KEY is required');
+        }
+        const connection = this.options.connectionUrl
+            ? await this.setupLocalConnection()
+            : await this.setupDaytonaConnection();
+        if (this.options.debug) {
+            console.log(`📡 Configuring server at ${connection.configUrl}...`);
+        }
+        const configPayload = {
+            anthropicApiKey,
+            agents: this.options.agents,
+            allowedTools: this.options.allowedTools,
+            systemPrompt: this.options.systemPrompt,
+            model: this.options.model,
+        };
+        const configHeaders = {
+            'Content-Type': 'application/json',
+        };
+        if (connection.previewToken) {
+            configHeaders['x-daytona-preview-token'] = connection.previewToken;
+        }
+        let configResponse = null;
+        const maxConfigAttempts = 10;
+        for (let attempt = 1; attempt <= maxConfigAttempts; attempt++) {
+            configResponse = await fetch(connection.configUrl, {
+                method: 'POST',
+                headers: configHeaders,
+                body: JSON.stringify(configPayload),
+            }).catch(err => {
+                if (this.options.debug) {
+                    console.warn(`⚠️ Config request failed on attempt ${attempt}:`, err);
+                }
+                return null;
+            });
+            if (configResponse && configResponse.ok)
+                break;
+            if (this.options.debug) {
+                console.warn(`⚠️ Config attempt ${attempt} failed (status ${configResponse?.status ?? 'n/a'}).`);
+            }
+            if (attempt < maxConfigAttempts) {
+                await new Promise(resolve => setTimeout(resolve, 3000));
+            }
+        }
+        if (!configResponse || !configResponse.ok) {
+            const errorText = configResponse ? await configResponse.text() : 'no response';
+            if (connection.cleanup)
+                await connection.cleanup();
+            throw new Error(`Failed to configure server (status ${configResponse?.status ?? 'n/a'}): ${errorText}`);
+        }
+        const { connectionToken } = (await configResponse.json());
+        if (!connectionToken) {
+            if (connection.cleanup)
+                await connection.cleanup();
+            throw new Error('Server did not return a connectionToken');
+        }
+        const wsUrlParams = new URLSearchParams();
+        wsUrlParams.set('token', connectionToken);
+        if (connection.previewToken) {
+            wsUrlParams.set('preview_token', connection.previewToken);
+        }
+        const wsUrlJoiner = connection.wsUrl.includes('?') ? '&' : '?';
+        const wsUrl = `${connection.wsUrl}${wsUrlJoiner}${wsUrlParams.toString()}`;
+        if (this.options.debug) {
+            console.log(`🔌 Connecting to WebSocket at ${wsUrl}...`);
+        }
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(wsUrl);
+            this.ws.onopen = () => {
+                if (this.options.debug)
+                    console.log('✅ Connected to Castari Server');
+                resolve();
+            };
+            this.ws.onmessage = event => {
+                try {
+                    const message = JSON.parse(event.data.toString());
+                    this.handleMessage(message);
+                }
+                catch (error) {
+                    console.error('Failed to parse message:', error);
+                }
+            };
+            this.ws.onerror = error => {
+                console.error('WebSocket error:', error);
+                reject(error);
+            };
+            this.ws.onclose = () => {
+                if (this.options.debug)
+                    console.log('👋 Disconnected');
+            };
+        });
+    }
+    async setupLocalConnection() {
+        const baseUrl = (this.options.connectionUrl || DEFAULT_LOCAL_URL).replace(/\/$/, '');
+        return {
+            configUrl: `${baseUrl.replace('ws://', 'http://').replace('wss://', 'https://')}/config`,
+            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.');
+            }
+        }
+        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,
+        };
+        this.sandbox = await this.daytona.create(createParams);
+        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);
+        }
+        // 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.');
+                }
+            }
+        }
+        baseUrl = baseUrl.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,
+            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);
+                    }
+                }
+            },
+        };
+    }
+    handleMessage(message) {
+        if (this.options.debug) {
+            console.log('📨 Received message:', JSON.stringify(message, null, 2));
+        }
+        this.messageHandlers.forEach(handler => handler(message));
+    }
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+        return () => {
+            this.messageHandlers = this.messageHandlers.filter(h => h !== handler);
+        };
+    }
+    send(message) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket is not connected');
+        }
+        this.ws.send(JSON.stringify(message));
+    }
+    async stop() {
+        if (this.ws) {
+            this.ws.close();
+        }
+        if (this.sandbox) {
+            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);
+                }
+            }
+        }
+    }
+}

package/dist/const.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Application constants
+ */
+export declare const SERVER_PORT = 3000;
+export declare const WORKSPACE_DIR_NAME = "agent-workspace";
+export declare const CONNECTION_TOKEN_TTL_MS: number;

package/dist/const.js

@@ -0,0 +1,9 @@
+/**
+ * Application constants
+ */
+// Server configuration
+export const SERVER_PORT = 3000;
+// Workspace configuration
+export const WORKSPACE_DIR_NAME = 'agent-workspace';
+// Connection token (one-time) configuration
+export const CONNECTION_TOKEN_TTL_MS = 5 * 60 * 10000; // 5 minutes

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './server';
+export * from './client';
+export { tool } from '@anthropic-ai/claude-agent-sdk';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './server';
+export * from './client';
+export { tool } from '@anthropic-ai/claude-agent-sdk';

package/dist/message-handler.d.ts

@@ -0,0 +1,8 @@
+import { query, type SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import { type ServerWebSocket } from 'bun';
+export type MessageHandlerContext = {
+    messageQueue: SDKUserMessage[];
+    getActiveStream: () => ReturnType<typeof query> | null;
+    workspaceDirectory: string;
+};
+export declare function handleMessage(ws: ServerWebSocket, message: string | Buffer, context: MessageHandlerContext): Promise<void>;

package/dist/message-handler.js

@@ -0,0 +1,96 @@
+import { readdir, readFile, unlink, writeFile } from 'fs/promises';
+import { join } from 'path';
+export async function handleMessage(ws, message, context) {
+    try {
+        const input = JSON.parse(message.toString());
+        const { messageQueue, getActiveStream, workspaceDirectory } = context;
+        if (input.type === 'user_message') {
+            messageQueue.push(input.data);
+        }
+        else if (input.type === 'interrupt') {
+            getActiveStream()?.interrupt();
+        }
+        else if (input.type === 'create_file') {
+            const targetPath = join(workspaceDirectory, input.path);
+            const encoding = input.encoding || 'utf-8';
+            const content = encoding === 'base64'
+                ? Buffer.from(input.content, 'base64')
+                : input.content;
+            try {
+                await writeFile(targetPath, content);
+                ws.send(JSON.stringify({
+                    type: 'file_result',
+                    operation: 'create_file',
+                    result: 'success',
+                }));
+            }
+            catch (err) {
+                ws.send(JSON.stringify({
+                    type: 'error',
+                    error: `Failed to create file: ${err instanceof Error ? err.message : String(err)}`,
+                }));
+            }
+        }
+        else if (input.type === 'read_file') {
+            const targetPath = join(workspaceDirectory, input.path);
+            const encoding = input.encoding || 'utf-8';
+            try {
+                const content = await readFile(targetPath, encoding === 'base64' ? 'base64' : 'utf-8');
+                ws.send(JSON.stringify({
+                    type: 'file_result',
+                    operation: 'read_file',
+                    result: content,
+                    encoding,
+                }));
+            }
+            catch (err) {
+                ws.send(JSON.stringify({
+                    type: 'error',
+                    error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}`,
+                }));
+            }
+        }
+        else if (input.type === 'delete_file') {
+            const targetPath = join(workspaceDirectory, input.path);
+            try {
+                await unlink(targetPath);
+                ws.send(JSON.stringify({
+                    type: 'file_result',
+                    operation: 'delete_file',
+                    result: 'success',
+                }));
+            }
+            catch (err) {
+                ws.send(JSON.stringify({
+                    type: 'error',
+                    error: `Failed to delete file: ${err instanceof Error ? err.message : String(err)}`,
+                }));
+            }
+        }
+        else if (input.type === 'list_files') {
+            const targetPath = input.path
+                ? join(workspaceDirectory, input.path)
+                : workspaceDirectory;
+            try {
+                const files = await readdir(targetPath);
+                ws.send(JSON.stringify({
+                    type: 'file_result',
+                    operation: 'list_files',
+                    result: files,
+                }));
+            }
+            catch (err) {
+                ws.send(JSON.stringify({
+                    type: 'error',
+                    error: `Failed to list files: ${err instanceof Error ? err.message : String(err)}`,
+                }));
+            }
+        }
+    }
+    catch (error) {
+        ws.send(JSON.stringify({
+            type: 'error',
+            error: `Invalid message format: ${error instanceof Error ? error.message : String(error)}`,
+        }));
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,5 @@
+import { type Options } from '@anthropic-ai/claude-agent-sdk';
+export type CastariServerOptions = Partial<Options> & {
+    port?: number;
+};
+export declare function serve(options?: CastariServerOptions): Promise<void>;

package/dist/server.js

@@ -0,0 +1,199 @@
+import { randomBytes } from 'crypto';
+import { mkdir } from 'fs/promises';
+import { homedir } from 'os';
+import { join } from 'path';
+import { query, } from '@anthropic-ai/claude-agent-sdk';
+import { CONNECTION_TOKEN_TTL_MS, SERVER_PORT, WORKSPACE_DIR_NAME, } from './const';
+import { handleMessage } from './message-handler';
+const workspaceDirectory = process.env.CASTARI_WORKSPACE || join(homedir(), WORKSPACE_DIR_NAME);
+// Single WebSocket connection (only one allowed)
+let activeConnection = null;
+// Message queue
+const messageQueue = [];
+// Stream reference for interrupts
+let activeStream = null;
+// Stored query configuration
+let queryConfig = {};
+// Connection tokens
+const connectionTokens = new Map();
+async function ensureWorkspace() {
+    await mkdir(workspaceDirectory, { recursive: true });
+}
+function generateConnectionToken() {
+    const value = randomBytes(24).toString('hex');
+    const token = {
+        value,
+        createdAt: Date.now(),
+        used: false,
+    };
+    connectionTokens.set(value, token);
+    return value;
+}
+function cleanupTokens() {
+    const now = Date.now();
+    for (const [value, token] of connectionTokens.entries()) {
+        if (token.used || now - token.createdAt > CONNECTION_TOKEN_TTL_MS) {
+            connectionTokens.delete(value);
+        }
+    }
+}
+function validateAndUseToken(value) {
+    cleanupTokens();
+    if (!value)
+        return false;
+    const token = connectionTokens.get(value);
+    if (!token)
+        return false;
+    const isExpired = Date.now() - token.createdAt > CONNECTION_TOKEN_TTL_MS;
+    if (token.used || isExpired) {
+        connectionTokens.delete(value);
+        return false;
+    }
+    token.used = true;
+    connectionTokens.set(value, token);
+    return true;
+}
+// Create an async generator that yields messages from the queue
+async function* generateMessages() {
+    while (true) {
+        while (messageQueue.length > 0) {
+            const message = messageQueue.shift();
+            if (message) {
+                yield message;
+            }
+        }
+        await new Promise(resolve => setTimeout(resolve, 10));
+    }
+}
+// Process messages from the SDK and send to WebSocket client
+async function processMessages(initialOptions) {
+    try {
+        const options = {
+            settingSources: ['local'],
+            cwd: workspaceDirectory,
+            // Auto-approve tool usage (including file writes) inside the sandbox.
+            // Daytona sandboxes are already isolated, so this keeps DX smooth without interactive prompts.
+            canUseTool: async (_toolName, input) => ({
+                behavior: 'allow',
+                updatedInput: input,
+            }),
+            stderr: data => {
+                if (activeConnection) {
+                    const output = {
+                        type: 'info',
+                        data,
+                    };
+                    activeConnection.send(JSON.stringify(output));
+                }
+            },
+            ...initialOptions, // Merge initial options (tools, systemPrompt, etc.)
+            ...queryConfig, // Merge dynamic config from /config endpoint (overrides initial)
+            ...(queryConfig.anthropicApiKey || process.env.ANTHROPIC_API_KEY
+                ? {
+                    env: {
+                        PATH: process.env.PATH,
+                        ANTHROPIC_API_KEY: queryConfig.anthropicApiKey || process.env.ANTHROPIC_API_KEY,
+                    },
+                }
+                : {}),
+        };
+        console.info('Starting query with options', {
+            ...options,
+            prompt: '[generator]', // avoid logging generator internals
+        });
+        activeStream = query({
+            prompt: generateMessages(),
+            options,
+        });
+        for await (const message of activeStream) {
+            if (activeConnection) {
+                const output = {
+                    type: 'sdk_message',
+                    data: message,
+                };
+                activeConnection.send(JSON.stringify(output));
+            }
+        }
+    }
+    catch (error) {
+        console.error('Error processing messages:', error);
+        if (activeConnection) {
+            const output = {
+                type: 'error',
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+            activeConnection.send(JSON.stringify(output));
+        }
+    }
+}
+export async function serve(options = {}) {
+    await ensureWorkspace();
+    // Create WebSocket server
+    const server = Bun.serve({
+        port: options.port || SERVER_PORT,
+        async fetch(req, server) {
+            const url = new URL(req.url);
+            // Configuration endpoint
+            if (url.pathname === '/config' && req.method === 'POST') {
+                try {
+                    const config = (await req.json());
+                    queryConfig = config;
+                    const connectionToken = generateConnectionToken();
+                    return Response.json({
+                        success: true,
+                        config: queryConfig,
+                        connectionToken,
+                    });
+                }
+                catch {
+                    return Response.json({ error: 'Invalid JSON' }, { status: 400 });
+                }
+            }
+            // Get current configuration
+            if (url.pathname === '/config' && req.method === 'GET') {
+                return Response.json({ config: queryConfig });
+            }
+            // WebSocket endpoint
+            if (url.pathname === '/ws') {
+                const token = url.searchParams.get('token');
+                if (!validateAndUseToken(token)) {
+                    return new Response('Unauthorized', { status: 401 });
+                }
+                if (activeConnection) {
+                    return new Response('Server already has an active connection', {
+                        status: 409,
+                    });
+                }
+                if (server.upgrade(req))
+                    return;
+            }
+            return new Response('Not Found', { status: 404 });
+        },
+        websocket: {
+            open(ws) {
+                activeConnection = ws;
+                // Start processing messages when first connection is made
+                if (!activeStream) {
+                    processMessages(options);
+                }
+                const output = { type: 'connected' };
+                ws.send(JSON.stringify(output));
+            },
+            async message(ws, message) {
+                await handleMessage(ws, message, {
+                    messageQueue,
+                    getActiveStream: () => activeStream,
+                    workspaceDirectory,
+                });
+            },
+            close(ws) {
+                if (activeConnection === ws) {
+                    activeConnection = null;
+                }
+            },
+        },
+    });
+    console.log(`🚀 Castari Server running on http://localhost:${server.port}`);
+    console.log(`   Config endpoint: http://localhost:${server.port}/config`);
+    console.log(`   WebSocket endpoint: ws://localhost:${server.port}/ws?token=<token>`);
+}

package/dist/types.d.ts

@@ -0,0 +1,58 @@
+import { type AgentDefinition, type SDKMessage, type SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+export type WSInputMessage = {
+    type: 'user_message';
+    data: SDKUserMessage;
+} | {
+    type: 'interrupt';
+} | {
+    type: 'create_file';
+    path: string;
+    content: string;
+    encoding?: 'utf-8' | 'base64';
+} | {
+    type: 'read_file';
+    path: string;
+    encoding?: 'utf-8' | 'base64';
+} | {
+    type: 'delete_file';
+    path: string;
+} | {
+    type: 'list_files';
+    path?: string;
+};
+export type WSOutputMessage = {
+    type: 'connected';
+} | {
+    type: 'sdk_message';
+    data: SDKMessage;
+} | {
+    type: 'error';
+    error: string;
+} | {
+    type: 'info';
+    data: string;
+} | {
+    type: 'file_result';
+    operation: 'create_file' | 'delete_file';
+    result: 'success';
+} | {
+    type: 'file_result';
+    operation: 'read_file';
+    result: string;
+    encoding: 'utf-8' | 'base64';
+} | {
+    type: 'file_result';
+    operation: 'list_files';
+    result: string[];
+};
+export type QueryConfig = {
+    agents?: Record<string, AgentDefinition>;
+    allowedTools?: string[];
+    systemPrompt?: string | {
+        type: 'preset';
+        preset: 'claude_code';
+        append?: string;
+    };
+    model?: string;
+    anthropicApiKey?: string;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,38 @@
+{
+    "name": "@castari/sdk",
+    "version": "0.0.1",
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "scripts": {
+        "build": "tsc"
+    },
+    "files": [
+        "dist"
+    ],
+    "license": "UNLICENSED",
+    "publishConfig": {
+        "access": "public"
+    },
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        },
+        "./client": {
+            "import": "./dist/client.js",
+            "types": "./dist/client.d.ts"
+        },
+        "./server": {
+            "import": "./dist/server.js",
+            "types": "./dist/server.d.ts"
+        }
+    },
+    "dependencies": {
+        "@anthropic-ai/claude-agent-sdk": "^0.1.44",
+        "@daytonaio/sdk": "^0.115.2"
+    },
+    "devDependencies": {
+        "@types/bun": "latest"
+    }
+}