@kernel.chat/kbot 3.99.31 → 3.99.34

package/dist/setup-editor.js

@@ -0,0 +1,222 @@
+// kbot setup-editor — idempotent installers that wire kbot's MCP server into
+// editor settings (Claude Code, Cursor, Zed) and, for Claude Code, copy the
+// kbot skill into the project's .claude/skills directory.
+//
+// All writes are atomic (tmp file + rename). Re-running is a no-op if the
+// entries already exist. Existing user config is preserved.
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, copyFileSync, unlinkSync, } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { homedir, platform, tmpdir } from 'node:os';
+import { execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+// ─── helpers ───────────────────────────────────────────────────────────────
+function getHome(opts) {
+    return opts.home ?? homedir();
+}
+function getCwd(opts) {
+    return opts.cwd ?? process.cwd();
+}
+/** Resolve the kbot binary. Prefer process.execPath when run as `kbot`,
+ *  fall back to `which kbot`, then to the literal string `kbot`. */
+function resolveKbotBin(opts) {
+    if (opts.kbotBin)
+        return opts.kbotBin;
+    try {
+        const which = execSync('which kbot', { encoding: 'utf8' }).trim();
+        if (which)
+            return which;
+    }
+    catch {
+        /* fall through */
+    }
+    return 'kbot';
+}
+/** Resolve the local-MCP server path (lives at repo-root/tools/kbot-local-mcp.ts). */
+function resolveKbotLocalMcpPath(opts) {
+    if (opts.kbotLocalMcpPath)
+        return opts.kbotLocalMcpPath;
+    // From this file: packages/kbot/src/setup-editor.ts → repo root is ../../..
+    try {
+        const here = fileURLToPath(import.meta.url);
+        const repoRoot = resolve(dirname(here), '..', '..', '..');
+        const candidate = join(repoRoot, 'tools', 'kbot-local-mcp.ts');
+        if (existsSync(candidate))
+            return candidate;
+    }
+    catch {
+        /* fall through */
+    }
+    return 'tools/kbot-local-mcp.ts';
+}
+function resolveSkillTemplatePath(opts) {
+    if (opts.skillTemplatePath)
+        return opts.skillTemplatePath;
+    try {
+        const here = fileURLToPath(import.meta.url);
+        // src/setup-editor.ts → packages/kbot/templates/kbot-skill.md
+        const pkgRoot = resolve(dirname(here), '..');
+        const candidate = join(pkgRoot, 'templates', 'kbot-skill.md');
+        if (existsSync(candidate))
+            return candidate;
+        // dist build: dist/setup-editor.js → packages/kbot/templates/kbot-skill.md
+        const candidate2 = resolve(dirname(here), '..', 'templates', 'kbot-skill.md');
+        if (existsSync(candidate2))
+            return candidate2;
+    }
+    catch {
+        /* fall through */
+    }
+    return '';
+}
+function readJson(p) {
+    if (!existsSync(p))
+        return {};
+    const txt = readFileSync(p, 'utf8').trim();
+    if (!txt)
+        return {};
+    try {
+        const parsed = JSON.parse(txt);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return {};
+    }
+    catch {
+        // Corrupt config — bail rather than overwrite.
+        throw new Error(`Refusing to overwrite invalid JSON at ${p}`);
+    }
+}
+function writeJsonAtomic(p, data) {
+    mkdirSync(dirname(p), { recursive: true });
+    const tmp = join(dirname(p), `.${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
+    const body = JSON.stringify(data, null, 2) + '\n';
+    writeFileSync(tmp, body, 'utf8');
+    try {
+        renameSync(tmp, p);
+    }
+    catch (e) {
+        try {
+            unlinkSync(tmp);
+        }
+        catch { /* ignore */ }
+        throw e;
+    }
+}
+/** Get an object property as a Record (creating it if missing/invalid). */
+function getOrCreateObj(parent, key) {
+    const existing = parent[key];
+    if (existing && typeof existing === 'object' && !Array.isArray(existing)) {
+        return existing;
+    }
+    const fresh = {};
+    parent[key] = fresh;
+    return fresh;
+}
+/** MCP server entry shapes. Same shape works for Claude Code and Cursor;
+ *  Zed nests under `context_servers` with the same `command`/`args` form. */
+function buildMcpEntries(opts) {
+    const kbotBin = resolveKbotBin(opts);
+    const localMcp = resolveKbotLocalMcpPath(opts);
+    return {
+        kbot: { command: kbotBin, args: ['ide', 'mcp'] },
+        'kbot-local': { command: 'npx', args: ['tsx', localMcp] },
+    };
+}
+/** Merge MCP entries into a target map. Idempotent: if the key already exists,
+ *  we leave it alone (user may have customized it). */
+function mergeMcp(target, entries) {
+    const added = [];
+    const alreadyPresent = [];
+    for (const [name, entry] of Object.entries(entries)) {
+        if (name in target) {
+            alreadyPresent.push(name);
+        }
+        else {
+            target[name] = entry;
+            added.push(name);
+        }
+    }
+    return { added, alreadyPresent };
+}
+// ─── Claude Code ───────────────────────────────────────────────────────────
+export function setupClaudeCode(opts = {}) {
+    const home = getHome(opts);
+    const cwd = getCwd(opts);
+    const configPath = join(home, '.claude', 'settings.json');
+    const cfg = readJson(configPath);
+    const mcp = getOrCreateObj(cfg, 'mcpServers');
+    const { added, alreadyPresent } = mergeMcp(mcp, buildMcpEntries(opts));
+    if (added.length > 0)
+        writeJsonAtomic(configPath, cfg);
+    // Skill copy
+    const skillDir = join(cwd, '.claude', 'skills');
+    const skillDest = join(skillDir, 'kbot.md');
+    const skillSrc = resolveSkillTemplatePath(opts);
+    let skillCopied;
+    let skillAlreadyPresent;
+    if (skillSrc && existsSync(skillSrc)) {
+        mkdirSync(skillDir, { recursive: true });
+        if (existsSync(skillDest) && !opts.force) {
+            skillAlreadyPresent = skillDest;
+        }
+        else {
+            copyFileSync(skillSrc, skillDest);
+            skillCopied = skillDest;
+        }
+    }
+    return {
+        configPath,
+        mcpAdded: added,
+        mcpAlreadyPresent: alreadyPresent,
+        skillCopied,
+        skillAlreadyPresent,
+    };
+}
+// ─── Cursor ────────────────────────────────────────────────────────────────
+function cursorConfigPath(home) {
+    if (platform() === 'darwin') {
+        return join(home, 'Library', 'Application Support', 'Cursor', 'User', 'settings.json');
+    }
+    if (platform() === 'win32') {
+        const appData = process.env.APPDATA ?? join(home, 'AppData', 'Roaming');
+        return join(appData, 'Cursor', 'User', 'settings.json');
+    }
+    // linux + everything else
+    return join(home, '.config', 'Cursor', 'User', 'settings.json');
+}
+export function setupCursor(opts = {}) {
+    const home = getHome(opts);
+    const configPath = cursorConfigPath(home);
+    const cfg = readJson(configPath);
+    // Cursor's evolving schema: it reads `mcp.servers` (nested) for MCP entries.
+    const mcp = getOrCreateObj(cfg, 'mcp');
+    const servers = getOrCreateObj(mcp, 'servers');
+    const { added, alreadyPresent } = mergeMcp(servers, buildMcpEntries(opts));
+    if (added.length > 0)
+        writeJsonAtomic(configPath, cfg);
+    return {
+        configPath,
+        mcpAdded: added,
+        mcpAlreadyPresent: alreadyPresent,
+    };
+}
+// ─── Zed ───────────────────────────────────────────────────────────────────
+export function setupZed(opts = {}) {
+    const home = getHome(opts);
+    const configPath = join(home, '.config', 'zed', 'settings.json');
+    const cfg = readJson(configPath);
+    // Zed's assistant config is in flux. Best-effort shape: `assistant.mcpServers`.
+    const assistant = getOrCreateObj(cfg, 'assistant');
+    const mcp = getOrCreateObj(assistant, 'mcpServers');
+    const { added, alreadyPresent } = mergeMcp(mcp, buildMcpEntries(opts));
+    if (added.length > 0)
+        writeJsonAtomic(configPath, cfg);
+    return {
+        configPath,
+        mcpAdded: added,
+        mcpAlreadyPresent: alreadyPresent,
+    };
+}
+// ─── tmpdir helper exported for tests ──────────────────────────────────────
+export const _testHelpers = { tmpdir };
+//# sourceMappingURL=setup-editor.js.map

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

@@ -0,0 +1,22 @@
+/**
+ * kbot tool definitions wrapping the Anthropic Managed Agents client.
+ *
+ * Six tools mirror the client surface: create / turn / list / close /
+ * memory_read / memory_write. Each uses the canonical ToolDefinition shape
+ * from ./index.js.
+ *
+ * Wiring into the global tool registry happens elsewhere (tools/index.ts).
+ * This file only exports the definitions so workspace-agents.ts can pick
+ * them up when ANTHROPIC_API_KEY is set.
+ *
+ * SPEC: best-effort, refine when official docs published.
+ */
+import type { ToolDefinition } from './index.js';
+export declare const anthropicManagedAgentCreate: ToolDefinition;
+export declare const anthropicManagedAgentTurn: ToolDefinition;
+export declare const anthropicManagedAgentList: ToolDefinition;
+export declare const anthropicManagedAgentClose: ToolDefinition;
+export declare const anthropicManagedAgentMemoryRead: ToolDefinition;
+export declare const anthropicManagedAgentMemoryWrite: ToolDefinition;
+export declare const anthropicManagedAgentTools: ToolDefinition[];
+//# sourceMappingURL=anthropic-managed-agents-tools.d.ts.map

package/dist/tools/anthropic-managed-agents-tools.js

@@ -0,0 +1,191 @@
+/**
+ * kbot tool definitions wrapping the Anthropic Managed Agents client.
+ *
+ * Six tools mirror the client surface: create / turn / list / close /
+ * memory_read / memory_write. Each uses the canonical ToolDefinition shape
+ * from ./index.js.
+ *
+ * Wiring into the global tool registry happens elsewhere (tools/index.ts).
+ * This file only exports the definitions so workspace-agents.ts can pick
+ * them up when ANTHROPIC_API_KEY is set.
+ *
+ * SPEC: best-effort, refine when official docs published.
+ */
+import { AnthropicManagedAgentsClient } from '../managed-agents-anthropic.js';
+// ─────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────
+function getClient() {
+    // Construct fresh per call so callers can rotate API keys without
+    // restarting the process. The constructor cost is trivial (just a string
+    // copy and a fetch reference).
+    return new AnthropicManagedAgentsClient();
+}
+function asString(v) {
+    return typeof v === 'string' ? v : undefined;
+}
+function asStringArray(v) {
+    if (!Array.isArray(v))
+        return undefined;
+    const out = [];
+    for (const item of v) {
+        if (typeof item === 'string')
+            out.push(item);
+    }
+    return out;
+}
+async function safeRun(fn) {
+    try {
+        const result = await fn();
+        return JSON.stringify(result, null, 2);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return `Error: ${message}`;
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Tools
+// ─────────────────────────────────────────────────────────────────────────
+export const anthropicManagedAgentCreate = {
+    name: 'anthropic_managed_agent_create',
+    description: 'Create a hosted Anthropic Managed Agent session. Returns session_id. Requires ANTHROPIC_API_KEY. Sends anthropic-beta: managed-agents-2026-04-01.',
+    tier: 'pro',
+    parameters: {
+        mission: {
+            type: 'string',
+            description: 'The agent\'s long-horizon goal / mission statement.',
+            required: true,
+        },
+        allowed_tools: {
+            type: 'array',
+            description: 'Optional list of tool names the hosted agent may invoke.',
+            items: { type: 'string' },
+        },
+        model: {
+            type: 'string',
+            description: 'Optional model override (e.g., "claude-sonnet-4-7").',
+        },
+    },
+    async execute(args) {
+        return safeRun(async () => {
+            const mission = asString(args.mission) ?? '';
+            const allowedTools = asStringArray(args.allowed_tools);
+            const model = asString(args.model);
+            return getClient().createSession({ mission, allowedTools, model });
+        });
+    },
+};
+export const anthropicManagedAgentTurn = {
+    name: 'anthropic_managed_agent_turn',
+    description: 'Send a turn (user input) to an Anthropic Managed Agent session. Returns the agent output and any tool calls.',
+    tier: 'pro',
+    parameters: {
+        session_id: {
+            type: 'string',
+            description: 'Session id returned by anthropic_managed_agent_create.',
+            required: true,
+        },
+        input: {
+            type: 'string',
+            description: 'The user-side input for this turn.',
+            required: true,
+        },
+    },
+    async execute(args) {
+        return safeRun(async () => {
+            const sessionId = asString(args.session_id) ?? '';
+            const input = asString(args.input) ?? '';
+            return getClient().sendTurn({ sessionId, input });
+        });
+    },
+};
+export const anthropicManagedAgentList = {
+    name: 'anthropic_managed_agent_list',
+    description: 'List all hosted Anthropic Managed Agent sessions for the configured API key.',
+    tier: 'pro',
+    parameters: {},
+    async execute() {
+        return safeRun(async () => getClient().listSessions());
+    },
+};
+export const anthropicManagedAgentClose = {
+    name: 'anthropic_managed_agent_close',
+    description: 'Close (DELETE) a hosted Anthropic Managed Agent session.',
+    tier: 'pro',
+    parameters: {
+        session_id: {
+            type: 'string',
+            description: 'Session id to close.',
+            required: true,
+        },
+    },
+    async execute(args) {
+        return safeRun(async () => {
+            const sessionId = asString(args.session_id) ?? '';
+            return getClient().closeSession({ sessionId });
+        });
+    },
+};
+export const anthropicManagedAgentMemoryRead = {
+    name: 'anthropic_managed_agent_memory_read',
+    description: 'Read a memory value from a hosted Anthropic Managed Agent session. Pass key to read a single entry; omit key for the full memory.',
+    tier: 'pro',
+    parameters: {
+        session_id: {
+            type: 'string',
+            description: 'Session id.',
+            required: true,
+        },
+        key: {
+            type: 'string',
+            description: 'Optional memory key. If omitted, returns the full memory.',
+        },
+    },
+    async execute(args) {
+        return safeRun(async () => {
+            const sessionId = asString(args.session_id) ?? '';
+            const key = asString(args.key);
+            return getClient().memoryRead({ sessionId, key });
+        });
+    },
+};
+export const anthropicManagedAgentMemoryWrite = {
+    name: 'anthropic_managed_agent_memory_write',
+    description: 'Write a memory value to a hosted Anthropic Managed Agent session.',
+    tier: 'pro',
+    parameters: {
+        session_id: {
+            type: 'string',
+            description: 'Session id.',
+            required: true,
+        },
+        key: {
+            type: 'string',
+            description: 'Memory key to write.',
+            required: true,
+        },
+        value: {
+            type: 'string',
+            description: 'Value to store. Strings are stored as-is; if the value is a JSON string it is forwarded verbatim.',
+            required: true,
+        },
+    },
+    async execute(args) {
+        return safeRun(async () => {
+            const sessionId = asString(args.session_id) ?? '';
+            const key = asString(args.key) ?? '';
+            const value = args.value;
+            return getClient().memoryWrite({ sessionId, key, value });
+        });
+    },
+};
+export const anthropicManagedAgentTools = [
+    anthropicManagedAgentCreate,
+    anthropicManagedAgentTurn,
+    anthropicManagedAgentList,
+    anthropicManagedAgentClose,
+    anthropicManagedAgentMemoryRead,
+    anthropicManagedAgentMemoryWrite,
+];
+//# sourceMappingURL=anthropic-managed-agents-tools.js.map

package/dist/tools/channel-tools.d.ts

@@ -0,0 +1,4 @@
+import type { ToolDefinition } from './index.js';
+export declare const channelSendTool: ToolDefinition;
+export declare const channelReceiveTool: ToolDefinition;
+//# sourceMappingURL=channel-tools.d.ts.map

package/dist/tools/channel-tools.js

@@ -0,0 +1,80 @@
+// kbot tool definitions for the unified channel adapter family.
+//
+// These tools are NOT auto-registered. Whoever wires them in (cli.ts,
+// a plugin, or an agent prompt) should call `registerTool(channelSendTool)`
+// and `registerTool(channelReceiveTool)`. Keeping registration external
+// preserves the CURATION_PLAN.md target of 52 core tools.
+import { getChannel } from '../channels/registry.js';
+export const channelSendTool = {
+    name: 'channel_send',
+    description: 'Send a message through a unified channel adapter (slack, whatsapp, telegram, signal, matrix, teams). Slack is fully implemented; others are stubs and will throw until implemented.',
+    tier: 'pro',
+    parameters: {
+        channel_type: {
+            type: 'string',
+            description: 'Adapter name: slack | whatsapp | telegram | signal | matrix | teams',
+            required: true,
+        },
+        channel: {
+            type: 'string',
+            description: 'Target channel/chat/room id understood by the adapter',
+            required: true,
+        },
+        text: {
+            type: 'string',
+            description: 'Plain-text message body',
+            required: true,
+        },
+        blocks: {
+            type: 'array',
+            description: 'Optional rich content (Slack blocks, etc.)',
+            required: false,
+        },
+    },
+    async execute(args) {
+        const adapter = getChannel(String(args.channel_type));
+        const result = await adapter.send({
+            channel: String(args.channel),
+            text: String(args.text),
+            blocks: args.blocks,
+        });
+        return JSON.stringify({ ok: true, adapter: adapter.name, ...result });
+    },
+};
+export const channelReceiveTool = {
+    name: 'channel_receive',
+    description: 'Fetch recent messages from a unified channel adapter. Returns a JSON array of {id, from, text, ts}.',
+    tier: 'pro',
+    parameters: {
+        channel_type: {
+            type: 'string',
+            description: 'Adapter name: slack | whatsapp | telegram | signal | matrix | teams',
+            required: true,
+        },
+        channel: {
+            type: 'string',
+            description: 'Source channel/chat/room id',
+            required: true,
+        },
+        oldest: {
+            type: 'number',
+            description: 'Unix epoch ms; only return messages newer than this',
+            required: false,
+        },
+        limit: {
+            type: 'number',
+            description: 'Maximum messages to return',
+            required: false,
+        },
+    },
+    async execute(args) {
+        const adapter = getChannel(String(args.channel_type));
+        const messages = await adapter.receive({
+            channel: String(args.channel),
+            oldest: args.oldest === undefined ? undefined : Number(args.oldest),
+            limit: args.limit === undefined ? undefined : Number(args.limit),
+        });
+        return JSON.stringify({ ok: true, adapter: adapter.name, messages });
+    },
+};
+//# sourceMappingURL=channel-tools.js.map

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

@@ -0,0 +1,13 @@
+export interface ToolDef {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    handler: (args: Record<string, unknown>) => Promise<unknown> | unknown;
+}
+export declare const computerCoordinatorRegister: ToolDef;
+export declare const computerCoordinatorClaim: ToolDef;
+export declare const computerCoordinatorRelease: ToolDef;
+export declare const computerCoordinatorStatus: ToolDef;
+export declare const computerCoordinatorUnregister: ToolDef;
+export declare const computerCoordinatorTools: ToolDef[];
+//# sourceMappingURL=computer-coordinator-tools.d.ts.map

package/dist/tools/computer-coordinator-tools.js

@@ -0,0 +1,104 @@
+// Tool definitions for the Computer-Use Coordinator.
+//
+// NOT registered here — wiring lives in computer.ts (or wherever the
+// `--computer-use` flag is interpreted). Exporting plain definitions
+// keeps this file pure and testable.
+import { Coordinator } from '../computer-use-coordinator.js';
+let shared = null;
+function instance() {
+    if (!shared)
+        shared = new Coordinator();
+    return shared;
+}
+function asString(v, field) {
+    if (typeof v !== 'string' || !v)
+        throw new Error(`${field} must be a non-empty string`);
+    return v;
+}
+function asStringArray(v, field) {
+    if (!Array.isArray(v) || v.some((x) => typeof x !== 'string')) {
+        throw new Error(`${field} must be a string[]`);
+    }
+    return v;
+}
+export const computerCoordinatorRegister = {
+    name: 'computer_coordinator_register',
+    description: 'Register an agent with the parallel computer-use coordinator. Declares which apps it intends to drive.',
+    inputSchema: {
+        type: 'object',
+        required: ['agentId', 'apps'],
+        properties: {
+            agentId: { type: 'string' },
+            apps: { type: 'array', items: { type: 'string' } },
+            windowIds: { type: 'array', items: { type: 'string' } },
+        },
+    },
+    handler: (args) => {
+        const agentId = asString(args.agentId, 'agentId');
+        const apps = asStringArray(args.apps, 'apps');
+        const windowIds = args.windowIds === undefined ? undefined : asStringArray(args.windowIds, 'windowIds');
+        instance().register(agentId, { apps, windowIds });
+        return { ok: true, agentId, apps, windowIds: windowIds ?? [] };
+    },
+};
+export const computerCoordinatorClaim = {
+    name: 'computer_coordinator_claim',
+    description: 'Claim exclusive control of one app for an agent. Denied if another live agent already holds it.',
+    inputSchema: {
+        type: 'object',
+        required: ['agentId', 'app'],
+        properties: {
+            agentId: { type: 'string' },
+            app: { type: 'string' },
+        },
+    },
+    handler: (args) => {
+        const agentId = asString(args.agentId, 'agentId');
+        const app = asString(args.app, 'app');
+        return instance().claim(agentId, app);
+    },
+};
+export const computerCoordinatorRelease = {
+    name: 'computer_coordinator_release',
+    description: 'Release a previously claimed app so another agent can take it.',
+    inputSchema: {
+        type: 'object',
+        required: ['agentId', 'app'],
+        properties: {
+            agentId: { type: 'string' },
+            app: { type: 'string' },
+        },
+    },
+    handler: (args) => {
+        const agentId = asString(args.agentId, 'agentId');
+        const app = asString(args.app, 'app');
+        return { released: instance().release(agentId, app) };
+    },
+};
+export const computerCoordinatorStatus = {
+    name: 'computer_coordinator_status',
+    description: 'List all registered agents and which apps they currently hold.',
+    inputSchema: { type: 'object', properties: {} },
+    handler: () => instance().status(),
+};
+export const computerCoordinatorUnregister = {
+    name: 'computer_coordinator_unregister',
+    description: 'Unregister an agent and release every claim it owns.',
+    inputSchema: {
+        type: 'object',
+        required: ['agentId'],
+        properties: { agentId: { type: 'string' } },
+    },
+    handler: (args) => {
+        const agentId = asString(args.agentId, 'agentId');
+        return { released: instance().unregister(agentId) };
+    },
+};
+export const computerCoordinatorTools = [
+    computerCoordinatorRegister,
+    computerCoordinatorClaim,
+    computerCoordinatorRelease,
+    computerCoordinatorStatus,
+    computerCoordinatorUnregister,
+];
+//# sourceMappingURL=computer-coordinator-tools.js.map