babyclaw 0.0.0

package/build/commands/skills/install.js

@@ -0,0 +1,85 @@
+import { command } from "@gud/cli";
+import { resolve } from "node:path";
+import { loadConfigRaw, installSkillFromClawHub, runSkillSetup, resolveLanguageModel, SkillAlreadyInstalledError, ClawHubError, } from "@babyclaw/gateway";
+import { c } from "../../ui/theme.js";
+export default command({
+    description: "Install a skill from ClawHub",
+    options: {
+        slug: {
+            type: "string",
+            description: "Skill slug on ClawHub (e.g. gcalcli-calendar)",
+            required: true,
+        },
+        version: {
+            type: "string",
+            description: "Install a specific version (defaults to latest)",
+        },
+        force: {
+            type: "boolean",
+            description: "Overwrite if the skill is already installed",
+        },
+        "skip-setup": {
+            type: "boolean",
+            description: "Skip automatic dependency setup after installation",
+        },
+    },
+    handler: async ({ options, client }) => {
+        const slug = await options.slug({ prompt: "Skill slug (e.g. gcalcli-calendar)" });
+        const version = await options.version();
+        const force = await options.force();
+        const skipSetup = await options["skip-setup"]();
+        try {
+            const config = await loadConfigRaw();
+            const workspacePath = resolve(process.cwd(), config?.workspace?.root ?? ".");
+            const installResult = await installSkillFromClawHub({
+                slug,
+                version: version || undefined,
+                workspacePath,
+                force: force || false,
+            });
+            let setupResult = null;
+            let setupError = null;
+            if (!skipSetup && config) {
+                try {
+                    const model = resolveLanguageModel({ config });
+                    setupResult = await runSkillSetup({
+                        model,
+                        skillPath: installResult.skillPath,
+                        workspacePath,
+                    });
+                }
+                catch (err) {
+                    setupError = err instanceof Error ? err.message : String(err);
+                }
+            }
+            client.log(c.success("✓ Installed ") +
+                c.bold(installResult.displayName) +
+                c.muted(` (${installResult.version})`));
+            client.log(c.muted(`  ${installResult.files.length} file${installResult.files.length !== 1 ? "s" : ""} → ${installResult.skillPath}`));
+            if (setupResult && !setupResult.skipped) {
+                client.log(c.success("  ✓ Dependencies set up"));
+            }
+            if (setupError) {
+                client.log(c.warning("  ⚠ Setup failed (skill files are still installed)"));
+                client.log(c.muted(`    ${setupError}`));
+            }
+            client.log(c.muted("  The skill will be available on the next agent session."));
+        }
+        catch (error) {
+            if (error instanceof SkillAlreadyInstalledError) {
+                client.log(c.warning(`⚠ Skill "${slug}" is already installed.`));
+                client.log(c.muted("  Use ") + c.info("--force") + c.muted(" to overwrite."));
+                return;
+            }
+            if (error instanceof ClawHubError && error.statusCode === 404) {
+                client.log(c.error(`✗ Skill "${slug}" not found on ClawHub.`));
+                client.log(c.muted("  Browse available skills at ") + c.info("https://clawhub.ai/skills"));
+                process.exitCode = 1;
+                return;
+            }
+            client.log(c.error(`✗ Failed to install skill "${slug}"`));
+            client.log(c.muted(`  ${error instanceof Error ? error.message : String(error)}`));
+            process.exitCode = 1;
+        }
+    },
+});

package/build/commands/skills/search.js

@@ -0,0 +1,114 @@
+import { command } from "@gud/cli";
+import { resolve } from "node:path";
+import { loadConfigRaw, installSkillFromClawHub, runSkillSetup, resolveLanguageModel, SkillAlreadyInstalledError, } from "@babyclaw/gateway";
+import { c } from "../../ui/theme.js";
+const CLAWHUB_SEARCH_URL = "https://clawhub.ai/api/v1/search";
+export default command({
+    description: "Search for skills on ClawHub",
+    options: {
+        query: {
+            type: "string",
+            description: "Search query (e.g. notion, calendar, git)",
+            required: true,
+        },
+        json: {
+            type: "boolean",
+            description: "Output raw JSON instead of formatted results",
+        },
+    },
+    handler: async ({ options, client }) => {
+        const query = await options.query({ prompt: "Search query" });
+        const json = await options.json();
+        const url = `${CLAWHUB_SEARCH_URL}?q=${encodeURIComponent(query)}`;
+        let data;
+        try {
+            const res = await fetch(url);
+            if (!res.ok) {
+                client.log(c.error(`✗ ClawHub API returned ${res.status}`));
+                process.exitCode = 1;
+                return;
+            }
+            data = (await res.json());
+        }
+        catch (error) {
+            client.log(c.error("✗ Failed to reach ClawHub API"));
+            client.log(c.muted(`  ${error instanceof Error ? error.message : String(error)}`));
+            process.exitCode = 1;
+            return;
+        }
+        if (data.results.length === 0) {
+            client.log(c.warning(`No skills found for "${query}".`));
+            client.log(c.muted("  Browse all skills at ") + c.info("https://clawhub.ai/skills"));
+            return;
+        }
+        if (json) {
+            client.log(JSON.stringify(data.results, null, 2));
+            return;
+        }
+        client.log(c.bold(` 🔍 ${data.results.length} result${data.results.length !== 1 ? "s" : ""} for "${query}"`) + "\n");
+        const choices = data.results.map((r) => ({
+            title: `${r.displayName} ${c.muted("v" + r.version)} — ${r.summary}`,
+            value: r.slug,
+        }));
+        choices.push({ title: c.muted("Cancel"), value: "__cancel__" });
+        const selected = await client.prompt({
+            type: "select",
+            message: "Select a skill to install",
+            choices,
+        });
+        if (selected === "__cancel__") {
+            return;
+        }
+        const slug = selected;
+        const skill = data.results.find((r) => r.slug === slug);
+        client.log("");
+        try {
+            const config = await loadConfigRaw();
+            const workspacePath = resolve(process.cwd(), config?.workspace?.root ?? ".");
+            const installResult = await installSkillFromClawHub({
+                slug,
+                workspacePath,
+                force: false,
+            });
+            let setupResult = null;
+            let setupError = null;
+            if (config) {
+                try {
+                    const model = resolveLanguageModel({ config });
+                    setupResult = await runSkillSetup({
+                        model,
+                        skillPath: installResult.skillPath,
+                        workspacePath,
+                    });
+                }
+                catch (err) {
+                    setupError = err instanceof Error ? err.message : String(err);
+                }
+            }
+            client.log(c.success("✓ Installed ") +
+                c.bold(installResult.displayName) +
+                c.muted(` (${installResult.version})`));
+            client.log(c.muted(`  ${installResult.files.length} file${installResult.files.length !== 1 ? "s" : ""} → ${installResult.skillPath}`));
+            if (setupResult && !setupResult.skipped) {
+                client.log(c.success("  ✓ Dependencies set up"));
+            }
+            if (setupError) {
+                client.log(c.warning("  ⚠ Setup failed (skill files are still installed)"));
+                client.log(c.muted(`    ${setupError}`));
+            }
+            client.log(c.muted("  The skill will be available on the next agent session."));
+        }
+        catch (error) {
+            if (error instanceof SkillAlreadyInstalledError) {
+                client.log(c.warning(`⚠ Skill "${skill.displayName}" is already installed.`));
+                client.log(c.muted("  Use ") +
+                    c.info(`babyclaw skill install --slug ${slug} --force`) +
+                    c.muted(" to overwrite."));
+                return;
+            }
+            client.log(c.error(`✗ Failed to install "${skill.displayName}"`));
+            client.log(c.muted(`  ${error instanceof Error ? error.message : String(error)}`));
+            process.exitCode = 1;
+        }
+    },
+});

package/build/service/adapter.js

@@ -0,0 +1,265 @@
+import { platform } from "node:os";
+import { existsSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { mkdirSync, writeFileSync, unlinkSync } from "node:fs";
+import { createRequire } from "node:module";
+const SERVICE_LABEL = "org.babyclaw.gateway";
+const SYSTEMD_UNIT = "babyclaw-gateway";
+export function detectPlatform() {
+    const os = platform();
+    if (os === "darwin")
+        return "launchd";
+    if (os === "linux")
+        return "systemd";
+    return "unsupported";
+}
+function getLaunchdPlistPath() {
+    return join(homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
+}
+function getSystemdUnitPath() {
+    return join(homedir(), ".config", "systemd", "user", `${SYSTEMD_UNIT}.service`);
+}
+function getGatewayEntryPath() {
+    try {
+        const require = createRequire(import.meta.url);
+        return require.resolve("@babyclaw/gateway/dist/main.js");
+    }
+    catch {
+        const thisDir = dirname(fileURLToPath(import.meta.url));
+        return join(thisDir, "..", "..", "..", "gateway", "dist", "main.js");
+    }
+}
+function getShellPath() {
+    const fallback = `/usr/local/bin:/usr/bin:/bin`;
+    try {
+        const shell = process.env.SHELL || "/bin/zsh";
+        return execSync(`${shell} -ilc 'echo $PATH'`, {
+            encoding: "utf8",
+            timeout: 5000,
+        }).trim();
+    }
+    catch {
+        return process.env.PATH || fallback;
+    }
+}
+function generateLaunchdPlist() {
+    const nodePath = execSync("which node", { encoding: "utf8" }).trim();
+    const entryPath = getGatewayEntryPath();
+    const logDir = join(homedir(), ".babyclaw", "logs");
+    const shellPath = getShellPath();
+    const nodeDir = dirname(nodePath);
+    const path = shellPath.includes(nodeDir) ? shellPath : `${shellPath}:${nodeDir}`;
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${entryPath}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${logDir}/gateway.stdout.log</string>
+  <key>StandardErrorPath</key>
+  <string>${logDir}/gateway.stderr.log</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${path}</string>
+  </dict>
+</dict>
+</plist>`;
+}
+function generateSystemdUnit() {
+    const nodePath = execSync("which node", { encoding: "utf8" }).trim();
+    const entryPath = getGatewayEntryPath();
+    return `[Unit]
+Description=BabyClaw Gateway
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${nodePath} ${entryPath}
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=default.target`;
+}
+export function install() {
+    const plat = detectPlatform();
+    if (plat === "launchd") {
+        const plistPath = getLaunchdPlistPath();
+        mkdirSync(dirname(plistPath), { recursive: true });
+        mkdirSync(join(homedir(), ".babyclaw", "logs"), { recursive: true });
+        writeFileSync(plistPath, generateLaunchdPlist(), "utf8");
+        return { path: plistPath };
+    }
+    if (plat === "systemd") {
+        const unitPath = getSystemdUnitPath();
+        mkdirSync(dirname(unitPath), { recursive: true });
+        writeFileSync(unitPath, generateSystemdUnit(), "utf8");
+        execSync("systemctl --user daemon-reload");
+        execSync(`systemctl --user enable ${SYSTEMD_UNIT}`);
+        return { path: unitPath };
+    }
+    throw new Error("Unsupported platform for service installation");
+}
+export function uninstall() {
+    const plat = detectPlatform();
+    if (plat === "launchd") {
+        const plistPath = getLaunchdPlistPath();
+        try {
+            execSync(`launchctl bootout gui/$(id -u) ${plistPath} 2>/dev/null`);
+        }
+        catch {
+            // Already unloaded
+        }
+        if (existsSync(plistPath)) {
+            unlinkSync(plistPath);
+        }
+        return;
+    }
+    if (plat === "systemd") {
+        const unitPath = getSystemdUnitPath();
+        try {
+            execSync(`systemctl --user stop ${SYSTEMD_UNIT} 2>/dev/null`);
+            execSync(`systemctl --user disable ${SYSTEMD_UNIT} 2>/dev/null`);
+        }
+        catch {
+            // Already stopped/disabled
+        }
+        if (existsSync(unitPath)) {
+            unlinkSync(unitPath);
+        }
+        execSync("systemctl --user daemon-reload");
+        return;
+    }
+    throw new Error("Unsupported platform for service uninstallation");
+}
+export function start() {
+    const plat = detectPlatform();
+    if (plat === "launchd") {
+        const plistPath = getLaunchdPlistPath();
+        if (!existsSync(plistPath)) {
+            throw new Error("Service not installed. Run 'babyclaw service install' first.");
+        }
+        execSync(`launchctl bootstrap gui/$(id -u) ${plistPath}`);
+        return;
+    }
+    if (plat === "systemd") {
+        execSync(`systemctl --user start ${SYSTEMD_UNIT}`);
+        return;
+    }
+    throw new Error("Unsupported platform");
+}
+export function stop() {
+    const plat = detectPlatform();
+    if (plat === "launchd") {
+        const plistPath = getLaunchdPlistPath();
+        execSync(`launchctl bootout gui/$(id -u) ${plistPath}`);
+        return;
+    }
+    if (plat === "systemd") {
+        execSync(`systemctl --user stop ${SYSTEMD_UNIT}`);
+        return;
+    }
+    throw new Error("Unsupported platform");
+}
+export function restart() {
+    const plat = detectPlatform();
+    if (plat === "launchd") {
+        const plistPath = getLaunchdPlistPath();
+        try {
+            execSync(`launchctl bootout gui/$(id -u) ${plistPath} 2>/dev/null`);
+        }
+        catch {
+            // May not be running
+        }
+        execSync(`launchctl bootstrap gui/$(id -u) ${plistPath}`);
+        return;
+    }
+    if (plat === "systemd") {
+        execSync(`systemctl --user restart ${SYSTEMD_UNIT}`);
+        return;
+    }
+    throw new Error("Unsupported platform");
+}
+export function getStatus() {
+    const plat = detectPlatform();
+    if (plat === "launchd") {
+        const plistPath = getLaunchdPlistPath();
+        const installed = existsSync(plistPath);
+        let running = false;
+        let pid = null;
+        if (installed) {
+            try {
+                const output = execSync(`launchctl list ${SERVICE_LABEL} 2>/dev/null`, {
+                    encoding: "utf8",
+                });
+                running = true;
+                const pidMatch = output.match(/"PID"\s*=\s*(\d+)/);
+                if (pidMatch) {
+                    pid = parseInt(pidMatch[1], 10);
+                }
+            }
+            catch {
+                // Service loaded but not running, or not loaded
+                try {
+                    const output = execSync(`launchctl print gui/$(id -u)/${SERVICE_LABEL} 2>/dev/null`, {
+                        encoding: "utf8",
+                    });
+                    running = output.includes("state = running");
+                    const pidMatch = output.match(/pid\s*=\s*(\d+)/);
+                    if (pidMatch) {
+                        pid = parseInt(pidMatch[1], 10);
+                    }
+                }
+                catch {
+                    running = false;
+                }
+            }
+        }
+        return { installed, running, pid, platform: "launchd" };
+    }
+    if (plat === "systemd") {
+        const unitPath = getSystemdUnitPath();
+        const installed = existsSync(unitPath);
+        let running = false;
+        let pid = null;
+        if (installed) {
+            try {
+                const output = execSync(`systemctl --user is-active ${SYSTEMD_UNIT} 2>/dev/null`, {
+                    encoding: "utf8",
+                });
+                running = output.trim() === "active";
+            }
+            catch {
+                running = false;
+            }
+            if (running) {
+                try {
+                    const output = execSync(`systemctl --user show ${SYSTEMD_UNIT} --property=MainPID 2>/dev/null`, { encoding: "utf8" });
+                    const match = output.match(/MainPID=(\d+)/);
+                    if (match && match[1] !== "0") {
+                        pid = parseInt(match[1], 10);
+                    }
+                }
+                catch {
+                    // Ignore
+                }
+            }
+        }
+        return { installed, running, pid, platform: "systemd" };
+    }
+    return { installed: false, running: false, pid: null, platform: "unsupported" };
+}

package/build/service/adapter.test.js

@@ -0,0 +1,33 @@
+import { describe, it, expect } from "vitest";
+import { detectPlatform, getStatus } from "./adapter.js";
+import { platform } from "node:os";
+describe("service adapter", () => {
+    it("detects the correct platform", () => {
+        const os = platform();
+        const detected = detectPlatform();
+        if (os === "darwin") {
+            expect(detected).toBe("launchd");
+        }
+        else if (os === "linux") {
+            expect(detected).toBe("systemd");
+        }
+        else {
+            expect(detected).toBe("unsupported");
+        }
+    });
+    it("returns a ServiceInfo object from getStatus", () => {
+        const info = getStatus();
+        expect(info).toHaveProperty("installed");
+        expect(info).toHaveProperty("running");
+        expect(info).toHaveProperty("pid");
+        expect(info).toHaveProperty("platform");
+        expect(typeof info.installed).toBe("boolean");
+        expect(typeof info.running).toBe("boolean");
+    });
+    it("reports not installed when no service file exists", () => {
+        const info = getStatus();
+        // On a clean dev machine, service should not be installed
+        // This test verifies the adapter doesn't crash when querying
+        expect(typeof info.installed).toBe("boolean");
+    });
+});

package/build/ui/theme.js

@@ -0,0 +1,69 @@
+import pc from "picocolors";
+export const c = {
+    brand: pc.magenta,
+    success: pc.green,
+    error: pc.red,
+    warning: pc.yellow,
+    muted: pc.gray,
+    info: pc.blue,
+    bold: pc.bold,
+};
+const BANNERS = [
+    `
+   ╭─────────────────────────────╮
+   │                             │
+   │   🦀  babyclaw  v1.0.0     │
+   │                             │
+   │   your friendly agent       │
+   │   gateway, at your service  │
+   │                             │
+   ╰─────────────────────────────╯`,
+    `
+   ╭─────────────────────────────╮
+   │                             │
+   │   🦞  babyclaw  v1.0.0     │
+   │                             │
+   │   pincers ready,            │
+   │   tasks loaded.             │
+   │                             │
+   ╰─────────────────────────────╯`,
+    `
+   ╭─────────────────────────────╮
+   │                             │
+   │   🦀  babyclaw  v1.0.0     │
+   │                             │
+   │   snip snip.                │
+   │   let's get to work.        │
+   │                             │
+   ╰─────────────────────────────╯`,
+];
+export function getRandomBanner() {
+    const index = Math.floor(Math.random() * BANNERS.length);
+    return BANNERS[index];
+}
+export function formatUptime(ms) {
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ${seconds % 60}s`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ${minutes % 60}m`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ${hours % 24}h`;
+}
+const TIPS = [
+    "Run 'babyclaw config edit' to tweak your setup interactively.",
+    "Use 'babyclaw service status' to check if the gateway is alive.",
+    "Add '--json' to most commands for machine-readable output.",
+    "The gateway talks over a local Unix socket — no ports to configure.",
+    "Use 'babyclaw config validate' after manual edits to catch typos.",
+    "Your config lives at ~/.babyclaw/babyclaw.json by default.",
+    "You can override the config path with BABYCLAW_CONFIG_PATH.",
+];
+export function getRandomTip() {
+    const index = Math.floor(Math.random() * TIPS.length);
+    return TIPS[index];
+}

package/build/ui/theme.test.js

@@ -0,0 +1,33 @@
+import { describe, it, expect } from "vitest";
+import { formatUptime, getRandomBanner, getRandomTip } from "./theme.js";
+describe("formatUptime", () => {
+    it("formats seconds", () => {
+        expect(formatUptime(5000)).toBe("5s");
+        expect(formatUptime(59000)).toBe("59s");
+    });
+    it("formats minutes and seconds", () => {
+        expect(formatUptime(90_000)).toBe("1m 30s");
+        expect(formatUptime(3_540_000)).toBe("59m 0s");
+    });
+    it("formats hours and minutes", () => {
+        expect(formatUptime(3_600_000)).toBe("1h 0m");
+        expect(formatUptime(7_260_000)).toBe("2h 1m");
+    });
+    it("formats days and hours", () => {
+        expect(formatUptime(86_400_000)).toBe("1d 0h");
+        expect(formatUptime(100_000_000)).toBe("1d 3h");
+    });
+});
+describe("getRandomBanner", () => {
+    it("returns a non-empty string", () => {
+        const banner = getRandomBanner();
+        expect(banner.length).toBeGreaterThan(0);
+        expect(banner).toContain("babyclaw");
+    });
+});
+describe("getRandomTip", () => {
+    it("returns a non-empty string", () => {
+        const tip = getRandomTip();
+        expect(tip.length).toBeGreaterThan(0);
+    });
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "babyclaw",
+  "version": "0.0.0",
+  "description": "The babyclaw command-line interface",
+  "keywords": [
+    "agent",
+    "babyclaw",
+    "cli",
+    "gateway"
+  ],
+  "license": "ISC",
+  "bin": {
+    "babyclaw": "./build/cli.js"
+  },
+  "files": [
+    "build"
+  ],
+  "type": "module",
+  "dependencies": {
+    "@gud/cli": "1.0.0-beta.7",
+    "picocolors": "^1.1.1",
+    "@babyclaw/gateway": "0.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "oxlint": "^1.49.0",
+    "typescript": "^5.9.2",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "format": "oxfmt --write .",
+    "format:check": "oxfmt --check .",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}