@kernel.chat/kbot 3.99.31 → 3.99.34

package/dist/cli.js

@@ -156,6 +156,87 @@ async function main() {
         printInfo('  kbot ide mcp    — VS Code, Cursor, Windsurf, Zed, Neovim');
         printInfo('  kbot ide acp    — IntelliJ, WebStorm, PyCharm, GoLand, Android Studio');
     });
+    // ── one-shot editor installers (Harrison-class onboarding) ──────────────
+    // Wires kbot's MCP servers into editor settings.json + (Claude Code only)
+    // copies the kbot skill into the project. Idempotent. No manual JSON edits.
+    const printSetupResult = (label, r) => {
+        printSuccess(`${label}: ${r.configPath}`);
+        if (r.mcpAdded.length > 0)
+            printInfo(`  + added MCP servers: ${r.mcpAdded.join(', ')}`);
+        if (r.mcpAlreadyPresent.length > 0)
+            printInfo(`  · already present: ${r.mcpAlreadyPresent.join(', ')}`);
+        if (r.skillCopied)
+            printInfo(`  + skill copied: ${r.skillCopied}`);
+        if (r.skillAlreadyPresent)
+            printWarn(`  · skill exists (use --force to overwrite): ${r.skillAlreadyPresent}`);
+    };
+    program
+        .command('setup-claude-code')
+        .description('Wire kbot into Claude Code (~/.claude/settings.json) + copy skill into project')
+        .option('-f, --force', 'Overwrite existing project skill if present')
+        .action(async (opts) => {
+        const { setupClaudeCode } = await import('./setup-editor.js');
+        try {
+            const r = setupClaudeCode({ force: opts.force });
+            printSetupResult('Claude Code', r);
+        }
+        catch (e) {
+            printError(`setup-claude-code failed: ${e instanceof Error ? e.message : String(e)}`);
+            process.exitCode = 1;
+        }
+    });
+    program
+        .command('setup-cursor')
+        .description('Wire kbot into Cursor settings.json (mcp.servers)')
+        .option('-f, --force', 'Reserved for parity (Cursor has no skill copy step)')
+        .action(async (opts) => {
+        const { setupCursor } = await import('./setup-editor.js');
+        try {
+            const r = setupCursor({ force: opts.force });
+            printSetupResult('Cursor', r);
+        }
+        catch (e) {
+            printError(`setup-cursor failed: ${e instanceof Error ? e.message : String(e)}`);
+            process.exitCode = 1;
+        }
+    });
+    program
+        .command('setup-zed')
+        .description('Wire kbot into Zed settings.json (assistant.mcpServers — best-effort shape)')
+        .option('-f, --force', 'Reserved for parity')
+        .action(async (opts) => {
+        const { setupZed } = await import('./setup-editor.js');
+        try {
+            const r = setupZed({ force: opts.force });
+            printSetupResult('Zed', r);
+        }
+        catch (e) {
+            printError(`setup-zed failed: ${e instanceof Error ? e.message : String(e)}`);
+            process.exitCode = 1;
+        }
+    });
+    program
+        .command('setup-all')
+        .description('Run setup-claude-code, setup-cursor, and setup-zed in one shot')
+        .option('-f, --force', 'Overwrite existing project skill if present')
+        .action(async (opts) => {
+        const { setupClaudeCode, setupCursor, setupZed } = await import('./setup-editor.js');
+        let failed = 0;
+        const run = (label, fn) => {
+            try {
+                printSetupResult(label, fn());
+            }
+            catch (e) {
+                failed++;
+                printError(`${label} failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        };
+        run('Claude Code', () => setupClaudeCode({ force: opts.force }));
+        run('Cursor', () => setupCursor({ force: opts.force }));
+        run('Zed', () => setupZed({ force: opts.force }));
+        if (failed > 0)
+            process.exitCode = 1;
+    });
     program
         .command('byok')
         .description('Bring Your Own Key — configure your LLM API key (20 providers)')

package/dist/computer-use-coordinator.d.ts

@@ -0,0 +1,44 @@
+export interface AgentRegistration {
+    apps: string[];
+    windowIds?: string[];
+}
+export interface LockRecord {
+    agentId: string;
+    pid: number;
+    ts: number;
+    windowIds?: string[];
+}
+export interface ClaimResult {
+    granted: boolean;
+    app: string;
+    heldBy?: string;
+    since?: number;
+}
+export interface CoordinatorStatus {
+    apps: Record<string, {
+        heldBy: string;
+        since: number;
+    } | null>;
+    agents: Array<{
+        id: string;
+        apps: string[];
+        claimed: string[];
+    }>;
+}
+export declare class Coordinator {
+    private root;
+    private agents;
+    /** in-memory mirror of which apps this coordinator instance has claimed */
+    private claimed;
+    constructor(root?: string);
+    private lockPath;
+    private readLock;
+    private isStale;
+    register(agentId: string, reg: AgentRegistration): void;
+    claim(agentId: string, app: string): ClaimResult;
+    release(agentId: string, app: string): boolean;
+    unregister(agentId: string): string[];
+    status(): CoordinatorStatus;
+}
+export declare function createCoordinator(root?: string): Coordinator;
+//# sourceMappingURL=computer-use-coordinator.d.ts.map

package/dist/file-library.d.ts

@@ -0,0 +1,76 @@
+/**
+ * File Library — local-first per-user file store.
+ *
+ * Mirrors ChatGPT's File Library: auto-saves uploaded and created files,
+ * lists, searches by name/content, fetches by id. Content-addressed (sha256).
+ *
+ * Storage layout:
+ *   <root>/index.json           — atomic JSON index of entries
+ *   <root>/blobs/<id>           — raw file bytes (id = sha256 of contents)
+ *
+ * Default root: ~/.kbot/files (overridable via KBOT_FILE_LIBRARY_ROOT or ctor opt).
+ */
+export declare const MAX_FILE_BYTES: number;
+export type FileSource = "user-upload" | "agent-output" | "tool-output";
+export interface FileEntry {
+    id: string;
+    name: string;
+    mimeType: string;
+    size: number;
+    createdAt: string;
+    source: FileSource;
+    tags: string[];
+    path: string;
+}
+export interface AddFileInput {
+    name: string;
+    mimeType: string;
+    source: FileSource;
+    content?: string;
+    buffer?: Buffer;
+    tags?: string[];
+}
+export interface ListOptions {
+    limit?: number;
+    since?: string | Date;
+    tag?: string;
+}
+export type SearchMode = "name" | "content" | "both";
+export interface SearchOptions {
+    query: string;
+    mode: SearchMode;
+}
+export interface FileLibraryOptions {
+    root?: string;
+}
+export declare class FileLibrary {
+    private readonly root;
+    private readonly blobsDir;
+    private readonly indexPath;
+    private writeLock;
+    constructor(opts?: FileLibraryOptions);
+    getRoot(): string;
+    private ensureDirs;
+    private readIndex;
+    /**
+     * Atomic write: serialize → write to <indexPath>.tmp.<rand> → rename.
+     */
+    private writeIndexAtomic;
+    /**
+     * Run a read-modify-write of the index under the writeLock so concurrent
+     * mutations don't lose updates. The mutator may return a fresh IndexFile
+     * (or undefined to skip the write).
+     */
+    private mutateIndex;
+    addFile(input: AddFileInput): Promise<FileEntry>;
+    listFiles(opts?: ListOptions): Promise<FileEntry[]>;
+    getFile(id: string): Promise<{
+        entry: FileEntry;
+        buffer: Buffer;
+    } | null>;
+    removeFile(id: string): Promise<boolean>;
+    searchFiles(opts: SearchOptions): Promise<FileEntry[]>;
+}
+export declare function getDefaultFileLibrary(): FileLibrary;
+export declare function _resetDefaultFileLibrary(): void;
+//# sourceMappingURL=file-library.d.ts.map

package/dist/file-library.js

@@ -0,0 +1,269 @@
+/**
+ * File Library — local-first per-user file store.
+ *
+ * Mirrors ChatGPT's File Library: auto-saves uploaded and created files,
+ * lists, searches by name/content, fetches by id. Content-addressed (sha256).
+ *
+ * Storage layout:
+ *   <root>/index.json           — atomic JSON index of entries
+ *   <root>/blobs/<id>           — raw file bytes (id = sha256 of contents)
+ *
+ * Default root: ~/.kbot/files (overridable via KBOT_FILE_LIBRARY_ROOT or ctor opt).
+ */
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+export const MAX_FILE_BYTES = 50 * 1024 * 1024; // 50 MB
+const TEXT_MIME_PREFIXES = ["text/"];
+const TEXT_MIME_EXACT = new Set([
+    "application/json",
+    "application/yaml",
+    "application/x-yaml",
+    "application/xml",
+    "application/javascript",
+    "application/typescript",
+]);
+function isTextMime(mimeType) {
+    const m = mimeType.toLowerCase();
+    if (TEXT_MIME_EXACT.has(m))
+        return true;
+    return TEXT_MIME_PREFIXES.some((p) => m.startsWith(p));
+}
+function defaultRoot() {
+    const env = process.env.KBOT_FILE_LIBRARY_ROOT;
+    if (env && env.length > 0)
+        return env;
+    return path.join(os.homedir(), ".kbot", "files");
+}
+export class FileLibrary {
+    root;
+    blobsDir;
+    indexPath;
+    writeLock = Promise.resolve();
+    constructor(opts = {}) {
+        this.root = opts.root ?? defaultRoot();
+        this.blobsDir = path.join(this.root, "blobs");
+        this.indexPath = path.join(this.root, "index.json");
+    }
+    getRoot() {
+        return this.root;
+    }
+    async ensureDirs() {
+        await fs.mkdir(this.blobsDir, { recursive: true });
+    }
+    async readIndex() {
+        try {
+            const raw = await fs.readFile(this.indexPath, "utf8");
+            const parsed = JSON.parse(raw);
+            if (!parsed || parsed.version !== 1 || !Array.isArray(parsed.entries)) {
+                return { version: 1, entries: [] };
+            }
+            return parsed;
+        }
+        catch (err) {
+            const e = err;
+            if (e.code === "ENOENT")
+                return { version: 1, entries: [] };
+            throw err;
+        }
+    }
+    /**
+     * Atomic write: serialize → write to <indexPath>.tmp.<rand> → rename.
+     */
+    async writeIndexAtomic(idx) {
+        await this.ensureDirs();
+        const tmp = `${this.indexPath}.tmp.${process.pid}.${Date.now()}.${Math.random()
+            .toString(36)
+            .slice(2, 10)}`;
+        const data = JSON.stringify(idx, null, 2);
+        await fs.writeFile(tmp, data, { encoding: "utf8" });
+        await fs.rename(tmp, this.indexPath);
+    }
+    /**
+     * Run a read-modify-write of the index under the writeLock so concurrent
+     * mutations don't lose updates. The mutator may return a fresh IndexFile
+     * (or undefined to skip the write).
+     */
+    async mutateIndex(fn) {
+        const run = async () => {
+            const idx = await this.readIndex();
+            const out = await fn(idx);
+            if (out.next)
+                await this.writeIndexAtomic(out.next);
+            return out.result;
+        };
+        const next = this.writeLock.then(run, run);
+        // Don't poison the lock chain on error.
+        this.writeLock = next.then(() => undefined, () => undefined);
+        return next;
+    }
+    async addFile(input) {
+        if (!input.name || input.name.trim().length === 0) {
+            throw new Error("file-library: name is required");
+        }
+        if (!input.mimeType) {
+            throw new Error("file-library: mimeType is required");
+        }
+        if (input.content === undefined && input.buffer === undefined) {
+            throw new Error("file-library: provide content or buffer");
+        }
+        if (input.content !== undefined && input.buffer !== undefined) {
+            throw new Error("file-library: provide content OR buffer, not both");
+        }
+        const buf = input.buffer !== undefined
+            ? input.buffer
+            : Buffer.from(input.content, "utf8");
+        if (buf.byteLength > MAX_FILE_BYTES) {
+            throw new Error(`file-library: file exceeds 50 MB cap (${buf.byteLength} bytes > ${MAX_FILE_BYTES})`);
+        }
+        const id = createHash("sha256").update(buf).digest("hex");
+        await this.ensureDirs();
+        const blobPath = path.join(this.blobsDir, id);
+        // Write blob if not already present (content-addressed dedup).
+        try {
+            await fs.access(blobPath);
+        }
+        catch {
+            const tmp = `${blobPath}.tmp.${process.pid}.${Date.now()}`;
+            await fs.writeFile(tmp, buf);
+            await fs.rename(tmp, blobPath);
+        }
+        const entry = {
+            id,
+            name: input.name,
+            mimeType: input.mimeType,
+            size: buf.byteLength,
+            createdAt: new Date().toISOString(),
+            source: input.source,
+            tags: [...(input.tags ?? [])],
+            path: blobPath,
+        };
+        return this.mutateIndex((idx) => {
+            // If an entry with this id already exists, replace it (latest metadata wins,
+            // since the blob bytes are identical by id).
+            const filtered = idx.entries.filter((e) => e.id !== id);
+            filtered.push(entry);
+            return { next: { version: 1, entries: filtered }, result: entry };
+        });
+    }
+    async listFiles(opts = {}) {
+        const idx = await this.readIndex();
+        let entries = idx.entries.slice();
+        if (opts.tag) {
+            const tag = opts.tag;
+            entries = entries.filter((e) => e.tags.includes(tag));
+        }
+        if (opts.since !== undefined) {
+            const sinceMs = opts.since instanceof Date
+                ? opts.since.getTime()
+                : new Date(opts.since).getTime();
+            if (!Number.isNaN(sinceMs)) {
+                entries = entries.filter((e) => new Date(e.createdAt).getTime() >= sinceMs);
+            }
+        }
+        // Newest first.
+        entries.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+        if (typeof opts.limit === "number" && opts.limit >= 0) {
+            entries = entries.slice(0, opts.limit);
+        }
+        return entries;
+    }
+    async getFile(id) {
+        const idx = await this.readIndex();
+        const entry = idx.entries.find((e) => e.id === id);
+        if (!entry)
+            return null;
+        try {
+            const buffer = await fs.readFile(entry.path);
+            return { entry, buffer };
+        }
+        catch (err) {
+            const e = err;
+            if (e.code === "ENOENT")
+                return null;
+            throw err;
+        }
+    }
+    async removeFile(id) {
+        const removedEntry = await this.mutateIndex((idx) => {
+            const entry = idx.entries.find((e) => e.id === id);
+            if (!entry)
+                return { result: null };
+            const remaining = idx.entries.filter((e) => e.id !== id);
+            return {
+                next: { version: 1, entries: remaining },
+                result: entry,
+            };
+        });
+        if (!removedEntry)
+            return false;
+        try {
+            await fs.unlink(removedEntry.path);
+        }
+        catch (err) {
+            const e = err;
+            if (e.code !== "ENOENT")
+                throw err;
+        }
+        return true;
+    }
+    async searchFiles(opts) {
+        const q = (opts.query ?? "").toLowerCase();
+        if (q.length === 0)
+            return [];
+        const idx = await this.readIndex();
+        const entries = idx.entries;
+        const matchName = (e) => e.name.toLowerCase().includes(q);
+        const matchContent = async (e) => {
+            if (!isTextMime(e.mimeType))
+                return false;
+            try {
+                const buf = await fs.readFile(e.path);
+                return buf.toString("utf8").toLowerCase().includes(q);
+            }
+            catch (err) {
+                const ne = err;
+                if (ne.code === "ENOENT")
+                    return false;
+                throw err;
+            }
+        };
+        const seen = new Set();
+        const out = [];
+        if (opts.mode === "name" || opts.mode === "both") {
+            for (const e of entries) {
+                if (matchName(e) && !seen.has(e.id)) {
+                    seen.add(e.id);
+                    out.push(e);
+                }
+            }
+        }
+        if (opts.mode === "content" || opts.mode === "both") {
+            for (const e of entries) {
+                if (seen.has(e.id))
+                    continue;
+                // eslint-disable-next-line no-await-in-loop
+                const hit = await matchContent(e);
+                if (hit) {
+                    seen.add(e.id);
+                    out.push(e);
+                }
+            }
+        }
+        out.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+        return out;
+    }
+}
+// Singleton helper for default root usage.
+let _default = null;
+export function getDefaultFileLibrary() {
+    if (!_default)
+        _default = new FileLibrary();
+    return _default;
+}
+// Reset the cached default — primarily for tests that mutate env.
+export function _resetDefaultFileLibrary() {
+    _default = null;
+}
+//# sourceMappingURL=file-library.js.map

package/dist/ide/mcp-server.js

@@ -54,7 +54,7 @@ export async function startMcpServer(config = {}) {
         const staticTools = [
             {
                 name: 'kbot_chat',
-                description: 'Send a natural language message to kbot and receive a specialist agent response. kbot automatically routes to the best-fit agent (coder, researcher, writer, analyst, guardian, or 30 others) based on message intent, or you can force a specific agent via the agent parameter. Use this tool when you need AI-powered assistance for coding, research, writing, analysis, security review, or any general task. Do not use this for direct file operations (use kbot_read_file, kbot_edit_file, kbot_write_file instead) or shell commands (use kbot_bash instead). Each call is stateless -- conversation history is not preserved between calls. Returns the agent response text, plus optional thinking traces and tool-use results if the agent invoked sub-tools.',
+                description: 'Send a natural language message to the kbot CLI and receive a response from one of its built-in specialist roles (saved prompt configurations such as coder, researcher, writer, analyst, guardian — invoked manually by the user). kbot routes to the best-fit role based on message intent, or you can force a specific role via the agent parameter. Use this tool when you need AI-assisted help for coding, research, writing, analysis, security review, or general developer tasks. Do not use this for direct file operations (use kbot_read_file, kbot_edit_file, kbot_write_file instead) or shell commands (use kbot_bash instead). Each call is stateless -- conversation history is not preserved between calls. Returns the response text, plus optional thinking traces and tool-use results if sub-tools were invoked.',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -137,7 +137,7 @@ export async function startMcpServer(config = {}) {
             },
             {
                 name: 'kbot_status',
-                description: 'Retrieve kbot runtime status as a JSON object. Returns the active specialist agent, learning engine statistics (patterns, solutions, knowledge entries, total messages processed), session count, and registered tool count. Use this tool to verify kbot is properly configured, check which agent is active, or monitor learning progress. Do not use this for project-specific status (use kbot_bash with "git status" instead). Read-only operation with no side effects.',
+                description: 'Retrieve kbot runtime status as a JSON object. Returns the active specialist role (saved prompt configuration), pattern-cache statistics (patterns, solutions, knowledge entries, total messages processed), session count, and registered tool count. Use this tool to verify kbot is properly configured, check which role is active, or monitor cached-pattern progress. Do not use this for project-specific status (use kbot_bash with "git status" instead). Read-only operation with no side effects.',
                 inputSchema: {
                     type: 'object',
                     properties: {},
@@ -145,7 +145,7 @@ export async function startMcpServer(config = {}) {
             },
             {
                 name: 'kbot_agent',
-                description: 'Switch the active specialist agent for subsequent kbot_chat calls, or list all available agents when called without arguments. Use this tool to optimize responses by selecting the right specialist -- e.g., switch to "guardian" before a security review, or "researcher" before a deep-dive investigation. Do not use this if you only need to route a single message (pass the agent parameter to kbot_chat instead). Side effects: when agent ID is provided, changes the active agent for all future kbot_chat calls in this session.',
+                description: 'Switch the active specialist role (saved prompt configuration) for subsequent kbot_chat calls, or list all available roles when called without arguments. Use this tool to optimize responses by selecting the right specialist prompt -- e.g., switch to "guardian" before a security review, or "researcher" before a deep-dive investigation. Do not use this if you only need to route a single message (pass the agent parameter to kbot_chat instead). Side effects: when an ID is provided, changes the active role used by all future kbot_chat calls in this session.',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -177,7 +177,7 @@ export async function startMcpServer(config = {}) {
             },
             {
                 name: 'kbot_plan',
-                description: 'Generate and optionally execute an autonomous multi-step plan for a complex task. The planner analyzes the task, breaks it into ordered subtasks, selects appropriate tools for each step, executes them sequentially, and self-corrects on failures with retries. Use this tool for complex multi-file refactors, full-stack feature implementations, research-then-implement workflows, or any task requiring coordination of multiple tools. Do not use this for simple single-step operations (use the specific tool directly). Side effects: depends on plan steps -- may read/write files, run shell commands, make API calls. Set auto_approve=false to review the generated plan before any execution begins.',
+                description: 'Generate, and optionally execute, a multi-step plan for a complex task. The planner analyzes the task, breaks it into ordered subtasks, selects appropriate tools for each step, executes them sequentially, and retries failed steps with adjusted parameters. Use this tool for complex multi-file refactors, full-stack feature implementations, research-then-implement workflows, or any task requiring coordination of multiple tools. Do not use this for simple single-step operations (use the specific tool directly). Side effects: depends on plan steps -- may read/write files, run shell commands, make API calls. Set auto_approve=false (default) to review the generated plan before any execution begins; auto_approve=true is opt-in.',
                 inputSchema: {
                     type: 'object',
                     properties: {

package/dist/managed-agents-anthropic.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Anthropic Managed Agents client (April 2026 launch).
+ *
+ * Hosted long-horizon agent platform. This module is a STANDALONE backend
+ * that workspace agents can route through when ANTHROPIC_API_KEY is set.
+ * Wiring into ./workspace-agents.ts happens in a follow-up pass.
+ *
+ * Beta header: `anthropic-beta: managed-agents-2026-04-01` is sent on every
+ * request.
+ *
+ * SPEC: best-effort, refine when official docs published.
+ * Endpoint shape mirrors the public beta announcement; refine when the
+ * official OpenAPI spec lands.
+ */
+export interface CreateSessionInput {
+    mission: string;
+    allowedTools?: string[];
+    model?: string;
+}
+export interface CreateSessionOutput {
+    session_id: string;
+    [key: string]: unknown;
+}
+export interface SendTurnInput {
+    sessionId: string;
+    input: string;
+}
+export interface SendTurnOutput {
+    output: string;
+    tool_calls?: unknown[];
+    [key: string]: unknown;
+}
+export interface SessionState {
+    session_id: string;
+    mission?: string;
+    status?: string;
+    [key: string]: unknown;
+}
+export interface ListSessionsOutput {
+    sessions: SessionState[];
+    [key: string]: unknown;
+}
+export interface MemoryReadInput {
+    sessionId: string;
+    key?: string;
+}
+export interface MemoryWriteInput {
+    sessionId: string;
+    key: string;
+    value: unknown;
+}
+export interface MemoryAck {
+    ok: boolean;
+    [key: string]: unknown;
+}
+export declare class AnthropicManagedAgentsError extends Error {
+    readonly status: number;
+    readonly body: string;
+    constructor(message: string, status: number, body: string);
+}
+export interface AnthropicManagedAgentsClientOptions {
+    /** Override the API key (default: process.env.ANTHROPIC_API_KEY). */
+    apiKey?: string;
+    /** Override the base URL (default: https://api.anthropic.com/v1). */
+    baseUrl?: string;
+    /** Override fetch (used by tests). */
+    fetchImpl?: typeof fetch;
+}
+export declare class AnthropicManagedAgentsClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    constructor(opts?: AnthropicManagedAgentsClientOptions);
+    createSession(input: CreateSessionInput): Promise<CreateSessionOutput>;
+    sendTurn(input: SendTurnInput): Promise<SendTurnOutput>;
+    getSession(input: {
+        sessionId: string;
+    }): Promise<SessionState>;
+    listSessions(): Promise<ListSessionsOutput>;
+    closeSession(input: {
+        sessionId: string;
+    }): Promise<{
+        ok: boolean;
+        [key: string]: unknown;
+    }>;
+    memoryRead(input: MemoryReadInput): Promise<unknown>;
+    memoryWrite(input: MemoryWriteInput): Promise<MemoryAck>;
+    private request;
+}
+//# sourceMappingURL=managed-agents-anthropic.d.ts.map