@castari/cli 0.0.4 → 0.0.6

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([
         {
@@ -71,3 +74,620 @@ 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 mkdir(join(webDir, 'lib'), { 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/index.js

@@ -7,6 +7,7 @@ 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', 'Deploy the agent to the Castari Platform')

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@castari/cli",
-    "version": "0.0.4",
+    "version": "0.0.6",
     "type": "module",
     "bin": {
         "castari": "./dist/index.js"