bluekiwi 0.1.0

package/dist/commands/init.js

@@ -0,0 +1,137 @@
+import prompts from "prompts";
+import pc from "picocolors";
+import { BlueKiwiClient } from "../api-client.js";
+import { BUNDLED_MCP_PATH, BUNDLED_SKILLS } from "../assets/index.js";
+import { saveConfig } from "../config.js";
+import { detectInstalledAdapters, getAllAdapters } from "../runtimes/detect.js";
+function normalizeEnvValue(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function parseCommaSeparatedList(values) {
+    const parsed = [];
+    for (const value of values ?? []) {
+        for (const item of value.split(",")) {
+            const trimmed = item.trim();
+            if (trimmed)
+                parsed.push(trimmed);
+        }
+    }
+    return parsed;
+}
+function uniquePreserveOrder(values) {
+    const seen = new Set();
+    const unique = [];
+    for (const value of values) {
+        if (seen.has(value))
+            continue;
+        seen.add(value);
+        unique.push(value);
+    }
+    return unique;
+}
+export async function initCommand(options = {}) {
+    const isNonInteractive = options.yes === true || process.stdin.isTTY !== true;
+    let server = normalizeEnvValue(options.server) ??
+        normalizeEnvValue(process.env.BLUEKIWI_SERVER);
+    let apiKey = normalizeEnvValue(options.apiKey) ??
+        normalizeEnvValue(process.env.BLUEKIWI_API_KEY);
+    if (!isNonInteractive && (server === undefined || apiKey === undefined)) {
+        const questions = [];
+        if (server === undefined) {
+            questions.push({
+                type: "text",
+                name: "server",
+                message: "BlueKiwi server URL",
+            });
+        }
+        if (apiKey === undefined) {
+            questions.push({
+                type: "password",
+                name: "apiKey",
+                message: "API key (bk_...)",
+            });
+        }
+        const answers = await prompts(questions);
+        server ??= answers.server;
+        apiKey ??= answers.apiKey;
+    }
+    if (server === undefined || apiKey === undefined) {
+        if (isNonInteractive) {
+            throw new Error("Non-interactive mode: --server and --api-key (or BLUEKIWI_SERVER/BLUEKIWI_API_KEY) are required");
+        }
+        throw new Error("BlueKiwi server URL and API key are required");
+    }
+    const client = new BlueKiwiClient(server, apiKey);
+    await client.request("GET", "/api/workflows");
+    const me = {
+        id: 0,
+        username: "unknown",
+        email: "",
+        role: "viewer",
+    };
+    const detected = detectInstalledAdapters();
+    const all = getAllAdapters();
+    const adaptersByName = new Map(all.map((adapter) => [adapter.name, adapter]));
+    const validRuntimeNames = all.map((adapter) => adapter.name);
+    const requestedFromFlags = uniquePreserveOrder(parseCommaSeparatedList(options.runtimes));
+    const requestedFromEnv = uniquePreserveOrder(parseCommaSeparatedList([process.env.BLUEKIWI_RUNTIMES ?? ""]));
+    const requestedRuntimeNames = requestedFromFlags.length > 0 ? requestedFromFlags : requestedFromEnv;
+    let selectedRuntimeNames = [];
+    if (requestedRuntimeNames.length > 0) {
+        const unknown = requestedRuntimeNames.filter((name) => !adaptersByName.has(name));
+        if (unknown.length > 0) {
+            throw new Error(`Unknown runtime(s): ${unknown.join(", ")}. Valid runtimes: ${validRuntimeNames.join(", ")}`);
+        }
+        for (const name of requestedRuntimeNames) {
+            const adapter = adaptersByName.get(name);
+            if (!adapter)
+                continue;
+            if (!adapter.isInstalled()) {
+                throw new Error(`Runtime '${name}' is not installed on this system`);
+            }
+        }
+        selectedRuntimeNames = requestedRuntimeNames;
+    }
+    else if (isNonInteractive) {
+        if (detected.length === 0) {
+            throw new Error("Non-interactive mode: at least one runtime is required (--runtime <name>) or install a supported runtime");
+        }
+        selectedRuntimeNames = [detected[0].name];
+    }
+    else {
+        const { selected } = (await prompts({
+            type: "multiselect",
+            name: "selected",
+            message: "Install into which runtimes?",
+            choices: all.map((adapter) => ({
+                title: adapter.displayName,
+                value: adapter.name,
+                selected: detected.some((item) => item.name === adapter.name),
+                disabled: !adapter.isInstalled(),
+            })),
+        }));
+        selectedRuntimeNames = selected ?? [];
+    }
+    for (const name of selectedRuntimeNames) {
+        const adapter = all.find((item) => item.name === name);
+        if (!adapter)
+            continue;
+        adapter.installSkills(BUNDLED_SKILLS);
+        adapter.installMcp({
+            command: "node",
+            args: [BUNDLED_MCP_PATH],
+            env: { BLUEKIWI_API_URL: server, BLUEKIWI_API_KEY: apiKey },
+        });
+    }
+    saveConfig({
+        version: "1.0.0",
+        server_url: server,
+        api_key: apiKey,
+        user: me,
+        runtimes: selectedRuntimeNames,
+        installed_at: new Date().toISOString(),
+        last_used: new Date().toISOString(),
+    });
+    console.log(pc.green("✓ BlueKiwi connected"));
+}

package/dist/commands/logout.js

@@ -0,0 +1,18 @@
+import pc from "picocolors";
+import { clearConfig, loadConfig } from "../config.js";
+import { getAllAdapters } from "../runtimes/detect.js";
+export async function logoutCommand() {
+    const cfg = loadConfig();
+    if (!cfg) {
+        console.log(pc.yellow("Already logged out."));
+        return;
+    }
+    for (const adapter of getAllAdapters()) {
+        if (cfg.runtimes.includes(adapter.name)) {
+            adapter.uninstall();
+            console.log(pc.dim(`  removed ${adapter.displayName}`));
+        }
+    }
+    clearConfig();
+    console.log(pc.green("✓ Logged out and uninstalled."));
+}

package/dist/commands/runtimes.js

@@ -0,0 +1,51 @@
+import { getAllAdapters } from "../runtimes/detect.js";
+import pc from "picocolors";
+import { BUNDLED_MCP_PATH, BUNDLED_SKILLS } from "../assets/index.js";
+import { loadConfig, requireConfig, saveConfig } from "../config.js";
+async function list() {
+    const cfg = loadConfig();
+    const installed = new Set(cfg?.runtimes ?? []);
+    for (const adapter of getAllAdapters()) {
+        const detected = adapter.isInstalled()
+            ? pc.green("detected")
+            : pc.dim("not installed");
+        const active = installed.has(adapter.name)
+            ? pc.green("● active")
+            : pc.dim("○ inactive");
+        console.log(`${adapter.displayName.padEnd(14)} ${detected}  ${active}`);
+    }
+}
+async function add(name) {
+    const cfg = requireConfig();
+    const adapter = getAllAdapters().find((item) => item.name === name);
+    if (!adapter) {
+        console.error(`Unknown runtime: ${name}`);
+        process.exit(1);
+    }
+    adapter.installSkills(BUNDLED_SKILLS);
+    adapter.installMcp({
+        command: "node",
+        args: [BUNDLED_MCP_PATH],
+        env: { BLUEKIWI_API_URL: cfg.server_url, BLUEKIWI_API_KEY: cfg.api_key },
+    });
+    saveConfig({
+        ...cfg,
+        runtimes: Array.from(new Set([...cfg.runtimes, name])),
+    });
+    console.log(pc.green(`✓ Installed to ${adapter.displayName}`));
+}
+async function remove(name) {
+    const cfg = requireConfig();
+    const adapter = getAllAdapters().find((item) => item.name === name);
+    if (!adapter) {
+        console.error(`Unknown runtime: ${name}`);
+        process.exit(1);
+    }
+    adapter.uninstall();
+    saveConfig({
+        ...cfg,
+        runtimes: cfg.runtimes.filter((runtime) => runtime !== name),
+    });
+    console.log(pc.green(`✓ Removed ${adapter.displayName}`));
+}
+export const runtimesCommand = { list, add, remove };

package/dist/commands/status.js

@@ -0,0 +1,22 @@
+import pc from "picocolors";
+import { BlueKiwiClient } from "../api-client.js";
+import { CONFIG_PATH, loadConfig } from "../config.js";
+export async function statusCommand() {
+    const cfg = loadConfig();
+    if (!cfg) {
+        console.log(pc.yellow(`Not authenticated. No config at ${CONFIG_PATH}.`));
+        process.exit(1);
+    }
+    console.log(`${pc.bold("Server:")}   ${cfg.server_url}`);
+    console.log(`${pc.bold("User:")}     ${cfg.user.username} (${cfg.user.role})`);
+    console.log(`${pc.bold("Runtimes:")} ${cfg.runtimes.join(", ") || "(none)"}`);
+    try {
+        const client = new BlueKiwiClient(cfg.server_url, cfg.api_key);
+        await client.request("GET", "/api/workflows");
+        console.log(pc.green("✓ Connection OK"));
+    }
+    catch (err) {
+        console.log(pc.red(`✗ Connection failed: ${err.message}`));
+        process.exit(1);
+    }
+}

package/dist/commands/upgrade.js

@@ -0,0 +1,28 @@
+import { execFileSync } from "child_process";
+import pc from "picocolors";
+import { BUNDLED_MCP_PATH, BUNDLED_SKILLS } from "../assets/index.js";
+import { loadConfig, saveConfig } from "../config.js";
+import { getAllAdapters } from "../runtimes/detect.js";
+export async function upgradeCommand() {
+    console.log(pc.cyan("→ Upgrading bluekiwi..."));
+    execFileSync("npm", ["install", "-g", "bluekiwi@latest"], {
+        stdio: "inherit",
+    });
+    const cfg = loadConfig();
+    if (!cfg) {
+        console.log(pc.yellow("No config found. Run `bluekiwi accept` or `bluekiwi init` next."));
+        return;
+    }
+    for (const adapter of getAllAdapters()) {
+        if (!cfg.runtimes.includes(adapter.name))
+            continue;
+        adapter.installSkills(BUNDLED_SKILLS);
+        adapter.installMcp({
+            command: "node",
+            args: [BUNDLED_MCP_PATH],
+            env: { BLUEKIWI_API_URL: cfg.server_url, BLUEKIWI_API_KEY: cfg.api_key },
+        });
+    }
+    saveConfig({ ...cfg, last_used: new Date().toISOString() });
+    console.log(pc.green("✓ Upgraded and reinstalled assets."));
+}

package/dist/config.js

@@ -0,0 +1,30 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync, unlinkSync, } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+export const CONFIG_PATH = join(homedir(), ".bluekiwi", "config.json");
+export function loadConfig() {
+    if (!existsSync(CONFIG_PATH))
+        return null;
+    try {
+        return JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveConfig(config) {
+    mkdirSync(dirname(CONFIG_PATH), { recursive: true, mode: 0o700 });
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+    chmodSync(CONFIG_PATH, 0o600);
+}
+export function clearConfig() {
+    if (existsSync(CONFIG_PATH))
+        unlinkSync(CONFIG_PATH);
+}
+export function requireConfig() {
+    const config = loadConfig();
+    if (!config) {
+        throw new Error("Not authenticated. Run `npx bluekiwi accept <token> --server <url>` first.");
+    }
+    return config;
+}

package/dist/index.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { acceptCommand } from "./commands/accept.js";
+import { initCommand } from "./commands/init.js";
+import { statusCommand } from "./commands/status.js";
+import { upgradeCommand } from "./commands/upgrade.js";
+import { logoutCommand } from "./commands/logout.js";
+import { runtimesCommand } from "./commands/runtimes.js";
+import { devLinkCommand } from "./commands/dev-link.js";
+function splitCommaSeparatedList(value) {
+    return value
+        .split(",")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+}
+function collectRuntimes(value, previous) {
+    return previous.concat(splitCommaSeparatedList(value));
+}
+const program = new Command();
+program
+    .name("bluekiwi")
+    .description("BlueKiwi CLI — connect your agent runtime to a BlueKiwi server")
+    .version("0.0.0");
+program
+    .command("accept <token>")
+    .requiredOption("--server <url>", "BlueKiwi server URL")
+    .option("--username <name>", "Username (non-interactive)")
+    .option("--password <pass>", "Password (non-interactive)")
+    .action(acceptCommand);
+program
+    .command("init")
+    .option("--server <url>", "BlueKiwi server URL")
+    .option("--api-key <key>", "API key (bk_...)")
+    .option("--runtime <name>", "Runtime to install into (repeatable, or comma-separated)", collectRuntimes, [])
+    .option("--yes", "Suppress all prompts (non-interactive)")
+    .action((opts) => initCommand({
+    server: opts.server,
+    apiKey: opts.apiKey,
+    runtimes: opts.runtime?.length ? opts.runtime : undefined,
+    yes: opts.yes,
+}));
+program.command("status").action(statusCommand);
+program.command("upgrade").action(upgradeCommand);
+program.command("logout").action(logoutCommand);
+program.command("runtimes").action(runtimesCommand.list);
+program.command("runtimes:add <name>").action(runtimesCommand.add);
+program.command("runtimes:remove <name>").action(runtimesCommand.remove);
+program.command("dev-link").action(devLinkCommand);
+program.parseAsync(process.argv).catch((err) => {
+    console.error(err.message);
+    process.exit(1);
+});

package/dist/runtimes/base.js

@@ -0,0 +1 @@
+export {};

package/dist/runtimes/claude-code.js

@@ -0,0 +1,56 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const BASE = join(homedir(), ".claude");
+const SKILLS_DIR = join(BASE, "skills");
+const MCP_CONFIG = join(BASE, "mcp.json");
+export class ClaudeCodeAdapter {
+    name = "claude-code";
+    displayName = "Claude Code";
+    isInstalled() {
+        return existsSync(BASE);
+    }
+    getSkillsDir() {
+        return SKILLS_DIR;
+    }
+    getMcpConfigPath() {
+        return MCP_CONFIG;
+    }
+    installSkills(skills) {
+        mkdirSync(SKILLS_DIR, { recursive: true });
+        for (const skill of skills) {
+            const dir = join(SKILLS_DIR, skill.name);
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(join(dir, "SKILL.md"), skill.content);
+        }
+    }
+    installMcp(config) {
+        let existing = {};
+        if (existsSync(MCP_CONFIG)) {
+            try {
+                existing = JSON.parse(readFileSync(MCP_CONFIG, "utf8"));
+            }
+            catch { }
+        }
+        existing.mcpServers = existing.mcpServers ?? {};
+        existing.mcpServers.bluekiwi = config;
+        mkdirSync(BASE, { recursive: true });
+        writeFileSync(MCP_CONFIG, JSON.stringify(existing, null, 2));
+    }
+    uninstall() {
+        for (const name of ["bk-start", "bk-next", "bk-status", "bk-rewind"]) {
+            const dir = join(SKILLS_DIR, name);
+            if (existsSync(dir)) {
+                rmSync(dir, { recursive: true, force: true });
+            }
+        }
+        if (existsSync(MCP_CONFIG)) {
+            try {
+                const config = JSON.parse(readFileSync(MCP_CONFIG, "utf8"));
+                delete config.mcpServers?.bluekiwi;
+                writeFileSync(MCP_CONFIG, JSON.stringify(config, null, 2));
+            }
+            catch { }
+        }
+    }
+}

package/dist/runtimes/codex.js

@@ -0,0 +1,54 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const BASE = join(homedir(), ".codex");
+const SKILLS_DIR = join(BASE, "skills");
+const MCP_CONFIG = join(BASE, "config.toml");
+export class CodexAdapter {
+    name = "codex";
+    displayName = "Codex CLI";
+    isInstalled() {
+        return existsSync(BASE);
+    }
+    getSkillsDir() {
+        return SKILLS_DIR;
+    }
+    getMcpConfigPath() {
+        return MCP_CONFIG;
+    }
+    installSkills(skills) {
+        mkdirSync(SKILLS_DIR, { recursive: true });
+        for (const skill of skills) {
+            const dir = join(SKILLS_DIR, skill.name);
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(join(dir, "SKILL.md"), skill.content);
+        }
+    }
+    installMcp(config) {
+        mkdirSync(BASE, { recursive: true });
+        const envLines = Object.entries(config.env)
+            .map(([key, value]) => `${key} = "${value}"`)
+            .join("\n");
+        const snippet = `\n[mcp_servers.bluekiwi]\n` +
+            `command = "${config.command}"\n` +
+            `args = ${JSON.stringify(config.args)}\n\n` +
+            `[mcp_servers.bluekiwi.env]\n${envLines}\n`;
+        const existing = existsSync(MCP_CONFIG)
+            ? readFileSync(MCP_CONFIG, "utf8")
+            : "";
+        const stripped = existing.replace(/\n?\[mcp_servers\.bluekiwi\][\s\S]*?(?=\n\[|$)/g, "");
+        writeFileSync(MCP_CONFIG, stripped + snippet);
+    }
+    uninstall() {
+        if (existsSync(MCP_CONFIG)) {
+            const existing = readFileSync(MCP_CONFIG, "utf8");
+            writeFileSync(MCP_CONFIG, existing.replace(/\n?\[mcp_servers\.bluekiwi\][\s\S]*?(?=\n\[|$)/g, ""));
+        }
+        for (const name of ["bk-start", "bk-next", "bk-status", "bk-rewind"]) {
+            const dir = join(SKILLS_DIR, name);
+            if (existsSync(dir)) {
+                rmSync(dir, { recursive: true, force: true });
+            }
+        }
+    }
+}

package/dist/runtimes/detect.js

@@ -0,0 +1,17 @@
+import { ClaudeCodeAdapter } from "./claude-code.js";
+import { CodexAdapter } from "./codex.js";
+import { GeminiCliAdapter } from "./gemini-cli.js";
+import { OpenCodeAdapter } from "./opencode.js";
+import { OpenClawAdapter } from "./openclaw.js";
+export function getAllAdapters() {
+    return [
+        new ClaudeCodeAdapter(),
+        new CodexAdapter(),
+        new GeminiCliAdapter(),
+        new OpenCodeAdapter(),
+        new OpenClawAdapter(),
+    ];
+}
+export function detectInstalledAdapters() {
+    return getAllAdapters().filter((adapter) => adapter.isInstalled());
+}

package/dist/runtimes/gemini-cli.js

@@ -0,0 +1,56 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const BASE = join(homedir(), ".gemini");
+const SKILLS_DIR = join(BASE, "skills");
+const MCP_CONFIG = join(BASE, "settings.json");
+export class GeminiCliAdapter {
+    name = "gemini-cli";
+    displayName = "Gemini CLI";
+    isInstalled() {
+        return existsSync(BASE);
+    }
+    getSkillsDir() {
+        return SKILLS_DIR;
+    }
+    getMcpConfigPath() {
+        return MCP_CONFIG;
+    }
+    installSkills(skills) {
+        mkdirSync(SKILLS_DIR, { recursive: true });
+        for (const skill of skills) {
+            const dir = join(SKILLS_DIR, skill.name);
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(join(dir, "SKILL.md"), skill.content);
+        }
+    }
+    installMcp(config) {
+        mkdirSync(BASE, { recursive: true });
+        let existing = {};
+        if (existsSync(MCP_CONFIG)) {
+            try {
+                existing = JSON.parse(readFileSync(MCP_CONFIG, "utf8"));
+            }
+            catch { }
+        }
+        existing.mcpServers = existing.mcpServers ?? {};
+        existing.mcpServers.bluekiwi = config;
+        writeFileSync(MCP_CONFIG, JSON.stringify(existing, null, 2));
+    }
+    uninstall() {
+        for (const name of ["bk-start", "bk-next", "bk-status", "bk-rewind"]) {
+            const dir = join(SKILLS_DIR, name);
+            if (existsSync(dir)) {
+                rmSync(dir, { recursive: true, force: true });
+            }
+        }
+        if (existsSync(MCP_CONFIG)) {
+            try {
+                const config = JSON.parse(readFileSync(MCP_CONFIG, "utf8"));
+                delete config.mcpServers?.bluekiwi;
+                writeFileSync(MCP_CONFIG, JSON.stringify(config, null, 2));
+            }
+            catch { }
+        }
+    }
+}

package/dist/runtimes/openclaw.js

@@ -0,0 +1,56 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const BASE = join(homedir(), ".openclaw");
+const SKILLS_DIR = join(BASE, "skills");
+const MCP_CONFIG = join(BASE, "mcp.json");
+export class OpenClawAdapter {
+    name = "openclaw";
+    displayName = "OpenClaw";
+    isInstalled() {
+        return existsSync(BASE);
+    }
+    getSkillsDir() {
+        return SKILLS_DIR;
+    }
+    getMcpConfigPath() {
+        return MCP_CONFIG;
+    }
+    installSkills(skills) {
+        mkdirSync(SKILLS_DIR, { recursive: true });
+        for (const skill of skills) {
+            const dir = join(SKILLS_DIR, skill.name);
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(join(dir, "SKILL.md"), skill.content);
+        }
+    }
+    installMcp(config) {
+        mkdirSync(BASE, { recursive: true });
+        let existing = {};
+        if (existsSync(MCP_CONFIG)) {
+            try {
+                existing = JSON.parse(readFileSync(MCP_CONFIG, "utf8"));
+            }
+            catch { }
+        }
+        existing.mcpServers = existing.mcpServers ?? {};
+        existing.mcpServers.bluekiwi = config;
+        writeFileSync(MCP_CONFIG, JSON.stringify(existing, null, 2));
+    }
+    uninstall() {
+        for (const name of ["bk-start", "bk-next", "bk-status", "bk-rewind"]) {
+            const dir = join(SKILLS_DIR, name);
+            if (existsSync(dir)) {
+                rmSync(dir, { recursive: true, force: true });
+            }
+        }
+        if (existsSync(MCP_CONFIG)) {
+            try {
+                const config = JSON.parse(readFileSync(MCP_CONFIG, "utf8"));
+                delete config.mcpServers?.bluekiwi;
+                writeFileSync(MCP_CONFIG, JSON.stringify(config, null, 2));
+            }
+            catch { }
+        }
+    }
+}

package/dist/runtimes/opencode.js

@@ -0,0 +1,56 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const BASE = join(homedir(), ".opencode");
+const SKILLS_DIR = join(BASE, "skills");
+const MCP_CONFIG = join(BASE, "mcp.json");
+export class OpenCodeAdapter {
+    name = "opencode";
+    displayName = "OpenCode";
+    isInstalled() {
+        return existsSync(BASE);
+    }
+    getSkillsDir() {
+        return SKILLS_DIR;
+    }
+    getMcpConfigPath() {
+        return MCP_CONFIG;
+    }
+    installSkills(skills) {
+        mkdirSync(SKILLS_DIR, { recursive: true });
+        for (const skill of skills) {
+            const dir = join(SKILLS_DIR, skill.name);
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(join(dir, "SKILL.md"), skill.content);
+        }
+    }
+    installMcp(config) {
+        mkdirSync(BASE, { recursive: true });
+        let existing = {};
+        if (existsSync(MCP_CONFIG)) {
+            try {
+                existing = JSON.parse(readFileSync(MCP_CONFIG, "utf8"));
+            }
+            catch { }
+        }
+        existing.mcpServers = existing.mcpServers ?? {};
+        existing.mcpServers.bluekiwi = config;
+        writeFileSync(MCP_CONFIG, JSON.stringify(existing, null, 2));
+    }
+    uninstall() {
+        for (const name of ["bk-start", "bk-next", "bk-status", "bk-rewind"]) {
+            const dir = join(SKILLS_DIR, name);
+            if (existsSync(dir)) {
+                rmSync(dir, { recursive: true, force: true });
+            }
+        }
+        if (existsSync(MCP_CONFIG)) {
+            try {
+                const config = JSON.parse(readFileSync(MCP_CONFIG, "utf8"));
+                delete config.mcpServers?.bluekiwi;
+                writeFileSync(MCP_CONFIG, JSON.stringify(config, null, 2));
+            }
+            catch { }
+        }
+    }
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "bluekiwi",
+  "version": "0.1.0",
+  "description": "BlueKiwi CLI — install MCP client and skills into your agent runtime",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "bluekiwi": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/bundle-assets.mjs",
+    "dev": "tsc -p tsconfig.json --watch"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "prompts": "^2.4.2",
+    "picocolors": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/prompts": "^2.4.9",
+    "typescript": "^5.5.0"
+  }
+}