@pasko70/pibo 1.9.9 → 1.9.11

package/dist/skills/cli.js

@@ -0,0 +1,151 @@
+import { Command } from "commander";
+import { createDefaultPiboPluginRegistry } from "../plugins/builtin.js";
+import { ScopedUserSkillManager, normalizeUserSkillScope, normalizeWritableUserSkillScope, } from "../user-skills/manager.js";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+export async function runSkillsCli(argv) {
+    const manager = new ScopedUserSkillManager();
+    const program = new Command();
+    program
+        .name("pibo skills")
+        .description("Manage Pibo user skills and inspect the built-in/plugin skill catalog")
+        .addHelpText("after", "\nBuilt-in/plugin skills are selected by agent profiles. Run `pibo skills catalog` to list them.\n");
+    program
+        .command("catalog")
+        .description("List built-in and plugin skills available to profiles")
+        .option("--json", "Print JSON")
+        .action((options) => {
+        const registry = createDefaultPiboPluginRegistry();
+        const skills = registry.getCapabilityCatalog().skills.filter((skill) => skill.kind !== "user");
+        if (options.json) {
+            printJson(skills);
+            return;
+        }
+        if (skills.length === 0) {
+            console.log("No built-in or plugin skills registered.");
+            return;
+        }
+        console.log("NAME\tKIND\tPATH");
+        for (const skill of skills) {
+            console.log(`${skill.name}\t${skill.kind ?? "plugin"}\t${skill.path}`);
+        }
+    });
+    program
+        .command("list")
+        .description("List user skills managed by this CLI")
+        .option("--scope <scope>", "Skill scope: global, workspace, or all", "all")
+        .option("--json", "Print JSON")
+        .action((options) => {
+        const skills = manager.list(normalizeUserSkillScope(options.scope));
+        if (options.json) {
+            printJson(skills);
+            return;
+        }
+        if (skills.length === 0) {
+            console.log("No user skills registered.");
+            return;
+        }
+        console.log("NAME\t\tSCOPE\t\tENABLED\tSOURCE\t\tDESCRIPTION");
+        for (const s of skills) {
+            const enabled = s.enabled ? "yes" : "no";
+            console.log(`${s.name}\t${s.scope ?? "global"}\t${enabled}\t\t${s.source}\t${s.description}`);
+        }
+    });
+    program
+        .command("show")
+        .description("Show a skill's markdown content")
+        .argument("<name>", "Skill name")
+        .option("--scope <scope>", "Skill scope: global, workspace, or all", "all")
+        .action((name, options) => {
+        const scope = normalizeUserSkillScope(options.scope);
+        const skill = manager.get(name, scope);
+        if (!skill) {
+            console.error(`Skill "${name}" not found.`);
+            process.exitCode = 1;
+            return;
+        }
+        console.log(manager.getSkillMarkdown(skill.id, scope));
+    });
+    program
+        .command("add")
+        .description("Create a new user skill from a markdown file")
+        .argument("<name>", "Skill name (kebab-case)")
+        .requiredOption("--file <path>", "Path to markdown file")
+        .option("--description <text>", "Short description")
+        .option("--scope <scope>", "Skill scope: global or workspace", "global")
+        .action((name, options) => {
+        const filePath = resolve(options.file);
+        const markdown = readFileSync(filePath, "utf-8");
+        const skill = manager.create({
+            name,
+            description: options.description ?? "",
+            markdown,
+        }, normalizeWritableUserSkillScope(options.scope));
+        printJson({ id: skill.id, name: skill.name, scope: skill.scope, enabled: skill.enabled });
+    });
+    program
+        .command("remove")
+        .description("Remove a user skill")
+        .argument("<name>", "Skill name")
+        .option("--scope <scope>", "Skill scope: global, workspace, or all", "all")
+        .action((name, options) => {
+        const scope = normalizeUserSkillScope(options.scope);
+        const skill = manager.get(name, scope);
+        if (!skill) {
+            console.error(`Skill "${name}" not found.`);
+            process.exitCode = 1;
+            return;
+        }
+        manager.remove(skill.id, scope);
+        console.log(`Removed skill "${skill.name}".`);
+    });
+    program
+        .command("enable")
+        .description("Enable a user skill")
+        .argument("<name>", "Skill name")
+        .option("--scope <scope>", "Skill scope: global, workspace, or all", "all")
+        .action((name, options) => {
+        const scope = normalizeUserSkillScope(options.scope);
+        const skill = manager.get(name, scope);
+        if (!skill) {
+            console.error(`Skill "${name}" not found.`);
+            process.exitCode = 1;
+            return;
+        }
+        manager.setEnabled(skill.id, true, scope);
+        console.log(`Enabled skill "${skill.name}".`);
+    });
+    program
+        .command("disable")
+        .description("Disable a user skill")
+        .argument("<name>", "Skill name")
+        .option("--scope <scope>", "Skill scope: global, workspace, or all", "all")
+        .action((name, options) => {
+        const scope = normalizeUserSkillScope(options.scope);
+        const skill = manager.get(name, scope);
+        if (!skill) {
+            console.error(`Skill "${name}" not found.`);
+            process.exitCode = 1;
+            return;
+        }
+        manager.setEnabled(skill.id, false, scope);
+        console.log(`Disabled skill "${skill.name}".`);
+    });
+    program
+        .command("install")
+        .description("Install a skill from a URL (GitHub or skills.sh)")
+        .argument("<url>", "Skill URL")
+        .option("--scope <scope>", "Skill scope: global or workspace", "global")
+        .action(async (url, options) => {
+        const skill = await manager.installFromUrl(url, normalizeWritableUserSkillScope(options.scope));
+        printJson({ id: skill.id, name: skill.name, scope: skill.scope, source: skill.source });
+    });
+    if (argv.length <= 2) {
+        program.outputHelp();
+        return;
+    }
+    await program.parseAsync(argv);
+}

package/dist/subagents/tool.js

@@ -0,0 +1,63 @@
+import { createHash } from "node:crypto";
+import { Type } from "@earendil-works/pi-ai";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+function hashPart(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+function toolNamePart(value) {
+    const normalized = value.trim().toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_+|_+$/g, "");
+    return normalized || `subagent_${hashPart(value)}`;
+}
+export function createSubagentToolName(subagentName) {
+    return `pibo_subagent_${toolNamePart(subagentName)}`;
+}
+export function createSubagentToolDefinitions(subagents, runner) {
+    const seen = new Set();
+    const definitions = [];
+    for (const subagent of subagents) {
+        if (subagent.enabled === false)
+            continue;
+        const toolName = createSubagentToolName(subagent.name);
+        if (seen.has(toolName)) {
+            throw new Error(`Duplicate subagent tool name "${toolName}"`);
+        }
+        seen.add(toolName);
+        definitions.push(createSubagentToolDefinition(subagent, runner));
+    }
+    return definitions;
+}
+function createSubagentToolDefinition(subagent, runner) {
+    const name = createSubagentToolName(subagent.name);
+    return defineTool({
+        name,
+        label: `Pibo Subagent ${subagent.name}`,
+        description: subagent.description ??
+            `Send a message to the ${subagent.name} subagent. Use threadKey to continue the same subagent session.`,
+        promptSnippet: subagent.description ??
+            `Send a message to the ${subagent.name} subagent. Pass the same threadKey when you want to continue the same subagent session.`,
+        executionMode: "parallel",
+        parameters: Type.Object({
+            message: Type.String({ description: "Message to send to the subagent" }),
+            threadKey: Type.Optional(Type.String({
+                description: "Stable key for continuing a previous subagent conversation. Omit it to create a new subagent session.",
+            })),
+        }),
+        async execute(toolCallId, params) {
+            const result = await runner.runSubagent({
+                subagent,
+                message: params.message,
+                threadKey: params.threadKey,
+                toolCallId,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result.reply.text,
+                    },
+                ],
+                details: result,
+            };
+        },
+    });
+}

package/dist/tools/agent-browser-leases.js

@@ -0,0 +1,219 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { cp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { ErrorCode, formatCliError } from '../cli-errors.js';
+const REGISTRY_VERSION = 1;
+const DEFAULT_APP = 'pibo-chat';
+const DEFAULT_TTL_MS = 8 * 60 * 60 * 1000;
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function sanitize(value) {
+    return value.trim().toLowerCase().replace(/[^a-z0-9_.-]+/g, '-').replace(/^-+|-+$/g, '') || 'default';
+}
+function registryPath(status) {
+    return join(status.homeDir, 'pibo-agent-browser-leases.json');
+}
+function lockDir(status) {
+    return join(status.homeDir, '.pibo-agent-browser-leases.lock');
+}
+function templateDir(status, app) {
+    return join(status.homeDir, 'profiles', 'auth-template', sanitize(app));
+}
+function leaseProfileDir(status, app, slot) {
+    return join(status.homeDir, 'profiles', 'leases', sanitize(app), slot);
+}
+function readRegistry(status) {
+    const path = registryPath(status);
+    if (!existsSync(path))
+        return { version: REGISTRY_VERSION, leases: [] };
+    const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+    if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.leases)) {
+        throw new Error(`Invalid agent-browser lease registry: ${path}`);
+    }
+    return { version: REGISTRY_VERSION, leases: parsed.leases };
+}
+async function writeRegistry(status, registry) {
+    await mkdir(status.homeDir, { recursive: true });
+    await writeFile(registryPath(status), `${JSON.stringify({ ...registry, version: REGISTRY_VERSION }, null, 2)}\n`);
+}
+async function withRegistryLock(status, action) {
+    const lock = lockDir(status);
+    await mkdir(status.homeDir, { recursive: true });
+    let acquired = false;
+    for (let attempt = 0; attempt < 50; attempt += 1) {
+        try {
+            await mkdir(lock);
+            acquired = true;
+            break;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+    }
+    if (!acquired)
+        throw new Error('Timed out waiting for agent-browser lease registry lock');
+    try {
+        return await action();
+    }
+    finally {
+        await rm(lock, { recursive: true, force: true });
+    }
+}
+function isExpired(lease, now = new Date()) {
+    return new Date(lease.expiresAt).getTime() <= now.getTime();
+}
+function copyFilter(source) {
+    const base = source.split(/[\\/]/).pop() || '';
+    return ![
+        'SingletonCookie',
+        'SingletonLock',
+        'SingletonSocket',
+        'DevToolsActivePort',
+        'Crashpad',
+        'ShaderCache',
+        'GrShaderCache',
+    ].includes(base);
+}
+function leaseEnv(status, lease) {
+    return {
+        AGENT_BROWSER_HOME: status.homeDir,
+        PIBO_AGENT_BROWSER_LEASE_ID: lease.id,
+        AGENT_BROWSER_SESSION: lease.sessionName,
+        AGENT_BROWSER_PROFILE: lease.profileDir,
+        AGENT_BROWSER_SESSION_NAME: lease.sessionName,
+    };
+}
+function printExports(env) {
+    for (const [key, value] of Object.entries(env))
+        console.log(`export ${key}=${shellQuote(value)}`);
+}
+export function printAgentBrowserAuthTemplatePath(status, app = DEFAULT_APP) {
+    console.log(templateDir(status, app));
+}
+export async function printAgentBrowserAuthTemplateEnv(status, app = DEFAULT_APP) {
+    const dir = templateDir(status, app);
+    await mkdir(dir, { recursive: true });
+    printExports({
+        AGENT_BROWSER_HOME: status.homeDir,
+        AGENT_BROWSER_PROFILE: dir,
+        AGENT_BROWSER_SESSION: `pibo-auth-template-${sanitize(app)}`,
+        AGENT_BROWSER_SESSION_NAME: `pibo-auth-template-${sanitize(app)}`,
+    });
+    console.log(`# Open Chat Web, sign in, then close the browser before acquiring leases.`);
+}
+export async function acquireAgentBrowserLease(status, options) {
+    const app = sanitize(options.app || DEFAULT_APP);
+    const holder = options.holder || process.env.USER || 'unknown';
+    const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    const maxSlots = options.maxSlots ?? 4;
+    const result = await withRegistryLock(status, async () => {
+        const registry = readRegistry(status);
+        const now = new Date();
+        for (const lease of registry.leases) {
+            if (lease.status === 'active' && isExpired(lease, now)) {
+                lease.status = 'released';
+                lease.updatedAt = nowIso();
+            }
+        }
+        const active = registry.leases.filter((lease) => lease.app === app && lease.status === 'active' && !isExpired(lease, now));
+        if (active.length >= maxSlots) {
+            throw new Error(formatCliError({
+                code: ErrorCode.CLIENT_ERROR,
+                type: 'AGENT_BROWSER_AUTH_POOL_EXHAUSTED',
+                message: `No agent-browser auth slots are available for ${app}`,
+                details: `Active slots: ${active.length}; max slots: ${maxSlots}`,
+                suggestion: 'Release a lease or rerun with a higher --max-slots value.',
+            }));
+        }
+        const used = new Set(active.map((lease) => lease.slot));
+        let slotNumber = 1;
+        while (used.has(`slot-${String(slotNumber).padStart(3, '0')}`))
+            slotNumber += 1;
+        const slot = `slot-${String(slotNumber).padStart(3, '0')}`;
+        const sessionName = `pibo-auth-${app}-${slot}`;
+        const profileDir = leaseProfileDir(status, app, slot);
+        const lease = {
+            id: `${app}-${slot}`,
+            app,
+            holder,
+            slot,
+            sessionName,
+            profileDir,
+            status: 'active',
+            createdAt: nowIso(),
+            updatedAt: nowIso(),
+            expiresAt: new Date(now.getTime() + ttlMs).toISOString(),
+        };
+        await rm(profileDir, { recursive: true, force: true });
+        const sourceTemplate = templateDir(status, app);
+        if (existsSync(sourceTemplate)) {
+            await cp(sourceTemplate, profileDir, { recursive: true, force: true, filter: copyFilter });
+        }
+        else {
+            await mkdir(profileDir, { recursive: true });
+        }
+        registry.leases.push(lease);
+        await writeRegistry(status, registry);
+        return lease;
+    });
+    const env = leaseEnv(status, result);
+    if (options.json) {
+        console.log(JSON.stringify({ lease: result, env }, null, 2));
+        return;
+    }
+    printExports(env);
+}
+export async function listAgentBrowserLeases(status, json = false) {
+    const registry = readRegistry(status);
+    if (json) {
+        console.log(JSON.stringify(registry, null, 2));
+        return;
+    }
+    if (registry.leases.length === 0) {
+        console.log('No agent-browser leases.');
+        return;
+    }
+    console.log('id\tapp\tstatus\tholder\tsession\texpires\tprofile');
+    for (const lease of registry.leases) {
+        console.log(`${lease.id}\t${lease.app}\t${lease.status}\t${lease.holder}\t${lease.sessionName}\t${lease.expiresAt}\t${lease.profileDir}`);
+    }
+}
+export async function releaseAgentBrowserLease(status, id, options) {
+    await withRegistryLock(status, async () => {
+        const registry = readRegistry(status);
+        const lease = registry.leases.find((item) => item.id === id);
+        if (!lease)
+            throw new Error(`Agent Browser lease not found: ${id}`);
+        lease.status = 'released';
+        lease.updatedAt = nowIso();
+        await writeRegistry(status, registry);
+        if (options.deleteProfile)
+            await rm(lease.profileDir, { recursive: true, force: true });
+    });
+    console.log(`Released agent-browser lease ${id}`);
+}
+export async function reapStaleAgentBrowserLeases(status, json = false) {
+    let released = 0;
+    await withRegistryLock(status, async () => {
+        const registry = readRegistry(status);
+        const now = new Date();
+        for (const lease of registry.leases) {
+            if (lease.status === 'active' && isExpired(lease, now)) {
+                lease.status = 'released';
+                lease.updatedAt = nowIso();
+                released += 1;
+            }
+        }
+        await writeRegistry(status, registry);
+    });
+    if (json)
+        console.log(JSON.stringify({ released }, null, 2));
+    else
+        console.log(`Reaped ${released} expired agent-browser lease(s).`);
+}

package/dist/tools/agent-browser-wrapper.js

@@ -0,0 +1,99 @@
+import { chmodSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+export const AGENT_BROWSER_DEFAULT_PROFILE = 'PIBo';
+export const AGENT_BROWSER_FRESH_PROFILE_FLAG = '--fresh-profile';
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function createAgentBrowserWrapper(realExecutablePath, defaultHomeDir) {
+    return `#!/usr/bin/env bash
+set -euo pipefail
+
+real_agent_browser=${shellQuote(realExecutablePath)}
+default_home=${shellQuote(defaultHomeDir)}
+fresh_flag=${shellQuote(AGENT_BROWSER_FRESH_PROFILE_FLAG)}
+
+if [ -z "\${AGENT_BROWSER_HOME:-}" ]; then
+  export AGENT_BROWSER_HOME="$default_home"
+fi
+mkdir -p "$AGENT_BROWSER_HOME" "$AGENT_BROWSER_HOME/profiles"
+
+# agent-browser@0.27.0 uses HOME for ~/.agent-browser state. Redirect it by
+# default so doctor, config, sockets, and auth vault files stay inside Pibo's
+# tool home. Operators can opt out for upstream debugging.
+if [ "\${PIBO_AGENT_BROWSER_PRESERVE_HOME:-0}" != "1" ]; then
+  export HOME="$AGENT_BROWSER_HOME"
+fi
+
+explicit_runtime=0
+fresh_profile=0
+show_help=0
+starts_browser=0
+args=()
+
+print_wrapper_help() {
+  cat <<'HELP'
+Pibo agent-browser wrapper
+  - keeps Agent Browser state under AGENT_BROWSER_HOME by default
+  - prepends a persistent Pibo profile for browser-launching commands
+  - pass --fresh-profile to disable Pibo profile injection
+  - explicit --profile, --state, --cdp, --auto-connect, --provider, --engine,
+    --executable-path, or --config flags override Pibo defaults
+HELP
+}
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --help|-h)
+      show_help=1
+      args+=("$1")
+      ;;
+    --fresh-profile)
+      fresh_profile=1
+      ;;
+    --profile|--state|--cdp|--auto-connect|--provider|--engine|--executable-path|--config)
+      explicit_runtime=1
+      args+=("$1")
+      if [ "$#" -gt 1 ]; then
+        shift
+        args+=("$1")
+      fi
+      ;;
+    --profile=*|--state=*|--cdp=*|--auto-connect=*|--provider=*|--engine=*|--executable-path=*|--config=*)
+      explicit_runtime=1
+      args+=("$1")
+      ;;
+    open|launch|new|goto)
+      starts_browser=1
+      args+=("$1")
+      ;;
+    *)
+      args+=("$1")
+      ;;
+  esac
+  shift
+done
+
+if [ "$show_help" -eq 1 ]; then
+  print_wrapper_help
+  exec "$real_agent_browser" "\${args[@]}"
+fi
+
+if [ "$starts_browser" -eq 1 ] && [ "$fresh_profile" -eq 0 ] && [ "$explicit_runtime" -eq 0 ]; then
+  profile_dir=\${AGENT_BROWSER_PROFILE:-$AGENT_BROWSER_HOME/profiles/${AGENT_BROWSER_DEFAULT_PROFILE}}
+  mkdir -p "$profile_dir"
+  exec "$real_agent_browser" --profile "$profile_dir" "\${args[@]}"
+fi
+
+exec "$real_agent_browser" "\${args[@]}"
+`;
+}
+export function ensureAgentBrowserWrapper(status) {
+    if (!status.homeDir || !status.executablePath)
+        return undefined;
+    const wrapperPath = join(status.homeDir, 'bin', 'agent-browser');
+    mkdirSync(dirname(wrapperPath), { recursive: true });
+    writeFileSync(wrapperPath, createAgentBrowserWrapper(status.executablePath, status.homeDir));
+    chmodSync(wrapperPath, 0o755);
+    return wrapperPath;
+}