@castari/cli 0.0.1

package/dist/commands/deploy.d.ts

@@ -0,0 +1,3 @@
+export declare function deploy(options: {
+    snapshot?: string;
+}): Promise<void>;

package/dist/commands/deploy.js

@@ -0,0 +1,64 @@
+import { Daytona, Image } from '@daytonaio/sdk';
+import { readFile } from 'fs/promises';
+import chalk from 'chalk';
+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) {
+        try {
+            const pkg = JSON.parse(await readFile('package.json', 'utf-8'));
+            snapshotName = pkg.name;
+        }
+        catch (e) {
+            console.warn(chalk.yellow('Warning: Could not read package.json. Using default name.'));
+            snapshotName = 'castari-agent';
+        }
+    }
+    if (!snapshotName) {
+        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,
+    });
+    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']);
+    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);
+            },
+        });
+        console.log(chalk.green(`✅ Snapshot "${snapshotName}" created successfully!`));
+    }
+    catch (err) {
+        console.error(chalk.red('Snapshot build failed:'), err.message || err);
+        process.exit(1);
+    }
+}

package/dist/commands/dev.d.ts

@@ -0,0 +1 @@
+export declare function dev(): Promise<void>;

package/dist/commands/dev.js

@@ -0,0 +1,17 @@
+import { pathToFileURL } from 'url';
+import { join } from 'path';
+import chalk from 'chalk';
+export async function dev() {
+    console.log(chalk.blue('🛠️  Starting local development server...'));
+    try {
+        const agentPath = join(process.cwd(), 'src', 'agent.ts');
+        // Dynamic import of the agent file. 
+        // Since the agent file calls `serve()`, this will start the server.
+        await import(pathToFileURL(agentPath).href);
+    }
+    catch (err) {
+        console.error(chalk.red('Failed to start local agent:'), err.message || err);
+        console.log(chalk.white('Make sure src/agent.ts exists and exports/calls serve().'));
+        process.exit(1);
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function init(): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,73 @@
+import inquirer from 'inquirer';
+import { writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import chalk from 'chalk';
+export async function init() {
+    console.log(chalk.blue('🤖 Initializing new Castari agent project...'));
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Agent name (used for snapshot):',
+            default: 'my-castari-agent',
+        },
+    ]);
+    const packageJson = {
+        name: answers.name,
+        version: '0.1.0',
+        type: 'module',
+        scripts: {
+            dev: 'castari dev',
+            deploy: 'castari deploy',
+            start: 'castari start',
+        },
+        dependencies: {
+            '@castari/sdk': 'workspace:*',
+            '@anthropic-ai/claude-agent-sdk': '^0.1.44',
+        },
+        castari: {
+            volume: 'default-data',
+        },
+    };
+    const tsConfig = {
+        compilerOptions: {
+            target: 'ESNext',
+            module: 'ESNext',
+            moduleResolution: 'bundler',
+            strict: true,
+            skipLibCheck: true,
+        },
+    };
+    const agentTs = `import { serve } from '@castari/sdk/server'
+import { tool } from '@castari/sdk'
+
+// Define your agent tools and logic here
+const myTool = tool({
+  name: 'hello',
+  description: 'Say hello',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      name: { type: 'string' },
+    },
+  },
+  handler: async ({ name }) => {
+    return \`Hello, \${name}!\`
+  },
+})
+
+// Start the agent server
+serve({
+  tools: [myTool],
+  systemPrompt: 'You are a helpful Castari agent.',
+})
+`;
+    const envExample = `ANTHROPIC_API_KEY=sk-ant-...\nDAYTONA_API_KEY=...\n`;
+    await writeFile('package.json', JSON.stringify(packageJson, null, 2));
+    await writeFile('tsconfig.json', JSON.stringify(tsConfig, null, 2));
+    await writeFile('.env.example', envExample);
+    await mkdir('src', { recursive: true });
+    await writeFile(join('src', 'agent.ts'), agentTs);
+    console.log(chalk.green('✅ Project initialized!'));
+    console.log(chalk.white('Run `bun install` to install dependencies.'));
+}

package/dist/commands/start.d.ts

@@ -0,0 +1,5 @@
+export declare function start(options: {
+    snapshot?: string;
+    volume?: string;
+    id?: string;
+}): Promise<void>;

package/dist/commands/start.js

@@ -0,0 +1,86 @@
+import { CastariClient } from '@castari/sdk/client';
+import { readFile } from 'fs/promises';
+import chalk from 'chalk';
+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;
+    try {
+        const pkg = JSON.parse(await readFile('package.json', 'utf-8'));
+        if (!snapshotName)
+            snapshotName = pkg.name;
+        if (!volumeName)
+            volumeName = pkg.castari?.volume;
+    }
+    catch (e) {
+        // Ignore if package.json missing
+    }
+    if (!snapshotName) {
+        console.error(chalk.red('Error: Snapshot name is required.'));
+        process.exit(1);
+    }
+    console.log(chalk.blue(`🚀 Starting agent "${snapshotName}"...`));
+    if (volumeName) {
+        console.log(chalk.blue(`📦 Using volume: ${volumeName}`));
+    }
+    const client = new CastariClient({
+        snapshot: snapshotName,
+        volume: volumeName,
+        daytonaApiKey: apiKey,
+        debug: true, // Enable debug logs for CLI
+    });
+    try {
+        await client.start();
+        console.log(chalk.green('✅ Agent started!'));
+        console.log(chalk.cyan('Type a message to chat with the agent (Ctrl+C to exit):'));
+        const stdin = process.stdin;
+        stdin.addListener('data', (d) => {
+            const input = d.toString().trim();
+            if (input) {
+                client.send({
+                    type: 'user_message',
+                    data: {
+                        type: 'user',
+                        message: {
+                            role: 'user',
+                            content: input
+                        }
+                    }
+                });
+            }
+        });
+        client.onMessage((msg) => {
+            if (msg.type === 'sdk_message') {
+                const data = msg.data;
+                if (data.type === 'assistant_message') {
+                    // Handle text content
+                    if (typeof data.message.content === 'string') {
+                        console.log(chalk.green('Agent:'), data.message.content);
+                    }
+                    else if (Array.isArray(data.message.content)) {
+                        data.message.content.forEach((block) => {
+                            if (block.type === 'text') {
+                                console.log(chalk.green('Agent:'), block.text);
+                            }
+                        });
+                    }
+                }
+            }
+            else if (msg.type === 'error') {
+                console.error(chalk.red('Error:'), msg.error);
+            }
+        });
+    }
+    catch (err) {
+        console.error(chalk.red('Failed to start agent:'), err.message || err);
+        process.exit(1);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/index.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env bun
+import { cac } from 'cac';
+import { init } from './commands/init';
+import { deploy } from './commands/deploy';
+import { start } from './commands/start';
+import { dev } from './commands/dev';
+const cli = cac('castari');
+cli
+    .command('init', 'Initialize a new Castari agent project')
+    .action(init);
+cli
+    .command('deploy', 'Build and deploy the agent snapshot to Daytona')
+    .option('--snapshot <name>', 'Snapshot name (overrides package.json)')
+    .action(deploy);
+cli
+    .command('start', 'Start a Daytona sandbox for the agent')
+    .option('--snapshot <name>', 'Snapshot name')
+    .option('--volume <name>', 'Volume name for persistence')
+    .option('--id <id>', 'Custom sandbox ID')
+    .action(start);
+cli
+    .command('dev', 'Run the agent locally for development')
+    .action(dev);
+cli.help();
+cli.version('0.0.1');
+cli.parse();

package/package.json

@@ -0,0 +1,33 @@
+{
+    "name": "@castari/cli",
+    "version": "0.0.1",
+    "type": "module",
+    "bin": {
+        "castari": "./dist/index.js"
+    },
+    "files": [
+        "dist"
+    ],
+    "license": "UNLICENSED",
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "build": "tsc",
+        "dev": "bun run src/index.ts"
+    },
+    "dependencies": {
+        "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.1",
+        "@anthropic-ai/claude-agent-sdk": "^0.1.44"
+    },
+    "devDependencies": {
+        "@types/inquirer": "^9.0.7",
+        "@types/node": "^20.10.0",
+        "typescript": "^5.6.3"
+    }
+}