bluekiwi 0.3.18 → 0.3.19

package/dist/commands/accept.js

@@ -1,10 +1,12 @@
 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 { createEmptyConfig, loadConfig, normalizeProfileName, saveConfig, upsertProfile, } from "../config.js";
+import { applyProfileToRuntimes } from "../runtime-sync.js";
 import { detectInstalledAdapters, getAllAdapters } from "../runtimes/detect.js";
 export async function acceptCommand(token, opts) {
+    const profileName = normalizeProfileName(opts.profile);
+    const currentConfig = loadConfig() ?? createEmptyConfig();
     console.log(pc.cyan("→ Validating invite..."));
     const validateRes = await fetch(`${opts.server}/api/invites/accept/${token}`);
     if (!validateRes.ok) {
@@ -60,7 +62,8 @@ export async function acceptCommand(token, opts) {
         const choices = all.map((adapter) => ({
             title: adapter.displayName,
             value: adapter.name,
-            selected: detected.some((detectedAdapter) => detectedAdapter.name === adapter.name),
+            selected: currentConfig.runtimes.includes(adapter.name) ||
+                detected.some((detectedAdapter) => detectedAdapter.name === adapter.name),
             disabled: !adapter.isInstalled(),
         }));
         const { selected } = (await prompts({
@@ -72,31 +75,26 @@ export async function acceptCommand(token, opts) {
         }));
         chosen = selected ?? [];
     }
-    const all = getAllAdapters();
-    for (const name of chosen) {
-        const adapter = all.find((item) => item.name === name);
-        if (!adapter)
-            continue;
-        console.log(pc.cyan(`→ Installing to ${adapter.displayName}...`));
-        adapter.installSkills(BUNDLED_SKILLS);
-        adapter.installMcp({
-            command: "node",
-            args: [BUNDLED_MCP_PATH],
-            env: {
-                BLUEKIWI_API_URL: opts.server,
-                BLUEKIWI_API_KEY: result.api_key,
-            },
-        });
-    }
-    saveConfig({
-        version: "1.0.0",
+    const now = new Date().toISOString();
+    const targetProfile = {
+        name: profileName,
         server_url: opts.server,
         api_key: result.api_key,
         user: result.user,
-        runtimes: chosen,
-        installed_at: new Date().toISOString(),
-        last_used: new Date().toISOString(),
+        installed_at: now,
+        last_used: now,
+    };
+    const nextConfig = upsertProfile({
+        ...currentConfig,
+        runtimes: Array.from(new Set([...currentConfig.runtimes, ...chosen])),
+    }, targetProfile, {
+        activate: chosen.length > 0 || Object.keys(currentConfig.profiles).length === 0,
     });
+    if (chosen.length > 0) {
+        applyProfileToRuntimes(nextConfig, profileName, chosen);
+    }
+    saveConfig(nextConfig);
     console.log(pc.green("\n✓ BlueKiwi installed successfully!"));
+    console.log(pc.dim(`Profile: ${profileName}`));
     console.log(pc.dim("Try /bk-start in your agent runtime to begin."));
 }

package/dist/commands/init.js

@@ -1,8 +1,8 @@
 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 { loadConfig, saveConfig } from "../config.js";
+import { createEmptyConfig, getProfile, loadConfig, normalizeProfileName, saveConfig, upsertProfile, } from "../config.js";
+import { applyProfileToRuntimes } from "../runtime-sync.js";
 import { detectInstalledAdapters, getAllAdapters } from "../runtimes/detect.js";
 function normalizeEnvValue(value) {
     const trimmed = value?.trim();
@@ -37,8 +37,10 @@ function maskApiKey(key) {
 }
 export async function initCommand(options = {}) {
     const isNonInteractive = options.yes === true || process.stdin.isTTY !== true;
+    const profileName = normalizeProfileName(options.profile);
     // Load existing config for pre-filling prompts
-    const existingCfg = loadConfig();
+    const existingCfg = loadConfig() ?? createEmptyConfig();
+    const existingProfile = getProfile(existingCfg, profileName);
     let server = normalizeEnvValue(options.server) ??
         normalizeEnvValue(process.env.BLUEKIWI_API_URL) ??
         normalizeEnvValue(process.env.BLUEKIWI_SERVER);
@@ -51,12 +53,12 @@ export async function initCommand(options = {}) {
                 type: "text",
                 name: "server",
                 message: "BlueKiwi server URL",
-                initial: existingCfg?.server_url,
+                initial: existingProfile?.profile.server_url,
             });
         }
         if (apiKey === undefined) {
-            const maskedKey = existingCfg?.api_key
-                ? maskApiKey(existingCfg.api_key)
+            const maskedKey = existingProfile?.profile.api_key
+                ? maskApiKey(existingProfile.profile.api_key)
                 : undefined;
             questions.push({
                 type: "text",
@@ -72,11 +74,11 @@ export async function initCommand(options = {}) {
         // If user kept the masked key (just pressed Enter), restore original
         if (apiKey === undefined) {
             const entered = answers.apiKey;
-            const maskedKey = existingCfg?.api_key
-                ? maskApiKey(existingCfg.api_key)
+            const maskedKey = existingProfile?.profile.api_key
+                ? maskApiKey(existingProfile.profile.api_key)
                 : undefined;
             if (entered && maskedKey && entered === maskedKey) {
-                apiKey = existingCfg.api_key;
+                apiKey = existingProfile.profile.api_key;
             }
             else {
                 apiKey = entered;
@@ -91,7 +93,7 @@ export async function initCommand(options = {}) {
     }
     const client = new BlueKiwiClient(server, apiKey);
     await client.request("GET", "/api/workflows");
-    const me = {
+    const me = existingProfile?.profile.user ?? {
         id: 0,
         username: "unknown",
         email: "",
@@ -104,8 +106,9 @@ export async function initCommand(options = {}) {
     const requestedFromFlags = uniquePreserveOrder(parseCommaSeparatedList(options.runtimes));
     const requestedFromEnv = uniquePreserveOrder(parseCommaSeparatedList([process.env.BLUEKIWI_RUNTIMES ?? ""]));
     const requestedRuntimeNames = requestedFromFlags.length > 0 ? requestedFromFlags : requestedFromEnv;
+    const hasExplicitRuntimeSelection = requestedRuntimeNames.length > 0;
     let selectedRuntimeNames = [];
-    if (requestedRuntimeNames.length > 0) {
+    if (hasExplicitRuntimeSelection) {
         const unknown = requestedRuntimeNames.filter((name) => !adaptersByName.has(name));
         if (unknown.length > 0) {
             throw new Error(`Unknown runtime(s): ${unknown.join(", ")}. Valid runtimes: ${validRuntimeNames.join(", ")}`);
@@ -120,6 +123,9 @@ export async function initCommand(options = {}) {
         }
         selectedRuntimeNames = requestedRuntimeNames;
     }
+    else if (existingCfg.runtimes.length > 0) {
+        selectedRuntimeNames = existingCfg.runtimes;
+    }
     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");
@@ -140,25 +146,26 @@ export async function initCommand(options = {}) {
         }));
         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",
+    const now = new Date().toISOString();
+    const targetProfile = {
+        name: profileName,
         server_url: server,
         api_key: apiKey,
         user: me,
-        runtimes: selectedRuntimeNames,
-        installed_at: new Date().toISOString(),
-        last_used: new Date().toISOString(),
-    });
+        installed_at: existingProfile?.profile.installed_at ?? now,
+        last_used: now,
+    };
+    const shouldActivate = hasExplicitRuntimeSelection ||
+        existingCfg.active_profile === profileName ||
+        Object.keys(existingCfg.profiles).length === 0;
+    const nextConfig = upsertProfile({
+        ...existingCfg,
+        runtimes: Array.from(new Set([...existingCfg.runtimes, ...selectedRuntimeNames])),
+    }, targetProfile, { activate: shouldActivate });
+    if (shouldActivate && nextConfig.runtimes.length > 0) {
+        applyProfileToRuntimes(nextConfig, profileName, nextConfig.runtimes);
+    }
+    saveConfig(nextConfig);
     console.log(pc.green("✓ BlueKiwi connected"));
+    console.log(pc.dim(`Profile: ${profileName}`));
 }

package/dist/commands/logout.js

@@ -1,12 +1,33 @@
 import pc from "picocolors";
-import { clearConfig, loadConfig } from "../config.js";
+import { clearConfig, loadConfig, removeProfile, saveConfig } from "../config.js";
 import { getAllAdapters } from "../runtimes/detect.js";
-export async function logoutCommand() {
+import { applyProfileToRuntimes } from "../runtime-sync.js";
+export async function logoutCommand(profileName) {
     const cfg = loadConfig();
     if (!cfg) {
         console.log(pc.yellow("Already logged out."));
         return;
     }
+    if (profileName) {
+        const next = removeProfile(cfg, profileName);
+        if (!next) {
+            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(`✓ Removed profile '${profileName}' and logged out.`));
+            return;
+        }
+        saveConfig(next);
+        if (profileName === cfg.active_profile && next.runtimes.length > 0) {
+            applyProfileToRuntimes(next, next.active_profile);
+        }
+        console.log(pc.green(`✓ Removed profile '${profileName}'. Active profile: ${next.active_profile}`));
+        return;
+    }
     for (const adapter of getAllAdapters()) {
         if (cfg.runtimes.includes(adapter.name)) {
             adapter.uninstall();

package/dist/commands/profile.js

@@ -0,0 +1,50 @@
+import pc from "picocolors";
+import { clearConfig, loadConfig, removeProfile, requireConfig, requireProfile, saveConfig, } from "../config.js";
+import { getAllAdapters } from "../runtimes/detect.js";
+import { applyProfileToRuntimes } from "../runtime-sync.js";
+async function list() {
+    const cfg = loadConfig();
+    if (!cfg) {
+        console.log(pc.yellow("No profiles configured."));
+        return;
+    }
+    for (const [name, profile] of Object.entries(cfg.profiles)) {
+        const marker = name === cfg.active_profile ? pc.green("●") : pc.dim("○");
+        console.log(`${marker} ${name}  ${pc.dim(profile.server_url)}  ${profile.user.username} (${profile.user.role})`);
+    }
+}
+async function use(name) {
+    const cfg = requireConfig();
+    requireProfile(cfg, name);
+    const next = {
+        ...cfg,
+        active_profile: name,
+    };
+    if (next.runtimes.length > 0) {
+        applyProfileToRuntimes(next, name);
+    }
+    saveConfig(next);
+    console.log(pc.green(`✓ Active profile switched to '${name}'`));
+}
+async function remove(name) {
+    const cfg = requireConfig();
+    requireProfile(cfg, name);
+    const next = removeProfile(cfg, name);
+    if (!next) {
+        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(`✓ Removed profile '${name}' and cleared config.`));
+        return;
+    }
+    saveConfig(next);
+    if (cfg.active_profile === name && next.runtimes.length > 0) {
+        applyProfileToRuntimes(next, next.active_profile);
+    }
+    console.log(pc.green(`✓ Removed profile '${name}'`));
+}
+export const profileCommand = { list, use, remove };

package/dist/commands/runtimes.js

@@ -1,7 +1,7 @@
 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";
+import { loadConfig, requireConfig, requireProfile, saveConfig, } from "../config.js";
+import { applyProfileToRuntimes } from "../runtime-sync.js";
 async function list() {
     const cfg = loadConfig();
     const installed = new Set(cfg?.runtimes ?? []);
@@ -15,23 +15,21 @@ async function list() {
         console.log(`${adapter.displayName.padEnd(14)} ${detected}  ${active}`);
     }
 }
-async function add(name) {
+async function add(name, profileName) {
     const cfg = requireConfig();
+    const { name: resolvedProfile } = requireProfile(cfg, profileName);
     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({
+    const next = {
         ...cfg,
+        active_profile: resolvedProfile,
         runtimes: Array.from(new Set([...cfg.runtimes, name])),
-    });
+    };
+    applyProfileToRuntimes(next, resolvedProfile, [name]);
+    saveConfig(next);
     console.log(pc.green(`✓ Installed to ${adapter.displayName}`));
 }
 async function remove(name) {

package/dist/commands/status.js

@@ -1,17 +1,19 @@
 import pc from "picocolors";
 import { BlueKiwiClient } from "../api-client.js";
-import { CONFIG_PATH, loadConfig } from "../config.js";
-export async function statusCommand() {
+import { CONFIG_PATH, loadConfig, requireProfile } from "../config.js";
+export async function statusCommand(profileName) {
     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})`);
+    const { name, profile } = requireProfile(cfg, profileName);
+    console.log(`${pc.bold("Profile:")}  ${name}${name === cfg.active_profile ? " (active)" : ""}`);
+    console.log(`${pc.bold("Server:")}   ${profile.server_url}`);
+    console.log(`${pc.bold("User:")}     ${profile.user.username} (${profile.user.role})`);
     console.log(`${pc.bold("Runtimes:")} ${cfg.runtimes.join(", ") || "(none)"}`);
     try {
-        const client = new BlueKiwiClient(cfg.server_url, cfg.api_key);
+        const client = new BlueKiwiClient(profile.server_url, profile.api_key);
         await client.request("GET", "/api/workflows");
         console.log(pc.green("✓ Connection OK"));
     }

package/dist/commands/upgrade.js

@@ -1,8 +1,7 @@
 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";
+import { applyProfileToRuntimes, pruneBundledSkills } from "../runtime-sync.js";
 export async function upgradeCommand() {
     console.log(pc.cyan("→ Upgrading bluekiwi..."));
     execFileSync("npm", ["install", "-g", "bluekiwi@latest"], {
@@ -13,18 +12,20 @@ export async function upgradeCommand() {
         console.log(pc.yellow("No config found. Run `bluekiwi accept` or `bluekiwi init` next."));
         return;
     }
-    const bundledNames = new Set(BUNDLED_SKILLS.map((s) => s.name));
-    for (const adapter of getAllAdapters()) {
-        if (!cfg.runtimes.includes(adapter.name))
-            continue;
-        adapter.installSkills(BUNDLED_SKILLS);
-        adapter.pruneSkills(bundledNames);
-        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() });
+    pruneBundledSkills(cfg);
+    applyProfileToRuntimes(cfg, cfg.active_profile);
+    const active = cfg.profiles[cfg.active_profile];
+    saveConfig({
+        ...cfg,
+        profiles: active
+            ? {
+                ...cfg.profiles,
+                [cfg.active_profile]: {
+                    ...active,
+                    last_used: new Date().toISOString(),
+                },
+            }
+            : cfg.profiles,
+    });
     console.log(pc.green("✓ Upgraded and reinstalled assets."));
 }

package/dist/config.js

@@ -1,20 +1,126 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync, unlinkSync, } from "fs";
 import { homedir } from "os";
 import { join, dirname } from "path";
+const CONFIG_VERSION = "2.0.0";
+export const DEFAULT_PROFILE = "default";
 export const CONFIG_PATH = join(homedir(), ".bluekiwi", "config.json");
+function nowIso() {
+    return new Date().toISOString();
+}
+function coerceUser(value) {
+    const raw = (value ?? {});
+    return {
+        id: typeof raw.id === "number" ? raw.id : 0,
+        username: typeof raw.username === "string" ? raw.username : "unknown",
+        email: typeof raw.email === "string" ? raw.email : "",
+        role: typeof raw.role === "string" ? raw.role : "viewer",
+    };
+}
+function coerceRuntimes(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
+}
+function normalizeProfileName(name) {
+    const trimmed = name?.trim();
+    return trimmed ? trimmed : DEFAULT_PROFILE;
+}
+function isLegacyConfig(value) {
+    const raw = value;
+    return !!raw && typeof raw.server_url === "string" && typeof raw.api_key === "string";
+}
+function normalizeProfile(name, raw) {
+    if (!raw ||
+        typeof raw.server_url !== "string" ||
+        typeof raw.api_key !== "string") {
+        return null;
+    }
+    return {
+        name,
+        server_url: raw.server_url,
+        api_key: raw.api_key,
+        user: coerceUser(raw.user),
+        installed_at: typeof raw.installed_at === "string" ? raw.installed_at : nowIso(),
+        last_used: typeof raw.last_used === "string" ? raw.last_used : nowIso(),
+    };
+}
+function migrateLegacyConfig(raw) {
+    const profile = normalizeProfile(DEFAULT_PROFILE, {
+        name: DEFAULT_PROFILE,
+        server_url: raw.server_url,
+        api_key: raw.api_key,
+        user: raw.user,
+        installed_at: raw.installed_at,
+        last_used: raw.last_used,
+    });
+    return {
+        version: CONFIG_VERSION,
+        active_profile: DEFAULT_PROFILE,
+        profiles: profile ? { [DEFAULT_PROFILE]: profile } : {},
+        runtimes: coerceRuntimes(raw.runtimes),
+    };
+}
+function normalizeConfig(raw) {
+    if (isLegacyConfig(raw)) {
+        return migrateLegacyConfig(raw);
+    }
+    const value = raw;
+    if (!value || typeof value !== "object" || value.profiles == null) {
+        return null;
+    }
+    const profiles = {};
+    for (const [name, profileValue] of Object.entries(value.profiles)) {
+        const normalized = normalizeProfile(name, profileValue);
+        if (normalized)
+            profiles[name] = normalized;
+    }
+    const profileNames = Object.keys(profiles);
+    if (profileNames.length === 0)
+        return null;
+    const requestedActive = typeof value.active_profile === "string" ? value.active_profile : undefined;
+    const activeProfile = profiles[requestedActive ?? ""]
+        ? requestedActive
+        : profiles[DEFAULT_PROFILE]
+            ? DEFAULT_PROFILE
+            : profileNames[0];
+    return {
+        version: typeof value.version === "string" ? value.version : CONFIG_VERSION,
+        active_profile: activeProfile,
+        profiles,
+        runtimes: coerceRuntimes(value.runtimes),
+    };
+}
 export function loadConfig() {
     if (!existsSync(CONFIG_PATH))
         return null;
     try {
-        return JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+        const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+        const normalized = normalizeConfig(raw);
+        if (!normalized)
+            return null;
+        if (JSON.stringify(raw, null, 2) !== JSON.stringify(normalized, null, 2)) {
+            saveConfig(normalized);
+        }
+        return normalized;
     }
     catch {
         return null;
     }
 }
+export function createEmptyConfig() {
+    return {
+        version: CONFIG_VERSION,
+        active_profile: DEFAULT_PROFILE,
+        profiles: {},
+        runtimes: [],
+    };
+}
 export function saveConfig(config) {
     mkdirSync(dirname(CONFIG_PATH), { recursive: true, mode: 0o700 });
-    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+    writeFileSync(CONFIG_PATH, JSON.stringify({
+        ...config,
+        version: CONFIG_VERSION,
+    }, null, 2), { mode: 0o600 });
     chmodSync(CONFIG_PATH, 0o600);
 }
 export function clearConfig() {
@@ -28,3 +134,51 @@ export function requireConfig() {
     }
     return config;
 }
+export function getProfile(config, profileName) {
+    const resolved = normalizeProfileName(profileName ?? config.active_profile);
+    const profile = config.profiles[resolved];
+    if (!profile)
+        return null;
+    return { name: resolved, profile };
+}
+export function requireProfile(config, profileName) {
+    const resolved = getProfile(config, profileName);
+    if (!resolved) {
+        throw new Error(`Unknown profile '${normalizeProfileName(profileName)}'. Use \`bluekiwi profile list\` to see configured profiles.`);
+    }
+    return resolved;
+}
+export function upsertProfile(config, profile, options) {
+    const next = {
+        ...config,
+        profiles: {
+            ...config.profiles,
+            [profile.name]: profile,
+        },
+    };
+    if (options?.activate) {
+        next.active_profile = profile.name;
+    }
+    else if (!next.active_profile) {
+        next.active_profile = profile.name;
+    }
+    return next;
+}
+export function removeProfile(config, profileName) {
+    const nextProfiles = { ...config.profiles };
+    delete nextProfiles[profileName];
+    const remaining = Object.keys(nextProfiles);
+    if (remaining.length === 0)
+        return null;
+    const nextActive = config.active_profile === profileName
+        ? nextProfiles[DEFAULT_PROFILE]
+            ? DEFAULT_PROFILE
+            : remaining[0]
+        : config.active_profile;
+    return {
+        ...config,
+        active_profile: nextActive,
+        profiles: nextProfiles,
+    };
+}
+export { normalizeProfileName };

package/dist/index.js

@@ -8,6 +8,7 @@ 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";
+import { profileCommand } from "./commands/profile.js";
 const require = createRequire(import.meta.url);
 const pkg = require("../package.json");
 function splitCommaSeparatedList(value) {
@@ -27,6 +28,7 @@ program
 program
     .command("accept <token>")
     .requiredOption("--server <url>", "BlueKiwi server URL")
+    .option("--profile <name>", "Profile name (default: default)")
     .option("--username <name>", "Username (non-interactive)")
     .option("--password <pass>", "Password (non-interactive)")
     .action(acceptCommand);
@@ -34,20 +36,35 @@ program
     .command("init")
     .option("--server <url>", "BlueKiwi server URL")
     .option("--api-key <key>", "API key (bk_...)")
+    .option("--profile <name>", "Profile name (default: default)")
     .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,
+    profile: opts.profile,
     yes: opts.yes,
 }));
-program.command("status").action(statusCommand);
+program
+    .command("status")
+    .option("--profile <name>", "Profile name (default: active profile)")
+    .action((opts) => statusCommand(opts.profile));
 program.command("upgrade").action(upgradeCommand);
-program.command("logout").action(logoutCommand);
+program
+    .command("logout")
+    .option("--profile <name>", "Remove only one profile")
+    .action((opts) => logoutCommand(opts.profile));
 program.command("runtimes").action(runtimesCommand.list);
-program.command("runtimes:add <name>").action(runtimesCommand.add);
+program
+    .command("runtimes:add <name>")
+    .option("--profile <name>", "Profile to install into runtimes and set active")
+    .action((name, opts) => runtimesCommand.add(name, opts.profile));
 program.command("runtimes:remove <name>").action(runtimesCommand.remove);
+program.command("profile").action(profileCommand.list);
+program.command("profile:list").action(profileCommand.list);
+program.command("profile:use <name>").action(profileCommand.use);
+program.command("profile:remove <name>").action(profileCommand.remove);
 program.command("dev-link").action(devLinkCommand);
 program.parseAsync(process.argv).catch((err) => {
     console.error(err.message);

package/dist/runtime-sync.js

@@ -0,0 +1,34 @@
+import { BUNDLED_MCP_PATH, BUNDLED_SKILLS } from "./assets/index.js";
+import { requireProfile, } from "./config.js";
+import { getAllAdapters } from "./runtimes/detect.js";
+export function applyProfileToRuntimes(config, profileName, runtimeNames) {
+    const { profile } = requireProfile(config, profileName);
+    const targetNames = runtimeNames ?? config.runtimes;
+    const allAdapters = getAllAdapters();
+    const installed = [];
+    for (const name of targetNames) {
+        const adapter = allAdapters.find((item) => item.name === name);
+        if (!adapter)
+            continue;
+        adapter.installSkills(BUNDLED_SKILLS);
+        adapter.installMcp({
+            command: "node",
+            args: [BUNDLED_MCP_PATH],
+            env: {
+                BLUEKIWI_API_URL: profile.server_url,
+                BLUEKIWI_API_KEY: profile.api_key,
+            },
+        });
+        installed.push(name);
+    }
+    return installed;
+}
+export function pruneBundledSkills(config) {
+    const bundledNames = new Set(BUNDLED_SKILLS.map((skill) => skill.name));
+    for (const adapter of getAllAdapters()) {
+        if (!config.runtimes.includes(adapter.name))
+            continue;
+        adapter.installSkills(BUNDLED_SKILLS);
+        adapter.pruneSkills(bundledNames);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bluekiwi",
-  "version": "0.3.18",
+  "version": "0.3.19",
   "description": "BlueKiwi CLI — install MCP client and skills into your agent runtime",
   "license": "MIT",
   "repository": {