babyclaw 0.0.0

package/build/cli.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { run, help } from "@gud/cli";
+await run({
+    plugins: [help()],
+});

package/build/commands/config/edit.js

@@ -0,0 +1,34 @@
+import { command } from "@gud/cli";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { execSync } from "node:child_process";
+import { getConfigPath } from "@babyclaw/gateway";
+import { c } from "../../ui/theme.js";
+export default command({
+    description: "Open config in your editor",
+    handler: async ({ client }) => {
+        const configPath = getConfigPath();
+        if (!existsSync(configPath)) {
+            client.log(c.error("✗ No config file found at:"));
+            client.log(c.muted(`  ${configPath}`));
+            client.log(c.muted("  Run ") + c.info("babyclaw config init") + c.muted(" first."));
+            process.exitCode = 1;
+            return;
+        }
+        const editor = process.env["EDITOR"] || process.env["VISUAL"] || "vi";
+        try {
+            execSync(`${editor} ${JSON.stringify(configPath)}`, {
+                stdio: "inherit",
+            });
+        }
+        catch {
+            const content = await readFile(configPath, "utf8");
+            process.stdout.write(`\nCurrent config at ${configPath}:\n\n`);
+            process.stdout.write(content);
+            process.stdout.write("\nEdit this file manually, then run 'babyclaw config validate'.\n");
+            return;
+        }
+        client.log(c.success("✓ Editor closed."));
+        client.log(c.muted("  Run ") + c.info("babyclaw config validate") + c.muted(" to check for issues."));
+    },
+});

package/build/commands/config/init.js

@@ -0,0 +1,44 @@
+import { command } from "@gud/cli";
+import { existsSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { getConfigPath, getDefaultConfigTemplate } from "@babyclaw/gateway";
+import { c } from "../../ui/theme.js";
+export default command({
+    description: "Create a fresh configuration file",
+    options: {
+        force: {
+            type: "boolean",
+            description: "Overwrite existing config file",
+        },
+    },
+    handler: async ({ options, client }) => {
+        const force = await options.force();
+        const configPath = getConfigPath();
+        try {
+            if (existsSync(configPath) && !force) {
+                client.log(c.warning("⚠ Config file already exists at:"));
+                client.log(c.muted(`  ${configPath}`));
+                const overwrite = await client.confirm("Overwrite existing config?", false);
+                if (!overwrite)
+                    return;
+            }
+            await mkdir(dirname(configPath), { recursive: true });
+            await writeFile(configPath, getDefaultConfigTemplate(), "utf8");
+            client.log(c.success("✓ Config created!"));
+            client.log(c.muted(`  ${configPath}`));
+            client.log(c.muted("  Next: run ") +
+                c.info("babyclaw model configure") +
+                c.muted(" to set up AI providers, or edit ") +
+                c.info("channels.telegram.botToken") +
+                c.muted(" and ") +
+                c.info("ai.providers") +
+                c.muted(" manually."));
+        }
+        catch (error) {
+            client.log(c.error("✗ Failed to create config"));
+            client.log(c.muted(error instanceof Error ? error.message : String(error)));
+            process.exitCode = 1;
+        }
+    },
+});

package/build/commands/config/validate.js

@@ -0,0 +1,51 @@
+import { command } from "@gud/cli";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { getConfigPath, babyclawConfigSchema } from "@babyclaw/gateway";
+import { c } from "../../ui/theme.js";
+export default command({
+    description: "Validate your current config",
+    handler: async ({ client }) => {
+        const configPath = getConfigPath();
+        try {
+            if (!existsSync(configPath)) {
+                client.log(c.error("✗ No config file found at:"));
+                client.log(c.muted(`  ${configPath}`));
+                client.log(c.muted("  Run ") + c.info("babyclaw config init") + c.muted(" to create one."));
+                process.exitCode = 1;
+                return;
+            }
+            const raw = await readFile(configPath, "utf8");
+            let json;
+            try {
+                json = JSON.parse(raw);
+            }
+            catch {
+                client.log(c.error("✗ Config is invalid"));
+                client.log(c.muted(`  ${configPath}`));
+                client.log(c.warning("  • Config file is not valid JSON."));
+                process.exitCode = 1;
+                return;
+            }
+            const result = babyclawConfigSchema.safeParse(json);
+            if (result.success) {
+                client.log(c.success("✓ Config is valid!"));
+                client.log(c.muted(`  ${configPath}`));
+            }
+            else {
+                client.log(c.error("✗ Config is invalid"));
+                client.log(c.muted(`  ${configPath}`));
+                for (const issue of result.error.issues) {
+                    const path = issue.path.length > 0 ? issue.path.map(String).join(".") : "$";
+                    client.log(c.warning(`  • ${path}: ${issue.message}`));
+                }
+                process.exitCode = 1;
+            }
+        }
+        catch (error) {
+            client.log(c.error("✗ Error reading config"));
+            client.log(c.muted(error instanceof Error ? error.message : String(error)));
+            process.exitCode = 1;
+        }
+    },
+});

package/build/commands/doctor.js

@@ -0,0 +1,121 @@
+import { command } from "@gud/cli";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { AdminClient, getAdminSocketPath, getConfigPath, babyclawConfigSchema, } from "@babyclaw/gateway";
+import { c } from "../ui/theme.js";
+import { getStatus as getServiceStatus } from "../service/adapter.js";
+function icon(status) {
+    if (status === "pass")
+        return c.success("✓");
+    if (status === "warn")
+        return c.warning("⚠");
+    return c.error("✗");
+}
+export default command({
+    description: "Run diagnostics on your setup",
+    handler: async ({ client }) => {
+        const checks = [];
+        const configPath = getConfigPath();
+        if (existsSync(configPath)) {
+            checks.push({
+                label: "Config file exists",
+                status: "pass",
+                detail: configPath,
+            });
+            try {
+                const raw = await readFile(configPath, "utf8");
+                const json = JSON.parse(raw);
+                const parsed = babyclawConfigSchema.safeParse(json);
+                if (parsed.success) {
+                    checks.push({ label: "Config passes validation", status: "pass" });
+                }
+                else {
+                    const count = parsed.error.issues.length;
+                    checks.push({
+                        label: "Config passes validation",
+                        status: "fail",
+                        detail: `${count} issue${count === 1 ? "" : "s"} found`,
+                    });
+                }
+            }
+            catch {
+                checks.push({
+                    label: "Config passes validation",
+                    status: "fail",
+                    detail: "Invalid JSON",
+                });
+            }
+        }
+        else {
+            checks.push({
+                label: "Config file exists",
+                status: "fail",
+                detail: `Not found at ${configPath}`,
+            });
+            checks.push({
+                label: "Config passes validation",
+                status: "fail",
+                detail: "No config to validate",
+            });
+        }
+        try {
+            const info = getServiceStatus();
+            checks.push({
+                label: "Service installed",
+                status: info.installed ? "pass" : "warn",
+                detail: info.installed ? `${info.platform}` : "Not installed yet",
+            });
+            checks.push({
+                label: "Service running",
+                status: info.running ? "pass" : "warn",
+                detail: info.running ? `PID ${info.pid}` : "Not running",
+            });
+        }
+        catch {
+            checks.push({
+                label: "Service installed",
+                status: "warn",
+                detail: "Could not check (unsupported platform?)",
+            });
+        }
+        try {
+            const adminClient = new AdminClient({
+                socketPath: getAdminSocketPath(),
+            });
+            const status = await adminClient.status();
+            checks.push({
+                label: "Gateway admin socket reachable",
+                status: "pass",
+                detail: `State: ${status.state}`,
+            });
+        }
+        catch {
+            checks.push({
+                label: "Gateway admin socket reachable",
+                status: "warn",
+                detail: "Not reachable (gateway may not be running)",
+            });
+        }
+        const passCount = checks.filter((ck) => ck.status === "pass").length;
+        const failCount = checks.filter((ck) => ck.status === "fail").length;
+        const warnCount = checks.filter((ck) => ck.status === "warn").length;
+        client.log(c.bold(" 🩺 babyclaw doctor"));
+        client.log("");
+        for (const check of checks) {
+            const detail = check.detail ? c.muted(` — ${check.detail}`) : "";
+            client.log(`  ${icon(check.status)} ${check.label}${detail}`);
+        }
+        client.log("");
+        if (failCount === 0 && warnCount === 0) {
+            client.log(c.success("  All clear! Your claw is in perfect shape. 🦀"));
+        }
+        else {
+            let summary = c.success(`${passCount} passed`);
+            if (warnCount > 0)
+                summary += c.warning(` · ${warnCount} warning${warnCount > 1 ? "s" : ""}`);
+            if (failCount > 0)
+                summary += c.error(` · ${failCount} failed`);
+            client.log(`  ${summary}`);
+        }
+    },
+});

package/build/commands/gateway/reload.js

@@ -0,0 +1,23 @@
+import { command } from "@gud/cli";
+import { AdminClient, getAdminSocketPath } from "@babyclaw/gateway";
+import { c } from "../../ui/theme.js";
+export default command({
+    description: "Check gateway health / signal a reload",
+    handler: async ({ client }) => {
+        try {
+            const adminClient = new AdminClient({
+                socketPath: getAdminSocketPath(),
+            });
+            await adminClient.health();
+            client.log(c.success("✓ Gateway is alive. Config reload requires a service restart for now."));
+            client.log(c.muted("  Run ") +
+                c.info("babyclaw service restart") +
+                c.muted(" to apply config changes."));
+        }
+        catch (err) {
+            client.log(c.error("✗ Could not reach the gateway"));
+            client.log(c.muted(`  ${err instanceof Error ? err.message : String(err)}`));
+            process.exitCode = 1;
+        }
+    },
+});

package/build/commands/gateway/status.js

@@ -0,0 +1,38 @@
+import { command } from "@gud/cli";
+import { AdminClient, getAdminSocketPath } from "@babyclaw/gateway";
+import { c, formatUptime } from "../../ui/theme.js";
+export default command({
+    description: "Query the running gateway for live status",
+    options: {
+        json: { type: "boolean", description: "Output raw JSON" },
+    },
+    handler: async ({ options, client }) => {
+        const json = await options.json();
+        try {
+            const adminClient = new AdminClient({
+                socketPath: getAdminSocketPath(),
+            });
+            const data = await adminClient.status();
+            if (json) {
+                client.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            const uptime = data.uptimeMs != null ? formatUptime(data.uptimeMs) : "—";
+            client.log(`${c.success("●")} Gateway is ${c.success(data.state)}`);
+            client.log(`  ${c.muted("PID     ")}${data.pid}`);
+            client.log(`  ${c.muted("Uptime  ")}${uptime}`);
+            client.log(`  ${c.muted("Version ")}${data.version}`);
+        }
+        catch (err) {
+            if (json) {
+                client.log(JSON.stringify({
+                    state: "stopped",
+                    error: err instanceof Error ? err.message : String(err),
+                }, null, 2));
+                return;
+            }
+            client.log(`${c.error("●")} Gateway is ${c.error(c.bold("not running"))}`);
+            client.log(c.muted(`  ${err instanceof Error ? err.message : String(err)}`));
+        }
+    },
+});

package/build/commands/index.js

@@ -0,0 +1,37 @@
+import { command } from "@gud/cli";
+import { c, getRandomBanner, getRandomTip } from "../ui/theme.js";
+export default command({
+    description: "Your friendly neighborhood agent gateway",
+    handler: async ({ client }) => {
+        client.log(c.brand(getRandomBanner()));
+        const pad = (cmd, width) => cmd + " ".repeat(Math.max(1, width - cmd.length));
+        const cmds = [
+            ["config init", "Create a fresh configuration file"],
+            ["config validate", "Validate your current config"],
+            ["config edit", "Open config in your editor"],
+            ["service install", "Install the gateway as a system service"],
+            ["service uninstall", "Uninstall the gateway system service"],
+            ["service status", "Check if the gateway service is installed/running"],
+            ["service start", "Start the gateway service"],
+            ["service stop", "Stop the gateway service"],
+            ["service restart", "Restart the gateway service"],
+            ["model", "Show current model configuration"],
+            ["model configure", "Interactive model provider setup wizard"],
+            ["model alias", "List model aliases"],
+            ["model alias set", "Create or update a model alias"],
+            ["model alias remove", "Remove a model alias"],
+            ["gateway status", "Query the running gateway for live status"],
+            ["gateway reload", "Check gateway health / signal a reload"],
+            ["skill install", "Install a skill from ClawHub"],
+            ["skill search", "Search for skills on ClawHub"],
+            ["doctor", "Run diagnostics on your setup"],
+        ];
+        client.log("");
+        client.log("   " + c.bold("Commands:"));
+        for (const [name, desc] of cmds) {
+            client.log(`   ${c.info(pad(name, 20))}${c.muted("· ")}${desc}`);
+        }
+        client.log("");
+        client.log(`   ${c.muted(`💡 tip: ${getRandomTip()}`)}`);
+    },
+});

package/build/commands/model/alias/index.js

@@ -0,0 +1,27 @@
+import { command } from "@gud/cli";
+import { getConfigPath, loadConfigRaw } from "@babyclaw/gateway";
+import { c } from "../../../ui/theme.js";
+export default command({
+    description: "List model aliases",
+    handler: async ({ client }) => {
+        const config = await loadConfigRaw();
+        if (!config) {
+            client.log(c.error(`No valid config found at ${getConfigPath()}`));
+            client.log(c.muted("  Run ") + c.info("babyclaw config init") + c.muted(" first."));
+            process.exitCode = 1;
+            return;
+        }
+        const entries = Object.entries(config.ai.aliases);
+        client.log(c.bold(" Model Aliases"));
+        if (entries.length === 0) {
+            client.log(c.muted("  No aliases configured. Use ") +
+                c.info("babyclaw model alias set") +
+                c.muted(" to create one."));
+        }
+        else {
+            for (const [name, ref] of entries) {
+                client.log(`  ${c.warning(c.bold(name))}${c.muted(" → ")}${ref}`);
+            }
+        }
+    },
+});

package/build/commands/model/alias/remove.js

@@ -0,0 +1,52 @@
+import { command } from "@gud/cli";
+import { getConfigPath, loadConfigRaw, writeConfig } from "@babyclaw/gateway";
+import { c } from "../../../ui/theme.js";
+export default command({
+    description: "Remove a model alias",
+    options: {
+        name: {
+            type: "string",
+            description: "Alias name to remove",
+        },
+    },
+    handler: async ({ options, client }) => {
+        try {
+            const config = await loadConfigRaw();
+            if (!config) {
+                client.log(c.error(`No valid config found at ${getConfigPath()}`));
+                client.log(c.muted("  Run ") + c.info("babyclaw config init") + c.muted(" first."));
+                process.exitCode = 1;
+                return;
+            }
+            const entries = Object.entries(config.ai.aliases);
+            let name = await options.name();
+            if (!name) {
+                if (entries.length === 0) {
+                    client.log(c.muted("No aliases configured. Nothing to remove."));
+                    return;
+                }
+                name = (await client.prompt({
+                    type: "select",
+                    message: "Select alias to remove",
+                    choices: entries.map(([n, ref]) => ({
+                        title: `${n} ${c.muted(`→ ${ref}`)}`,
+                        value: n,
+                    })),
+                }));
+            }
+            if (!(name in config.ai.aliases)) {
+                client.log(c.warning(`Alias ${c.bold(name)} does not exist.`));
+                client.log(c.muted("  Run ") + c.info("babyclaw model alias") + c.muted(" to see current aliases."));
+                return;
+            }
+            delete config.ai.aliases[name];
+            await writeConfig({ config });
+            client.log(c.success(`Removed alias ${c.bold(name)}`));
+        }
+        catch (err) {
+            client.log(c.error("Failed to remove alias"));
+            client.log(c.muted(err instanceof Error ? err.message : String(err)));
+            process.exitCode = 1;
+        }
+    },
+});

package/build/commands/model/alias/set.js

@@ -0,0 +1,63 @@
+import { command } from "@gud/cli";
+import { getConfigPath, loadConfigRaw, writeConfig } from "@babyclaw/gateway";
+import { c } from "../../../ui/theme.js";
+export default command({
+    description: "Create or update a model alias",
+    options: {
+        name: {
+            type: "string",
+            description: "Alias name (e.g. fast, smart)",
+            required: true,
+        },
+        model: {
+            type: "string",
+            description: "Model reference in provider:modelId format",
+            required: true,
+        },
+    },
+    handler: async ({ options, client }) => {
+        const name = await options.name({
+            prompt: "Alias name",
+            validate: (val) => {
+                if (!val)
+                    return "Alias name is required";
+                const cleaned = val.toLowerCase().replace(/[^a-z0-9_-]/g, "");
+                if (!cleaned)
+                    return "Use only lowercase letters, numbers, hyphens, and underscores";
+                return true;
+            },
+        });
+        const model = await options.model({
+            prompt: "Model reference (provider:modelId)",
+            validate: (val) => {
+                if (!val)
+                    return "Model reference is required";
+                if (!val.includes(":"))
+                    return "Expected format: provider:modelId";
+                return true;
+            },
+        });
+        try {
+            const config = await loadConfigRaw();
+            if (!config) {
+                client.log(c.error(`No valid config found at ${getConfigPath()}`));
+                client.log(c.muted("  Run ") + c.info("babyclaw config init") + c.muted(" first."));
+                process.exitCode = 1;
+                return;
+            }
+            const aliasName = name.toLowerCase().replace(/[^a-z0-9_-]/g, "");
+            const wasUpdate = aliasName in config.ai.aliases;
+            config.ai.aliases[aliasName] = model;
+            await writeConfig({ config });
+            client.log(c.success(`${wasUpdate ? "Updated" : "Created"} alias `) +
+                c.warning(c.bold(aliasName)) +
+                c.muted(" → ") +
+                model);
+        }
+        catch (err) {
+            client.log(c.error("Failed to set alias"));
+            client.log(c.muted(err instanceof Error ? err.message : String(err)));
+            process.exitCode = 1;
+        }
+    },
+});

package/build/commands/model/configure.js

@@ -0,0 +1,154 @@
+import { command } from "@gud/cli";
+import { getConfigPath, loadConfigRaw, writeConfig, getDefaultConfigTemplate, babyclawConfigSchema, SUPPORTED_PROVIDERS, } from "@babyclaw/gateway";
+import { c } from "../../ui/theme.js";
+export default command({
+    description: "Interactive model provider setup wizard",
+    handler: async ({ client }) => {
+        let baseConfig;
+        const existing = await loadConfigRaw();
+        if (existing) {
+            baseConfig = existing;
+        }
+        else {
+            const template = JSON.parse(getDefaultConfigTemplate());
+            baseConfig = babyclawConfigSchema.parse(template);
+        }
+        const providers = existing
+            ? Object.entries(existing.ai.providers).map(([id, cfg]) => ({
+                id,
+                apiKey: cfg.apiKey,
+                baseUrl: cfg.baseUrl ?? "",
+            }))
+            : [];
+        let chatModel = baseConfig.ai.models.chat;
+        let addingProviders = true;
+        while (addingProviders) {
+            const providerChoices = SUPPORTED_PROVIDERS.map((p) => {
+                const configured = providers.find((e) => e.id === p.id);
+                return {
+                    title: configured ? `${p.displayName} (configured)` : p.displayName,
+                    value: p.id,
+                };
+            });
+            providerChoices.push({
+                title: providers.length > 0 ? "Done adding providers →" : "(add at least one provider first)",
+                value: "__done__",
+            });
+            client.log("");
+            client.log(c.bold(" Model Provider Setup"));
+            if (providers.length > 0) {
+                client.log(c.muted(`  Configured: ${providers.map((p) => p.id).join(", ")}`));
+            }
+            const selected = await client.prompt({
+                type: "select",
+                message: "Select a provider to configure (or Done when finished)",
+                choices: providerChoices,
+            });
+            if (selected === "__done__") {
+                if (providers.length === 0) {
+                    client.log(c.warning("  Add at least one provider before continuing."));
+                    continue;
+                }
+                addingProviders = false;
+                continue;
+            }
+            const providerId = selected;
+            const meta = SUPPORTED_PROVIDERS.find((p) => p.id === providerId);
+            const existingEntry = providers.find((p) => p.id === providerId);
+            client.log(c.bold(`  Configure ${meta?.displayName ?? providerId}`));
+            const apiKey = await client.prompt({
+                type: "password",
+                message: "API Key",
+                initial: existingEntry?.apiKey,
+            });
+            const baseUrl = await client.prompt({
+                type: "text",
+                message: "Base URL (leave empty for default)",
+                initial: existingEntry?.baseUrl,
+            });
+            const entry = {
+                id: providerId,
+                apiKey: apiKey,
+                baseUrl: baseUrl ?? "",
+            };
+            const idx = providers.findIndex((p) => p.id === entry.id);
+            if (idx >= 0) {
+                providers[idx] = entry;
+            }
+            else {
+                providers.push(entry);
+            }
+        }
+        const knownModels = providers.flatMap((p) => {
+            const meta = SUPPORTED_PROVIDERS.find((m) => m.id === p.id);
+            return (meta?.exampleModels ?? []).map((m) => `${p.id}:${m}`);
+        });
+        client.log("");
+        client.log(c.bold(" Model Selection"));
+        client.log(c.muted("  Type to search or enter a custom provider:model-id"));
+        if (knownModels.length > 0) {
+            const modelChoices = knownModels.map((m) => ({ title: m, value: m }));
+            const suggestModel = (input, choices) => Promise.resolve(input
+                ? choices.filter((ch) => ch.title.toLowerCase().includes(input.toLowerCase()))
+                : choices);
+            chatModel = (await client.prompt({
+                type: "autocomplete",
+                message: "Chat model",
+                choices: modelChoices,
+                initial: chatModel,
+                suggest: suggestModel,
+            }));
+        }
+        else {
+            chatModel = (await client.prompt({
+                type: "text",
+                message: "Chat model (provider:model-id)",
+                initial: chatModel,
+            }));
+        }
+        client.log("");
+        client.log(c.bold(" Review Configuration"));
+        client.log(`  ${c.brand(c.bold("Providers:"))}`);
+        for (const p of providers) {
+            const url = p.baseUrl ? c.muted(` [${p.baseUrl}]`) : "";
+            client.log(`    ${c.success("●")} ${p.id}${url}`);
+        }
+        client.log(`  ${c.brand(c.bold("Models:"))}`);
+        client.log(`    chat: ${c.info(chatModel)}`);
+        client.log("");
+        const confirmed = await client.confirm("Save configuration?");
+        if (!confirmed) {
+            client.log(c.muted("  Configuration not saved."));
+            return;
+        }
+        try {
+            const providersObj = {};
+            for (const p of providers) {
+                providersObj[p.id] = {
+                    apiKey: p.apiKey,
+                    ...(p.baseUrl ? { baseUrl: p.baseUrl } : {}),
+                };
+            }
+            const config = {
+                ...baseConfig,
+                ai: {
+                    providers: providersObj,
+                    models: { chat: chatModel },
+                    aliases: baseConfig.ai.aliases,
+                },
+            };
+            await writeConfig({ config });
+            client.log(c.success(`Configuration saved to ${getConfigPath()}`));
+            client.log(c.muted("  Run ") +
+                c.info("babyclaw config validate") +
+                c.muted(" to verify, or ") +
+                c.info("babyclaw model") +
+                c.muted(" to review."));
+        }
+        catch (err) {
+            client.log(c.error("Failed to save configuration"));
+            client.log(c.muted(err instanceof Error ? err.message : String(err)));
+            process.exitCode = 1;
+        }
+    },
+});