@chatbotkit/cli 1.20.0 → 1.21.1

package/dist/cjs/tools.cjs

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tools = void 0;
+exports.getTools = getTools;
+exports.getToolNames = getToolNames;
+const child_process_1 = require("child_process");
+const promises_1 = require("fs/promises");
+const util_1 = require("util");
+const zod_1 = require("zod");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+exports.tools = {
+    read: {
+        description: 'Read the contents of a file',
+        default: true,
+        input: zod_1.z.object({
+            path: zod_1.z.string().describe('The file path to read'),
+        }),
+        handler: async (input) => {
+            try {
+                const content = await (0, promises_1.readFile)(input.path, 'utf-8');
+                return { success: true, content };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                };
+            }
+        },
+    },
+    write: {
+        description: 'Write content to a file',
+        default: true,
+        input: zod_1.z.object({
+            path: zod_1.z.string().describe('The file path to write to'),
+            content: zod_1.z.string().describe('The content to write'),
+        }),
+        handler: async (input) => {
+            try {
+                await (0, promises_1.writeFile)(input.path, input.content, 'utf-8');
+                return { success: true };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                };
+            }
+        },
+    },
+    edit: {
+        description: 'Edit a file by replacing an exact string occurrence with a new string. Only one occurrence must exist.',
+        default: true,
+        input: zod_1.z.object({
+            path: zod_1.z.string().describe('The file path to edit'),
+            oldString: zod_1.z
+                .string()
+                .describe('The exact string to find and replace (must match exactly)'),
+            newString: zod_1.z.string().describe('The new string to replace with'),
+        }),
+        handler: async (input) => {
+            try {
+                const content = await (0, promises_1.readFile)(input.path, 'utf-8');
+                const occurrences = content.split(input.oldString).length - 1;
+                if (occurrences === 0) {
+                    return {
+                        success: false,
+                        error: 'String not found in file',
+                    };
+                }
+                if (occurrences > 1) {
+                    return {
+                        success: false,
+                        error: `Multiple occurrences found (${occurrences}). The old string must match exactly one location.`,
+                    };
+                }
+                const newContent = content.replace(input.oldString, input.newString);
+                await (0, promises_1.writeFile)(input.path, newContent, 'utf-8');
+                const oldPreview = input.oldString.length > 100
+                    ? input.oldString.substring(0, 100) + '...'
+                    : input.oldString;
+                const newPreview = input.newString.length > 100
+                    ? input.newString.substring(0, 100) + '...'
+                    : input.newString;
+                return {
+                    success: true,
+                    message: `Successfully replaced:\n  OLD: ${oldPreview}\n  NEW: ${newPreview}`,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                };
+            }
+        },
+    },
+    find: {
+        description: 'Search for files matching a pattern',
+        default: true,
+        input: zod_1.z.object({
+            pattern: zod_1.z.string().describe('The glob pattern to search for'),
+            directory: zod_1.z
+                .string()
+                .optional()
+                .describe('The directory to search in (defaults to current)'),
+        }),
+        handler: async (input) => {
+            try {
+                const dir = input.directory || '.';
+                const { stdout } = await execAsync(`find ${dir} -name "${input.pattern}"`);
+                const files = stdout.trim().split('\n').filter(Boolean);
+                return { success: true, files };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                };
+            }
+        },
+    },
+    exec: {
+        description: 'Execute a shell command (non-interactive only). Commands timeout after the specified duration (default 30 seconds). Use only for commands that run and exit automatically.',
+        default: true,
+        input: zod_1.z.object({
+            command: zod_1.z.string().describe('The command to execute'),
+            timeout: zod_1.z
+                .number()
+                .default(30)
+                .describe('Timeout in seconds. The command will be killed if it runs longer than this.'),
+        }),
+        handler: async (input) => {
+            const timeoutMs = input.timeout * 1000;
+            return new Promise((resolve) => {
+                const childProcess = (0, child_process_1.spawn)('sh', ['-c', input.command], {
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                    timeout: timeoutMs,
+                });
+                let stdout = '';
+                let stderr = '';
+                let timedOut = false;
+                childProcess.stdout.on('data', (data) => {
+                    stdout += data.toString();
+                });
+                childProcess.stderr.on('data', (data) => {
+                    stderr += data.toString();
+                });
+                childProcess.on('close', (code) => {
+                    if (timedOut) {
+                        resolve({
+                            success: false,
+                            error: `Command timed out after ${timeoutMs / 1000} seconds. This may indicate an interactive command.`,
+                        });
+                    }
+                    else if (code === 0) {
+                        resolve({ success: true, stdout, stderr });
+                    }
+                    else {
+                        resolve({
+                            success: false,
+                            error: `Command exited with code ${code}`,
+                            stdout,
+                            stderr,
+                        });
+                    }
+                });
+                childProcess.on('error', (error) => {
+                    resolve({
+                        success: false,
+                        error: error.message,
+                    });
+                });
+                setTimeout(() => {
+                    if (!childProcess.killed) {
+                        timedOut = true;
+                        childProcess.kill('SIGTERM');
+                        setTimeout(() => {
+                            if (!childProcess.killed) {
+                                childProcess.kill('SIGKILL');
+                            }
+                        }, 2000);
+                    }
+                }, timeoutMs);
+            });
+        },
+    },
+};
+function getTools(selectedTools) {
+    if (!selectedTools || selectedTools.length === 0) {
+        return Object.fromEntries(Object.entries(exports.tools).filter(([, tool]) => tool.default));
+    }
+    return Object.fromEntries(Object.entries(exports.tools).filter(([name]) => selectedTools.includes(name)));
+}
+function getToolNames() {
+    return Object.keys(exports.tools);
+}

package/dist/cjs/tools.d.ts

@@ -0,0 +1,9 @@
+export function getTools(selectedTools?: Array<keyof typeof tools>): typeof tools;
+export function getToolNames(): Array<keyof typeof tools>;
+export const tools: Record<string, {
+    description: string;
+    input: z.ZodObject<any>;
+    handler: (input: any) => Promise<any>;
+    default?: boolean;
+}>;
+import { z } from 'zod';

package/dist/esm/command/agent/index.d.ts

@@ -0,0 +1,3 @@
+export const command: Command;
+export default command;
+import { Command } from 'commander';

package/dist/esm/command/agent/index.js

@@ -0,0 +1,97 @@
+import { getRUNAS_USERID, getSECRET } from '../../env.js';
+import { print, printError } from '../../output.js';
+import { Spinner } from '../../spinner.js';
+import { getToolNames, getTools } from '../../tools.js';
+import { execute } from '@chatbotkit/agent';
+import { ChatBotKit } from '@chatbotkit/sdk';
+import { Command, Option } from 'commander';
+import { existsSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+function getClient() {
+    return new ChatBotKit({
+        secret: getSECRET(),
+        runAsUserId: getRUNAS_USERID(),
+    });
+}
+export const command = new Command()
+    .name('agent')
+    .description('Run an agent as a background worker with a prompt')
+    .addOption(new Option('-b, --bot <bot>', 'Bot id'))
+    .addOption(new Option('-m, --model <model>', 'Model name'))
+    .addOption(new Option('-p, --prompt <prompt>', 'The prompt to execute (or path to a file containing the prompt)').makeOptionMandatory())
+    .addOption(new Option('-t, --tools <tools...>', 'Specific tools to enable').choices(getToolNames()))
+    .addOption(new Option('-i, --max-iterations <maxIterations>', 'Maximum number of iterations')
+    .default(50)
+    .argParser((value) => parseInt(value, 10)))
+    .action(async (options) => {
+    const client = getClient();
+    const tools = getTools(options.tools);
+    let prompt = options.prompt;
+    {
+        const filePath = resolve(process.cwd(), options.prompt);
+        if (existsSync(filePath)) {
+            try {
+                prompt = readFileSync(filePath, 'utf-8');
+            }
+            catch (error) {
+                printError(error);
+            }
+        }
+    }
+    const isInteractive = process.stdout.isTTY;
+    const spinner = isInteractive ? new Spinner() : null;
+    let exitResult = null;
+    let hasOutput = false;
+    for await (const { type, data } of execute({
+        client,
+        botId: options.bot,
+        model: options.model,
+        messages: [{ type: 'user', text: prompt }],
+        tools,
+        maxIterations: options.maxIterations,
+    })) {
+        if (type === 'iteration') {
+            if (spinner) {
+                if (spinner.isSpinning) {
+                    spinner.stop();
+                }
+                const iterationNum = data.iteration - 1;
+                console.log(`\n╭─ Iteration ${iterationNum} ─╮`);
+                spinner.start();
+            }
+            else {
+                print({ iteration: data.iteration - 1 });
+            }
+            hasOutput = false;
+        }
+        else if (type === 'token') {
+            if (spinner && spinner.isSpinning) {
+                spinner.stop();
+            }
+            if (!hasOutput && isInteractive) {
+                process.stdout.write('> ');
+                hasOutput = true;
+            }
+            process.stdout.write(data.token);
+        }
+        else if (type === 'exit') {
+            exitResult = data;
+        }
+    }
+    if (spinner && spinner.isSpinning) {
+        spinner.stop();
+    }
+    process.stdout.write('\n\n');
+    if (exitResult) {
+        print({
+            status: exitResult.code === 0 ? 'success' : 'failed',
+            exitCode: exitResult.code,
+            ...(exitResult.message && { message: exitResult.message }),
+        });
+        process.exit(exitResult.code);
+    }
+    else {
+        printError(new Error('Task ended without exit signal'));
+    }
+});
+export default command;

package/dist/esm/command/api/conversation/index.d.ts

@@ -1,6 +1,4 @@
 export const conversationList: Command;
-export const conversationFetch: Command;
-export const conversationDelete: Command;
 export const command: Command;
 export default command;
 import { Command } from 'commander';

package/dist/esm/command/api/conversation/index.js

@@ -28,7 +28,7 @@ export const conversationList = new Command()
         }
     }
 });
-export const conversationFetch = new Command()
+const conversationFetch = new Command()
     .name('fetch')
     .description('Fetch conversation')
     .argument('<conversationId>', 'Conversation ID')
@@ -37,7 +37,7 @@ export const conversationFetch = new Command()
     const conversation = await client.fetch(conversationId);
     print(conversation);
 });
-export const conversationDelete = new Command()
+const conversationDelete = new Command()
     .name('delete')
     .description('Delete conversation')
     .argument('<conversationId>', 'Conversation ID')
@@ -45,11 +45,16 @@ export const conversationDelete = new Command()
     const client = getClient();
     await client.delete(conversationId);
 });
+const commands = {
+    list: conversationList,
+    fetch: conversationFetch,
+    delete: conversationDelete,
+    message,
+};
 export const command = new Command()
     .name('conversation')
-    .description('Conversation tools for ChatBotKit')
-    .addCommand(conversationList)
-    .addCommand(conversationFetch)
-    .addCommand(conversationDelete)
-    .addCommand(message);
+    .description('Conversation tools for ChatBotKit');
+for (const cmd of Object.values(commands)) {
+    command.addCommand(cmd);
+}
 export default command;

package/dist/esm/command/api/conversation/message/index.js

@@ -47,10 +47,15 @@ export const messageDelete = new Command()
     const client = getClient();
     await client.delete(conversationId, messageId);
 });
+const commands = {
+    list: messageList,
+    fetch: messageFetch,
+    delete: messageDelete,
+};
 export const command = new Command()
     .name('message')
-    .description('Message tools for ChatBotKit')
-    .addCommand(messageList)
-    .addCommand(messageFetch)
-    .addCommand(messageDelete);
+    .description('Message tools for ChatBotKit');
+for (const cmd of Object.values(commands)) {
+    command.addCommand(cmd);
+}
 export default command;

package/dist/esm/command/api/dataset/index.js

@@ -44,10 +44,15 @@ export const datasetDelete = new Command()
     const client = getClient();
     await client.delete(datasetId);
 });
+const commands = {
+    list: datasetList,
+    fetch: datasetFetch,
+    delete: datasetDelete,
+};
 export const command = new Command()
     .name('dataset')
-    .description('Dataset tools for ChatBotKit')
-    .addCommand(datasetList)
-    .addCommand(datasetFetch)
-    .addCommand(datasetDelete);
+    .description('Dataset tools for ChatBotKit');
+for (const cmd of Object.values(commands)) {
+    command.addCommand(cmd);
+}
 export default command;

package/dist/esm/command/api/index.d.ts

@@ -1,3 +1,4 @@
 export const command: Command;
 export default command;
+export type ChatBotKitSDK = import("@chatbotkit/sdk").ChatBotKit;
 import { Command } from 'commander';

package/dist/esm/command/api/index.js

@@ -4,13 +4,18 @@ import dataset from './dataset/index.js';
 import partner from './partner/index.js';
 import skillset from './skillset/index.js';
 import { Command, Option } from 'commander';
+const commands = {
+    conversation,
+    dataset,
+    skillset,
+    partner,
+};
 export const command = new Command()
     .name('api')
-    .description('API tools for ChatBotKit')
-    .addCommand(dataset)
-    .addCommand(skillset)
-    .addCommand(conversation)
-    .addCommand(partner);
+    .description('API tools for ChatBotKit');
+for (const cmd of Object.values(commands)) {
+    command.addCommand(cmd);
+}
 command
     .addOption(new Option('-o, --output <format>', 'Output format').choices([
     'yaml',

package/dist/esm/command/api/partner/index.js

@@ -1,7 +1,12 @@
 import user from './user/index.js';
 import { Command } from 'commander';
+const commands = {
+    user,
+};
 export const command = new Command()
     .name('partner')
-    .description('Partner tools for ChatBotKit')
-    .addCommand(user);
+    .description('Partner tools for ChatBotKit');
+for (const cmd of Object.values(commands)) {
+    command.addCommand(cmd);
+}
 export default command;

package/dist/esm/command/api/partner/user/index.js

@@ -44,10 +44,15 @@ export const userDelete = new Command()
     const client = getClient();
     await client.delete(userId);
 });
+const commands = {
+    list: userList,
+    fetch: userFetch,
+    delete: userDelete,
+};
 export const command = new Command()
     .name('user')
-    .description('User tools for ChatBotKit')
-    .addCommand(userList)
-    .addCommand(userFetch)
-    .addCommand(userDelete);
+    .description('User tools for ChatBotKit');
+for (const cmd of Object.values(commands)) {
+    command.addCommand(cmd);
+}
 export default command;

package/dist/esm/command/api/skillset/index.js

@@ -44,10 +44,15 @@ export const skillsetDelete = new Command()
     const client = getClient();
     await client.delete(skillsetId);
 });
+const commands = {
+    list: skillsetList,
+    fetch: skillsetFetch,
+    delete: skillsetDelete,
+};
 export const command = new Command()
     .name('skillset')
-    .description('Skillset tools for ChatBotKit')
-    .addCommand(skillsetList)
-    .addCommand(skillsetFetch)
-    .addCommand(skillsetDelete);
+    .description('Skillset tools for ChatBotKit');
+for (const cmd of Object.values(commands)) {
+    command.addCommand(cmd);
+}
 export default command;

package/dist/esm/command/chat/index.js

@@ -1,9 +1,12 @@
 import { getRUNAS_USERID, getSECRET } from '../../env.js';
-import { ConversationClient } from '@chatbotkit/sdk/conversation/index.js';
+import { Spinner } from '../../spinner.js';
+import { getToolNames, getTools } from '../../tools.js';
+import { complete } from '@chatbotkit/agent';
+import { ChatBotKit } from '@chatbotkit/sdk';
 import { Command, Option } from 'commander';
 import readline from 'readline/promises';
 function getClient() {
-    return new ConversationClient({
+    return new ChatBotKit({
         secret: getSECRET(),
         runAsUserId: getRUNAS_USERID(),
     });
@@ -11,28 +14,50 @@ function getClient() {
 export const command = new Command()
     .name('chat')
     .description('Start a chat session')
-    .addOption(new Option('-m, --model <model>', 'Model name').default('gpt-4'))
-    .action(async (_arg, options) => {
+    .addOption(new Option('-b, --bot <bot>', 'Bot id'))
+    .addOption(new Option('-m, --model <model>', 'Model name'))
+    .addOption(new Option('-t, --tools <tools...>', 'Specific tools to enable').choices(getToolNames()))
+    .action(async (options) => {
     const client = getClient();
     const rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
     });
     const messages = [];
+    const tools = getTools(options.tools);
+    const colors = {
+        reset: '\x1b[0m',
+        bold: '\x1b[1m',
+        cyan: '\x1b[36m',
+        green: '\x1b[32m',
+    };
     for (;;) {
-        const user = await rl.question('user: ');
+        process.stdout.write('\n');
+        const user = await rl.question(`${colors.cyan}●${colors.reset} ${colors.bold}You${colors.reset}\n\n> `);
         messages.push({ type: 'user', text: user });
-        process.stdout.write('bot: ');
-        for await (const { type, data } of client
-            .complete(null, { model: options.model, messages })
-            .stream()) {
+        process.stdout.write(`\n${colors.green}●${colors.reset} ${colors.bold}Assistant${colors.reset}\n\n  `);
+        const spinner = new Spinner('');
+        spinner.start();
+        let firstToken = true;
+        for await (const { type, data } of complete({
+            client,
+            botId: options.bot,
+            model: options.model,
+            messages,
+            tools,
+        })) {
             if (type === 'token') {
+                if (firstToken) {
+                    spinner.stop();
+                    firstToken = false;
+                }
                 process.stdout.write(data.token);
             }
             else if (type === 'result') {
                 messages.push({ type: 'bot', text: data.text });
             }
         }
+        spinner.stop();
         process.stdout.write('\n');
     }
 });

package/dist/esm/index.js

@@ -1,3 +1,4 @@
+import agent from './command/agent/index.js';
 import command from './command/api/index.js';
 import chat from './command/chat/index.js';
 import solution from './command/solution/index.js';
@@ -6,6 +7,7 @@ export default async function cbk(argv = process.argv) {
     const program = new Command();
     program.name('cbk').description('Command line tools for ChatBotKit');
     program.addCommand(command);
+    program.addCommand(agent);
     program.addCommand(chat);
     program.addCommand(solution);
     program.parse(argv);

package/dist/esm/output.js

@@ -26,10 +26,14 @@ export function print(input) {
     }
 }
 export function printError(error) {
+    if (error?.code === 'ABORT_ERR' || error?.name === 'AbortError') {
+        process.exit(130);
+    }
     if (error instanceof CommandError) {
         console.error(error.message);
     }
     else {
         console.error(error);
     }
+    process.exit(1);
 }

package/dist/esm/spinner.d.ts

@@ -0,0 +1,15 @@
+export class Spinner {
+    constructor(text?: string, options?: {
+        frames?: string[] | undefined;
+        interval?: number | undefined;
+    });
+    text: string;
+    frames: string[];
+    interval: number;
+    frameIndex: number;
+    intervalId: NodeJS.Timeout | null;
+    isSpinning: boolean;
+    start(): void;
+    stop(keepText?: boolean): void;
+    setText(text: string): void;
+}

package/dist/esm/spinner.js

@@ -0,0 +1,52 @@
+export class Spinner {
+    constructor(text = '', options = {}) {
+        this.text = text;
+        this.frames = options.frames || [
+            '⠋',
+            '⠙',
+            '⠹',
+            '⠸',
+            '⠼',
+            '⠴',
+            '⠦',
+            '⠧',
+            '⠇',
+            '⠏',
+        ];
+        this.interval = options.interval || 80;
+        this.frameIndex = 0;
+        this.intervalId = null;
+        this.isSpinning = false;
+    }
+    start() {
+        if (this.isSpinning) {
+            return;
+        }
+        this.isSpinning = true;
+        this.frameIndex = 0;
+        this.intervalId = setInterval(() => {
+            const frame = this.frames[this.frameIndex];
+            process.stdout.write(`\r${this.text}${frame} `);
+            this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+        }, this.interval);
+    }
+    stop(keepText = true) {
+        if (!this.isSpinning) {
+            return;
+        }
+        this.isSpinning = false;
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        if (keepText) {
+            process.stdout.write(`\r${this.text}`);
+        }
+        else {
+            process.stdout.write('\r' + ' '.repeat(this.text.length + 2) + '\r');
+        }
+    }
+    setText(text) {
+        this.text = text;
+    }
+}

package/dist/esm/tools.d.ts

@@ -0,0 +1,9 @@
+export function getTools(selectedTools?: Array<keyof typeof tools>): typeof tools;
+export function getToolNames(): Array<keyof typeof tools>;
+export const tools: Record<string, {
+    description: string;
+    input: z.ZodObject<any>;
+    handler: (input: any) => Promise<any>;
+    default?: boolean;
+}>;
+import { z } from 'zod';