@castari/cli 0.0.2 → 0.0.5

package/README.md

@@ -0,0 +1,20 @@
+# @castari/cli
+
+The Command Line Interface for Castari.
+
+## Installation
+
+```bash
+npm install -g @castari/cli
+```
+
+## Usage
+
+See the [CLI Reference](../../docs/cli-reference.md) for detailed documentation.
+
+```bash
+castari init      # Create a new agent
+castari dev       # Run locally
+castari deploy    # Deploy to Platform
+castari start     # Start sandbox
+```

package/dist/commands/deploy.js

@@ -1,12 +1,7 @@
-import { Daytona, Image } from '@daytonaio/sdk';
 import { readFile } from 'fs/promises';
 import chalk from 'chalk';
+import AdmZip from 'adm-zip';
 export async function deploy(options) {
-    const apiKey = process.env.DAYTONA_API_KEY;
-    if (!apiKey) {
-        console.error(chalk.red('Error: DAYTONA_API_KEY is required.'));
-        process.exit(1);
-    }
     // Read package.json to get default snapshot name
     let snapshotName = options.snapshot;
     if (!snapshotName) {
@@ -23,42 +18,45 @@ export async function deploy(options) {
         console.error(chalk.red('Error: Snapshot name is required (via --snapshot or package.json name).'));
         process.exit(1);
     }
-    console.log(chalk.blue(`🧱 Building Daytona snapshot "${snapshotName}"...`));
-    const daytona = new Daytona({
-        apiKey,
-        apiUrl: process.env.DAYTONA_API_URL,
-        target: process.env.DAYTONA_TARGET,
-    });
+    console.log(chalk.blue(`📦 Packaging source code...`));
+    const zip = new AdmZip();
     const projectRoot = process.cwd();
-    const workspaceMount = '/home/daytona/agent-workspace';
-    // Use official Bun image
-    const image = Image.base('oven/bun:1.3.1')
-        .addLocalDir(projectRoot, '/home/daytona/app')
-        .workdir('/home/daytona/app')
-        .runCommands('apt-get update && apt-get install -y git', 'bun install', `mkdir -p ${workspaceMount}`)
-        .entrypoint(['sleep', 'infinity']);
+    // Add local files, respecting a simple ignore list for now
+    // Ideally we'd parse .gitignore, but for MVP let's just ignore common heavy folders
+    const ignoreList = ['node_modules', '.git', 'dist', '.daytona', '.env'];
+    zip.addLocalFolder(projectRoot, undefined, (filename) => {
+        // Simple filter: return false to exclude
+        // filename is the relative path in the zip? No, it seems to be the absolute path or filename.
+        // AdmZip filter is a bit tricky. Let's assume it passes the name.
+        // Actually addLocalFolder filter takes a RegExp or function.
+        // If function: (filename: string) => boolean.
+        // Note: filename passed to filter is usually the relative path.
+        // Let's try to be safe and just add everything except node_modules at the root.
+        // Actually, addLocalFolder adds everything.
+        // We might want to use addLocalFile loop or similar if we want strict control.
+        // But let's try the filter.
+        return !ignoreList.some(ignore => filename.includes(ignore));
+    });
+    const zipBuffer = zip.toBuffer();
+    console.log(chalk.blue(`🚀 Uploading to Castari Platform...`));
+    const platformUrl = process.env.CASTARI_PLATFORM_URL || 'http://localhost:3000';
+    const formData = new FormData();
+    formData.append('file', new Blob([zipBuffer]), 'source.zip');
+    formData.append('snapshot', snapshotName);
     try {
-        // Try to delete existing snapshot to allow overwrite
-        try {
-            await daytona.snapshot.delete(snapshotName);
-            console.log(chalk.yellow(`🗑️  Deleted existing snapshot "${snapshotName}"`));
-        }
-        catch (e) {
-            // Ignore delete error (e.g. not found)
-        }
-        await daytona.snapshot.create({
-            name: snapshotName,
-            image,
-        }, {
-            onLogs: log => {
-                if (log)
-                    process.stdout.write(log);
-            },
+        const response = await fetch(`${platformUrl}/deploy`, {
+            method: 'POST',
+            body: formData,
         });
-        console.log(chalk.green(`✅ Snapshot "${snapshotName}" created successfully!`));
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Platform error (${response.status}): ${errorText}`);
+        }
+        const result = await response.json();
+        console.log(chalk.green(`✅ Snapshot "${result.snapshot}" created successfully!`));
     }
     catch (err) {
-        console.error(chalk.red('Snapshot build failed:'), err.message || err);
+        console.error(chalk.red('Deploy failed:'), err.message || err);
         process.exit(1);
     }
 }

package/dist/commands/init.d.ts

@@ -1 +1,5 @@
-export declare function init(): Promise<void>;
+type InitOptions = {
+    demo?: boolean;
+};
+export declare function init(options?: InitOptions): Promise<void>;
+export {};

package/dist/commands/init.js

@@ -2,7 +2,10 @@ import inquirer from 'inquirer';
 import { writeFile, mkdir } from 'fs/promises';
 import { join } from 'path';
 import chalk from 'chalk';
-export async function init() {
+export async function init(options = {}) {
+    if (options.demo) {
+        return initDemo();
+    }
     console.log(chalk.blue('🤖 Initializing new Castari agent project...'));
     const answers = await inquirer.prompt([
         {
@@ -22,7 +25,7 @@ export async function init() {
             start: 'castari start',
         },
         dependencies: {
-            '@castari/sdk': 'workspace:*',
+            '@castari/sdk': '^0.0.4',
             '@anthropic-ai/claude-agent-sdk': '^0.1.44',
         },
         castari: {
@@ -62,7 +65,7 @@ serve({
   systemPrompt: 'You are a helpful Castari agent.',
 })
 `;
-    const envExample = `ANTHROPIC_API_KEY=sk-ant-...\nDAYTONA_API_KEY=...\n`;
+    const envExample = `ANTHROPIC_API_KEY=sk-ant-...\n# CASTARI_PLATFORM_URL=https://api.castari.com\n`;
     await writeFile('package.json', JSON.stringify(packageJson, null, 2));
     await writeFile('tsconfig.json', JSON.stringify(tsConfig, null, 2));
     await writeFile('.env.example', envExample);
@@ -71,3 +74,619 @@ serve({
     console.log(chalk.green('✅ Project initialized!'));
     console.log(chalk.white('Run `bun install` to install dependencies.'));
 }
+async function initDemo() {
+    console.log(chalk.blue('🎨 Initializing Castari demo (web + agent)...'));
+    const demoRoot = 'castari_demo';
+    const agentDir = join(demoRoot, 'agent');
+    const webDir = join(demoRoot, 'web');
+    const writeJson = async (path, obj) => writeFile(path, JSON.stringify(obj, null, 2));
+    // Agent scaffold
+    await mkdir(join(agentDir, 'src'), { recursive: true });
+    await writeJson(join(agentDir, 'package.json'), {
+        name: 'castari-demo-agent',
+        version: '0.1.0',
+        private: true,
+        type: 'module',
+        scripts: {
+            dev: 'bun run src/agent.ts',
+            deploy: 'castari deploy',
+            start: 'bun run src/agent.ts',
+        },
+        dependencies: {
+            '@castari/sdk': '^0.0.4',
+            '@anthropic-ai/claude-agent-sdk': '^0.1.50',
+        },
+        castari: {
+            volume: 'castari-demo-workspace',
+        },
+    });
+    await writeJson(join(agentDir, 'tsconfig.json'), {
+        compilerOptions: {
+            target: 'ESNext',
+            module: 'ESNext',
+            moduleResolution: 'bundler',
+            strict: true,
+            skipLibCheck: true,
+            esModuleInterop: true,
+        },
+        include: ['src'],
+    });
+    await writeFile(join(agentDir, '.env.example'), 'ANTHROPIC_API_KEY=sk-ant-...\n# CASTARI_PLATFORM_URL=http://localhost:3000\n');
+    await writeFile(join(agentDir, 'src', 'agent.ts'), `import { serve } from '@castari/sdk'
+
+serve({
+    systemPrompt: [
+        'You are Castari Demo Agent.',
+        'Keep responses concise and friendly.',
+        'Feel free to explain how you can help with code or product questions.',
+    ].join(' '),
+    includePartialMessages: true,
+})
+`);
+    // Web scaffold
+    await mkdir(join(webDir, 'app', 'api', 'chat'), { recursive: true });
+    await writeJson(join(webDir, 'package.json'), {
+        name: 'castari-demo-web',
+        version: '0.1.0',
+        private: true,
+        scripts: {
+            dev: 'next dev',
+            build: 'next build',
+            start: 'next start',
+        },
+        dependencies: {
+            '@castari/sdk': '^0.0.4',
+            next: '14.2.3',
+            react: '18.3.1',
+            'react-dom': '18.3.1',
+        },
+        devDependencies: {
+            '@types/node': '^20.11.0',
+            '@types/react': '^18.2.0',
+            '@types/react-dom': '^18.2.0',
+            typescript: '^5.6.3',
+        },
+    });
+    await writeJson(join(webDir, 'tsconfig.json'), {
+        compilerOptions: {
+            target: 'ES2020',
+            lib: ['dom', 'dom.iterable', 'esnext'],
+            allowJs: true,
+            skipLibCheck: true,
+            strict: true,
+            noEmit: true,
+            esModuleInterop: true,
+            module: 'esnext',
+            moduleResolution: 'bundler',
+            resolveJsonModule: true,
+            isolatedModules: true,
+            jsx: 'preserve',
+            incremental: true,
+            types: ['node'],
+            baseUrl: '.',
+            paths: {
+                '@/*': ['./*'],
+            },
+        },
+        include: ['next-env.d.ts', '**/*.ts', '**/*.tsx', '.next/types/**/*.ts'],
+        exclude: ['node_modules'],
+    });
+    await writeFile(join(webDir, 'next-env.d.ts'), `/// <reference types="next" />
+/// <reference types="next/types/global" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+`);
+    await writeFile(join(webDir, 'next.config.mjs'), `/** @type {import('next').NextConfig} */
+const nextConfig = {
+  experimental: {
+    serverActions: false
+  }
+}
+
+export default nextConfig
+`);
+    await writeFile(join(webDir, '.env.example'), 'ANTHROPIC_API_KEY=sk-ant-...\n# CASTARI_PLATFORM_URL=http://localhost:3000\n# CASTARI_DEBUG=false\n');
+    await writeFile(join(webDir, 'app', 'globals.css'), `:root {
+  color-scheme: light;
+  background: #f5f5f5;
+  font-family: "Inter", system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  background: radial-gradient(circle at 20% 20%, #f7f0ff 0, #f5f5f5 35%), radial-gradient(circle at 80% 0%, #e0f4ff 0, #f5f5f5 30%);
+  color: #0f172a;
+  min-height: 100vh;
+}
+
+a {
+  color: inherit;
+  text-decoration: none;
+}
+
+.chat-container {
+  max-width: 760px;
+  margin: 0 auto;
+  padding: 32px 16px 64px;
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+
+.card {
+  background: rgba(255, 255, 255, 0.85);
+  backdrop-filter: blur(6px);
+  border: 1px solid rgba(15, 23, 42, 0.06);
+  border-radius: 16px;
+  box-shadow: 0 20px 60px rgba(15, 23, 42, 0.12);
+  padding: 24px;
+}
+
+.heading {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  font-size: 22px;
+  font-weight: 700;
+}
+
+.badge {
+  font-size: 12px;
+  font-weight: 600;
+  color: #0ea5e9;
+  background: rgba(14, 165, 233, 0.1);
+  padding: 6px 10px;
+  border-radius: 999px;
+  border: 1px solid rgba(14, 165, 233, 0.2);
+}
+
+.messages {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.bubble {
+  padding: 14px 16px;
+  border-radius: 14px;
+  max-width: 90%;
+  line-height: 1.5;
+  font-size: 15px;
+}
+
+.bubble.assistant {
+  background: #0f172a;
+  color: white;
+  align-self: flex-start;
+  border-bottom-left-radius: 4px;
+}
+
+.bubble.user {
+  background: white;
+  color: #0f172a;
+  border: 1px solid rgba(15, 23, 42, 0.06);
+  align-self: flex-end;
+  border-bottom-right-radius: 4px;
+}
+
+.form {
+  display: flex;
+  gap: 12px;
+  margin-top: 8px;
+}
+
+.input {
+  flex: 1;
+  padding: 14px 16px;
+  border-radius: 12px;
+  border: 1px solid rgba(15, 23, 42, 0.08);
+  font-size: 15px;
+  outline: none;
+  transition: border-color 0.15s ease;
+}
+
+.input:focus {
+  border-color: #0ea5e9;
+  box-shadow: 0 0 0 3px rgba(14, 165, 233, 0.12);
+}
+
+.button {
+  background: linear-gradient(135deg, #0ea5e9, #6366f1);
+  color: white;
+  border: none;
+  border-radius: 12px;
+  padding: 12px 18px;
+  font-weight: 700;
+  cursor: pointer;
+  box-shadow: 0 12px 25px rgba(99, 102, 241, 0.35);
+  min-width: 110px;
+  transition: transform 0.12s ease, box-shadow 0.12s ease, opacity 0.12s ease;
+}
+
+.button:disabled {
+  opacity: 0.6;
+  cursor: not-allowed;
+  box-shadow: none;
+}
+
+.button:not(:disabled):hover {
+  transform: translateY(-1px);
+  box-shadow: 0 16px 30px rgba(99, 102, 241, 0.45);
+}
+
+.status {
+  font-size: 13px;
+  color: #475569;
+  margin-top: 6px;
+}
+
+.pill-row {
+  display: flex;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+
+.pill {
+  padding: 6px 10px;
+  border-radius: 999px;
+  background: rgba(15, 23, 42, 0.06);
+  font-size: 12px;
+  color: #0f172a;
+  border: 1px solid rgba(15, 23, 42, 0.08);
+}
+`);
+    await writeFile(join(webDir, 'app', 'layout.tsx'), `import './globals.css'
+import { ReactNode } from 'react'
+
+export default function RootLayout({ children }: { children: ReactNode }) {
+  return (
+    <html lang="en">
+      <head>
+        <title>Castari Demo Chat</title>
+      </head>
+      <body>{children}</body>
+    </html>
+  )
+}
+`);
+    await writeFile(join(webDir, 'app', 'page.tsx'), `"use client"
+
+import { FormEvent, useState } from 'react'
+
+type ChatMessage = {
+  role: 'assistant' | 'user'
+  content: string
+}
+
+export default function Home() {
+  const [messages, setMessages] = useState<ChatMessage[]>([
+    {
+      role: 'assistant',
+      content:
+        'Hi! I am the Castari demo agent. Ask me anything about your code, architecture, or how this demo works.',
+    },
+  ])
+  const [input, setInput] = useState('')
+  const [status, setStatus] = useState<string | null>(null)
+  const [sending, setSending] = useState(false)
+
+  const sendMessage = async (event: FormEvent) => {
+    event.preventDefault()
+    if (!input.trim() || sending) return
+
+    const userMessage: ChatMessage = { role: 'user', content: input.trim() }
+    setMessages(prev => [...prev, userMessage])
+    setInput('')
+    setSending(true)
+    setStatus('Connecting to your sandbox...')
+
+    // Add assistant placeholder immediately so we can stream into it
+    let assistantIndex = -1
+    setMessages(prev => {
+      assistantIndex = prev.length
+      return [...prev, { role: 'assistant', content: '' }]
+    })
+
+    try {
+      const response = await fetch('/api/chat', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ message: userMessage.content }),
+      })
+
+      if (!response.ok || !response.body) {
+        const errorText = await response.text()
+        throw new Error(errorText || 'Request failed')
+      }
+
+      const reader = response.body.getReader()
+      const decoder = new TextDecoder()
+
+      while (true) {
+        const { value, done } = await reader.read()
+        if (done) break
+        const chunk = decoder.decode(value, { stream: true })
+        if (!chunk) continue
+        const idx = assistantIndex
+        setMessages(prev =>
+          prev.map((m, i) => (i === idx ? { ...m, content: m.content + chunk } : m)),
+        )
+      }
+
+      setStatus(null)
+    } catch (err) {
+      const message =
+        err instanceof Error ? err.message : 'Something went wrong talking to the agent.'
+      setMessages(prev =>
+        prev.map((m, i) =>
+          i === assistantIndex
+            ? { ...m, content: \`I hit an error: \${message}\` }
+            : m,
+        ),
+      )
+      setStatus('Temporary hiccup. Try again in a moment.')
+    } finally {
+      setSending(false)
+    }
+  }
+
+  return (
+    <main className="chat-container">
+      <div className="card">
+        <div className="heading">
+          <span>Castari Demo Chat</span>
+          <span className="badge">Single sandbox</span>
+        </div>
+        <p style={{ margin: '8px 0 16px', color: '#475569' }}>
+          This UI connects to a Castari agent running in a Daytona sandbox. Messages reuse the same
+          sandbox (via labels) so the conversation stays warm while the sandbox is alive.
+        </p>
+
+        <div className="pill-row" style={{ marginBottom: 12 }}>
+          <span className="pill">Snapshot: castari-demo-agent</span>
+          <span className="pill">Volume: castari-demo-workspace</span>
+          <span className="pill">Labels: app=castari-demo, env=local</span>
+        </div>
+
+        <div className="messages">
+          {messages.map((m, idx) => (
+            <div key={idx} className={\`bubble \${m.role}\`}>
+              {m.content}
+            </div>
+          ))}
+        </div>
+
+        <form className="form" onSubmit={sendMessage}>
+          <input
+            className="input"
+            placeholder="Ask the Castari agent anything..."
+            value={input}
+            onChange={e => setInput(e.target.value)}
+          />
+          <button className="button" type="submit" disabled={sending}>
+            {sending ? 'Talking…' : 'Send'}
+          </button>
+        </form>
+        {status && <div className="status">{status}</div>}
+      </div>
+    </main>
+  )
+}
+`);
+    await writeFile(join(webDir, 'lib', 'castari-client.ts'), `import { CastariClient, type WSOutputMessage } from '@castari/sdk/client'
+
+const SNAPSHOT = 'castari-demo-agent'
+const LABELS = { app: 'castari-demo', env: 'local' }
+const VOLUME = 'castari-demo-workspace'
+
+let clientPromise: Promise<CastariClient> | null = null
+
+async function createClient() {
+    const anthropicApiKey = process.env.ANTHROPIC_API_KEY
+    if (!anthropicApiKey) {
+        throw new Error('ANTHROPIC_API_KEY is required to contact the Castari agent')
+    }
+
+    const client = new CastariClient({
+        snapshot: SNAPSHOT,
+        volume: VOLUME,
+        labels: LABELS,
+        platformUrl: process.env.CASTARI_PLATFORM_URL,
+        anthropicApiKey,
+        debug: process.env.CASTARI_DEBUG === 'true',
+    })
+
+    await client.start()
+    return client
+}
+
+async function getClient() {
+    if (!clientPromise) {
+        clientPromise = createClient()
+    }
+    return clientPromise
+}
+
+function extractText(content: unknown): string {
+    if (typeof content === 'string') return content
+    if (Array.isArray(content)) {
+        return content
+            .map(block => {
+                if (typeof block === 'string') return block
+                if (block && typeof block === 'object' && 'text' in block) {
+                    return (block as { text?: string }).text ?? ''
+                }
+                return ''
+            })
+            .join('\\n')
+    }
+    if (content && typeof content === 'object' && 'text' in (content as any)) {
+        return (content as any).text ?? ''
+    }
+    return ''
+}
+
+function extractStreamDelta(event: any): string {
+    if (!event || typeof event !== 'object') return ''
+    if (event.type === 'content_block_delta' && event.delta?.text) {
+        return String(event.delta.text)
+    }
+    if (event.type === 'content_block_start' && event.content_block?.text) {
+        return String(event.content_block.text)
+    }
+    if (event.type === 'message_delta' && event.delta?.text) {
+        return String(event.delta.text)
+    }
+    return ''
+}
+
+export async function streamMessageToAgent(
+    message: string,
+    handlers: {
+        onChunk?: (text: string) => void
+    },
+): Promise<void> {
+    const client = await getClient()
+
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            cleanup()
+            reject(new Error('Timed out waiting for agent response'))
+        }, 60000)
+
+        let sawStreamChunk = false
+
+        const unsubscribe = client.onMessage((msg: WSOutputMessage) => {
+            if (msg.type !== 'sdk_message') return
+            const data: any = msg.data
+
+            if (data.type === 'stream_event') {
+                const deltaText = extractStreamDelta(data.event)
+                if (deltaText) {
+                    sawStreamChunk = true
+                    handlers.onChunk?.(deltaText)
+                }
+            } else if (data.type === 'assistant_message') {
+                finish()
+            } else if (data.type === 'result' && data.subtype === 'success') {
+                if (!sawStreamChunk) {
+                    const text =
+                        typeof data.result === 'string'
+                            ? data.result
+                            : extractText(data.result?.output || data.result?.message || '')
+                    if (text) handlers.onChunk?.(text)
+                }
+                finish()
+            } else if (data.type === 'error') {
+                cleanup()
+                reject(new Error(data.error || 'Agent returned an error'))
+            }
+        })
+
+        const cleanup = () => {
+            clearTimeout(timeout)
+            unsubscribe()
+        }
+
+        const finish = () => {
+            cleanup()
+            resolve()
+        }
+
+        try {
+            client.send({
+                type: 'user_message',
+                data: {
+                    type: 'user',
+                    message: { role: 'user', content: message },
+                } as any,
+            })
+        } catch (err) {
+            cleanup()
+            reject(err)
+        }
+    })
+}
+`);
+    await writeFile(join(webDir, 'app', 'api', 'chat', 'route.ts'), `export const runtime = 'nodejs'
+
+import { streamMessageToAgent } from '@/lib/castari-client'
+
+export async function POST(request: Request) {
+    const body = (await request.json()) as { message?: string }
+    const message = body.message?.trim()
+
+    if (!message) {
+        return new Response(JSON.stringify({ error: 'message is required' }), {
+            status: 400,
+            headers: { 'Content-Type': 'application/json' },
+        })
+    }
+
+    const encoder = new TextEncoder()
+
+    const stream = new ReadableStream({
+        async start(controller) {
+            try {
+                await streamMessageToAgent(message, {
+                    onChunk: text => controller.enqueue(encoder.encode(text)),
+                })
+                controller.close()
+            } catch (err) {
+                controller.error(err)
+            }
+        },
+    })
+
+    return new Response(stream, {
+        headers: {
+            'Content-Type': 'text/plain; charset=utf-8',
+            'Transfer-Encoding': 'chunked',
+        },
+    })
+}
+`);
+    // Demo README
+    await writeFile(join(demoRoot, 'README.md'), `# Castari Demo (Web + Agent)
+
+This demo pairs a minimal Castari agent with a simple Next.js chat UI.
+
+Structure:
+- \`agent/\` – Castari agent you deploy to the platform.
+- \`web/\` – Next.js app that chats with the agent via \`CastariClient\`.
+
+## Prerequisites
+- Bun (for the Castari CLI and scripts)
+- Node 18+ (for the Next.js app)
+- \`ANTHROPIC_API_KEY\`
+- Castari Platform running locally or reachable via \`CASTARI_PLATFORM_URL\`
+
+## 1) Prepare and deploy the agent
+\`\`\`bash
+cd castari_demo/agent
+cp .env.example .env  # add ANTHROPIC_API_KEY (and CASTARI_PLATFORM_URL if self-hosted)
+bun install           # pulls @castari/sdk from npm
+castari deploy        # builds snapshot castari-demo-agent (CLI must be installed)
+# Optional: bun run src/agent.ts   # run locally without the CLI
+\`\`\`
+
+## 2) Run the web app
+\`\`\`bash
+cd ../web
+cp .env.example .env  # add ANTHROPIC_API_KEY and CASTARI_PLATFORM_URL if needed
+npm install           # or bun install
+npm run dev           # opens http://localhost:3000
+\`\`\`
+
+The web app uses a single sandbox labeled \`{ app: 'castari-demo', env: 'local' }\`. That keeps the same sandbox alive across requests so chats stay in memory as long as you don’t delete it (\`stop({ delete: false })\` behavior).
+`);
+    console.log(chalk.green('✅ Demo scaffold created at ./castari_demo'));
+    console.log(chalk.white('Next steps:'));
+    console.log(chalk.white('  1) cd castari_demo/agent && bun install && castari deploy'));
+    console.log(chalk.white('  2) cd ../web && npm install && npm run dev'));
+}

package/dist/commands/start.js

@@ -5,11 +5,6 @@ import dotenv from 'dotenv';
 export async function start(options) {
     // Load .env from current directory
     dotenv.config();
-    const apiKey = process.env.DAYTONA_API_KEY;
-    if (!apiKey) {
-        console.error(chalk.red('Error: DAYTONA_API_KEY is required.'));
-        process.exit(1);
-    }
     // Read package.json for defaults
     let snapshotName = options.snapshot;
     let volumeName = options.volume;
@@ -31,11 +26,13 @@ export async function start(options) {
     if (volumeName) {
         console.log(chalk.blue(`📦 Using volume: ${volumeName}`));
     }
+    const platformUrl = process.env.CASTARI_PLATFORM_URL;
     const client = new CastariClient({
         snapshot: snapshotName,
         volume: volumeName,
-        daytonaApiKey: apiKey,
+        platformUrl,
         debug: true, // Enable debug logs for CLI
+        anthropicApiKey: process.env.ANTHROPIC_API_KEY
     });
     try {
         await client.start();

package/dist/index.js

@@ -7,13 +7,14 @@ import { dev } from './commands/dev';
 const cli = cac('castari');
 cli
     .command('init', 'Initialize a new Castari agent project')
+    .option('--demo', 'Generate a Castari demo (web + agent) scaffold')
     .action(init);
 cli
-    .command('deploy', 'Build and deploy the agent snapshot to Daytona')
+    .command('deploy', 'Deploy the agent to the Castari Platform')
     .option('--snapshot <name>', 'Snapshot name (overrides package.json)')
     .action(deploy);
 cli
-    .command('start', 'Start a Daytona sandbox for the agent')
+    .command('start', 'Start a sandbox for the agent')
     .option('--snapshot <name>', 'Snapshot name')
     .option('--volume <name>', 'Volume name for persistence')
     .option('--id <id>', 'Custom sandbox ID')
@@ -22,5 +23,5 @@ cli
     .command('dev', 'Run the agent locally for development')
     .action(dev);
 cli.help();
-cli.version('0.0.1');
+cli.version('0.0.4');
 cli.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@castari/cli",
-    "version": "0.0.2",
+    "version": "0.0.5",
     "type": "module",
     "bin": {
         "castari": "./dist/index.js"
@@ -17,17 +17,20 @@
         "dev": "bun run src/index.ts"
     },
     "dependencies": {
+        "@anthropic-ai/claude-agent-sdk": "^0.1.44",
+        "@castari/sdk": "^0.0.4",
+        "adm-zip": "^0.5.16",
         "cac": "^6.7.14",
-        "inquirer": "^9.2.12",
         "chalk": "^5.3.0",
         "dotenv": "^16.3.1",
-        "@daytonaio/sdk": "^0.115.2",
-        "@castari/sdk": "^0.0.3",
-        "@anthropic-ai/claude-agent-sdk": "^0.1.44"
+        "form-data": "^4.0.5",
+        "inquirer": "^9.2.12"
     },
     "devDependencies": {
+        "@types/adm-zip": "^0.5.7",
+        "@types/form-data": "^2.5.2",
         "@types/inquirer": "^9.0.7",
         "@types/node": "^20.10.0",
         "typescript": "^5.6.3"
     }
-}
+}