@pasko70/pibo 1.9.9 → 1.9.10

package/dist/cli-session/sessionSource.js

@@ -0,0 +1,13 @@
+export class CliSourceError extends Error {
+    code;
+    cause;
+    constructor(code, message, options = {}) {
+        super(message);
+        this.name = "CliSourceError";
+        this.code = code;
+        this.cause = options.cause;
+    }
+}
+export function isCliSourceError(error) {
+    return error instanceof CliSourceError;
+}

package/dist/cli.js

@@ -0,0 +1,491 @@
+import { existsSync, readFileSync } from "node:fs";
+import { Command } from "commander";
+import { PIBO_CONFIG_KEYS, getDefaultPiboConfigPath, deletePiboConfigValue, getDisplayPiboConfigValue, loadPiboConfig, redactPiboConfig, savePiboConfig, setPiboConfigValue, } from "./config/config.js";
+import { parsePiboThinkingLevel } from "./core/thinking.js";
+import { piboHomePath } from "./core/pibo-home.js";
+async function createCliProfile(profileName) {
+    const { createDefaultPiboPluginRegistry, createGatewayProducerPiboProfile, createPiboProfileFromRegistryOrDefault } = await import("./plugins/builtin.js");
+    if (profileName === "gateway-producer" || profileName === "pibo-gateway-producer") {
+        return createGatewayProducerPiboProfile();
+    }
+    const registry = createDefaultPiboPluginRegistry();
+    const chatAgentStorePath = piboHomePath("chat-agents.sqlite");
+    if (existsSync(chatAgentStorePath)) {
+        const { createPiboChatCustomAgentProfilesPlugin } = await import("./plugins/chat-custom-agents.js");
+        registry.registerPlugin(createPiboChatCustomAgentProfilesPlugin({ agentStorePath: chatAgentStorePath }));
+    }
+    return createPiboProfileFromRegistryOrDefault(registry, profileName);
+}
+function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+function printConfigKeys() {
+    for (const definition of PIBO_CONFIG_KEYS) {
+        const visibility = definition.secret === true ? "secret" : "public";
+        console.log(`${definition.key}\t${definition.type}\t${visibility}\t${definition.description}`);
+    }
+}
+function printRootDiscovery() {
+    console.log(printRootDiscoveryText());
+}
+function getPiboVersion() {
+    const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+    if (typeof packageJson.version !== "string" || packageJson.version.length === 0) {
+        throw new Error("Unable to read Pibo package version");
+    }
+    return packageJson.version;
+}
+function printPiboVersion() {
+    console.log(getPiboVersion());
+}
+function printConfigDiscovery() {
+    console.log(printConfigDiscoveryText());
+}
+function parsePort(value) {
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error("Port must be an integer between 1 and 65535");
+    }
+    return port;
+}
+function parsePositiveInteger(value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new Error("Value must be a positive integer");
+    }
+    return parsed;
+}
+function defaultGatewayPortForWebPort(webPort) {
+    if (webPort === undefined)
+        return undefined;
+    const gatewayPort = webPort + 1;
+    if (gatewayPort > 65535) {
+        throw new Error("--web-port 65535 requires an explicit --gateway-port because the derived gateway port would exceed 65535");
+    }
+    return gatewayPort;
+}
+function isLoopbackBindForCli(host) {
+    const normalized = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+    return normalized === "127.0.0.1" || normalized === "::1" || normalized === "localhost";
+}
+function isComputeWorkerRuntimeForCli() {
+    return process.env.PIBO_COMPUTE_WORKER === "1";
+}
+export async function runPiboCli(argv = process.argv) {
+    if (argv[2] === "--help" || argv[2] === "-h") {
+        printRootDiscovery();
+        return;
+    }
+    if (argv[2] === "--version" || argv[2] === "-V") {
+        printPiboVersion();
+        return;
+    }
+    if (argv[2] === "mcp") {
+        const { runMcpCli } = await import("./mcp/index.js");
+        await runMcpCli([argv[0] ?? "node", "pibo mcp", ...argv.slice(3)]);
+        return;
+    }
+    if (argv[2] === "tools") {
+        const { runToolsCli } = await import("./tools/index.js");
+        await runToolsCli([argv[0] ?? "node", "pibo tools", ...argv.slice(3)]);
+        return;
+    }
+    if (argv[2] === "pi-packages") {
+        const { runPiPackagesCli } = await import("./pi-packages/cli.js");
+        await runPiPackagesCli([argv[0] ?? "node", "pibo pi-packages", ...argv.slice(3)]);
+        return;
+    }
+    if (argv[2] === "debug") {
+        const { runDebugCli } = await import("./debug/index.js");
+        await runDebugCli([argv[0] ?? "node", "pibo debug", ...argv.slice(3)]);
+        return;
+    }
+    if (argv[2] === "data") {
+        const { runDataCli } = await import("./data/cli.js");
+        await runDataCli([argv[0] ?? "node", "pibo data", ...argv.slice(3)]);
+        return;
+    }
+    if (argv[2] === "gateway") {
+        const { runGatewayCli } = await import("./gateway/cli.js");
+        await runGatewayCli(argv);
+        return;
+    }
+    if (argv[2] === "compute") {
+        const { runComputeCli } = await import("./compute/cli.js");
+        await runComputeCli([argv[0] ?? "node", "pibo compute", ...argv.slice(3)]);
+        return;
+    }
+    if (argv[2] === "resources") {
+        const { runResourcesCli } = await import("./resources/cli.js");
+        await runResourcesCli([argv[0] ?? "node", "pibo resources", ...argv.slice(3)]);
+        return;
+    }
+    if (argv[2] === "setup") {
+        const { runSetupCli } = await import("./setup/cli.js");
+        await runSetupCli([argv[0] ?? "node", "pibo setup", ...argv.slice(3)]);
+        return;
+    }
+    if (argv[2] === "skills") {
+        const { runSkillsCli } = await import("./skills/cli.js");
+        await runSkillsCli([argv[0] ?? "node", "pibo skills", ...argv.slice(3)]);
+        return;
+    }
+    if (argv[2] === "cron") {
+        const { runCronCli } = await import("./cron/cli.js");
+        await runCronCli([argv[0] ?? "node", "pibo cron", ...argv.slice(3)]);
+        return;
+    }
+    if (argv[2] === "ralph") {
+        const { runRalphCli } = await import("./ralph/cli.js");
+        await runRalphCli([argv[0] ?? "node", "pibo ralph", ...argv.slice(3)]);
+        return;
+    }
+    if (argv[2] === "vscode") {
+        const { runVscodeCli } = await import("./vscode/cli.js");
+        await runVscodeCli([argv[0] ?? "node", "pibo vscode", ...argv.slice(3)]);
+        return;
+    }
+    if (argv[2] === "config" && (argv[3] === "--help" || argv[3] === "-h" || argv.length === 3)) {
+        printConfigDiscovery();
+        return;
+    }
+    if (argv[2] === "tui:sessions" && (argv[3] === "--help" || argv[3] === "-h")) {
+        const { cliSessionsHelpText } = await import("./apps/cli-ui/index.js");
+        console.log(cliSessionsHelpText());
+        return;
+    }
+    const program = new Command();
+    program.name("pibo").description("Agent-oriented CLI for Pibo").helpOption(false).showHelpAfterError();
+    program
+        .command("mcp")
+        .description("Interact with configured MCP servers")
+        .helpOption(false)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args) => {
+        const { runMcpCli } = await import("./mcp/index.js");
+        await runMcpCli([argv[0] ?? "node", "pibo mcp", ...args]);
+    });
+    program
+        .command("tools")
+        .description("Install and inspect curated external CLI tools")
+        .helpOption(false)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args) => {
+        const { runToolsCli } = await import("./tools/index.js");
+        await runToolsCli([argv[0] ?? "node", "pibo tools", ...args]);
+    });
+    program
+        .command("pi-packages")
+        .description("Register Pi Coding Agent packages")
+        .helpOption(false)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args) => {
+        const { runPiPackagesCli } = await import("./pi-packages/cli.js");
+        await runPiPackagesCli([argv[0] ?? "node", "pibo pi-packages", ...args]);
+    });
+    program
+        .command("debug")
+        .description("Inspect local Pibo data")
+        .helpOption(false)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args) => {
+        const { runDebugCli } = await import("./debug/index.js");
+        await runDebugCli([argv[0] ?? "node", "pibo debug", ...args]);
+    });
+    program
+        .command("data")
+        .description("Inspect and maintain Pibo data stores")
+        .helpOption(false)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args) => {
+        const { runDataCli } = await import("./data/cli.js");
+        await runDataCli([argv[0] ?? "node", "pibo data", ...args]);
+    });
+    program
+        .command("compute")
+        .description("Manage Pibo Docker compute workers")
+        .helpOption(false)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args) => {
+        const { runComputeCli } = await import("./compute/cli.js");
+        await runComputeCli([argv[0] ?? "node", "pibo compute", ...args]);
+    });
+    program
+        .command("resources")
+        .description("Inspect and safely reap managed compute and browser resources")
+        .helpOption(false)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args) => {
+        const { runResourcesCli } = await import("./resources/cli.js");
+        await runResourcesCli([argv[0] ?? "node", "pibo resources", ...args]);
+    });
+    program
+        .command("setup")
+        .description("Plan user-host installs and developer-host upgrades")
+        .helpOption(false)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args) => {
+        const { runSetupCli } = await import("./setup/cli.js");
+        await runSetupCli([argv[0] ?? "node", "pibo setup", ...args]);
+    });
+    program
+        .command("skills")
+        .description("Manage Pibo user skills")
+        .helpOption(false)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args) => {
+        const { runSkillsCli } = await import("./skills/cli.js");
+        await runSkillsCli([argv[0] ?? "node", "pibo skills", ...args]);
+    });
+    program
+        .command("cron")
+        .description("Manage scheduled Pibo jobs")
+        .helpOption(false)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args) => {
+        const { runCronCli } = await import("./cron/cli.js");
+        await runCronCli([argv[0] ?? "node", "pibo cron", ...args]);
+    });
+    program
+        .command("ralph")
+        .description("Manage continuous Ralph jobs")
+        .helpOption(false)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args) => {
+        const { runRalphCli } = await import("./ralph/cli.js");
+        await runRalphCli([argv[0] ?? "node", "pibo ralph", ...args]);
+    });
+    program
+        .command("vscode")
+        .description("Manage the Pibo VS Code extension")
+        .helpOption(false)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args) => {
+        const { runVscodeCli } = await import("./vscode/cli.js");
+        await runVscodeCli([argv[0] ?? "node", "pibo vscode", ...args]);
+    });
+    const config = program.command("config").description(`Manage pibo config at ${getDefaultPiboConfigPath()}`).helpOption(false);
+    config.action(() => {
+        printConfigDiscovery();
+    });
+    config
+        .command("set")
+        .argument("<key>")
+        .argument("<value>")
+        .description("Set a config value")
+        .action((key, value) => {
+        const nextConfig = setPiboConfigValue(loadPiboConfig(), key, value);
+        savePiboConfig(nextConfig);
+        console.log(`Set ${key}`);
+    });
+    config
+        .command("get")
+        .argument("<key>")
+        .description("Print a config value")
+        .action((key) => {
+        const value = getDisplayPiboConfigValue(loadPiboConfig(), key);
+        if (value === undefined) {
+            process.exitCode = 1;
+            return;
+        }
+        if (typeof value === "string")
+            console.log(value);
+        else
+            printJson(value);
+    });
+    config
+        .command("del")
+        .argument("<key>")
+        .description("Delete a config value")
+        .action((key) => {
+        savePiboConfig(deletePiboConfigValue(loadPiboConfig(), key));
+        console.log(`Deleted ${key}`);
+    });
+    config.command("keys").description("List supported config keys").action(printConfigKeys);
+    config
+        .command("show")
+        .description("Print the complete config")
+        .action(() => {
+        printJson(redactPiboConfig(loadPiboConfig()));
+    });
+    program
+        .command("profile")
+        .helpOption("-h, --help", "Display help for command")
+        .argument("[profile]")
+        .description("Inspect a pibo profile")
+        .addHelpText("after", "\nProfiles include built-in plugin profiles plus active saved Chat custom agents from $PIBO_HOME/chat-agents.sqlite. Archived custom agents are not exposed.\n")
+        .action(async (profile) => {
+        const { inspectPiboProfile } = await import("./core/runtime.js");
+        printJson(await inspectPiboProfile({ profile: await createCliProfile(profile) }));
+    });
+    program
+        .command("tui")
+        .argument("[profile]")
+        .description("Start the Pi TUI through pibo")
+        .action(async (profile) => {
+        const { runPiboTui } = await import("./core/runtime.js");
+        await runPiboTui({ profile: await createCliProfile(profile) });
+    });
+    program
+        .command("tui:routed")
+        .helpOption("-h, --help", "Display help for command")
+        .option("--show-thinking", "Show routed thinking deltas in the local TUI")
+        .option("--thinking <level>", "Set routed thinking level: off, minimal, low, medium, high, xhigh, max", parsePiboThinkingLevel)
+        .argument("[profile]")
+        .description("Start the local routed Pibo TUI")
+        .action(async (profile, options) => {
+        const { runLocalRoutedTui } = await import("./local/tui.js");
+        await runLocalRoutedTui({
+            profile,
+            showThinking: options.showThinking === true,
+            thinkingLevel: options.thinking,
+        });
+    });
+    program
+        .command("tui:sessions")
+        .description("Start the reduced Web Chat-derived session UI")
+        .option("--session <id>", "Open a specific Pibo session id")
+        .option("--max-rows <count>", "Limit rendered transcript rows", parsePositiveInteger)
+        .option("--demo", "Use deterministic fake session data for smoke testing")
+        .action(async (options) => {
+        const { runCliSessionsUi } = await import("./apps/cli-ui/index.js");
+        await runCliSessionsUi({
+            initialSessionId: options.session,
+            maxRows: options.maxRows,
+            useFakeSource: options.demo === true,
+        });
+    });
+    program
+        .command("router")
+        .argument("[piboSessionId]", "Pibo session id", "demo")
+        .description("Emit a demo router status event")
+        .action(async (piboSessionId) => {
+        const { PiboSessionRouter } = await import("./core/session-router.js");
+        const router = new PiboSessionRouter({ persistSession: false });
+        const event = await router.emit({
+            type: "execution",
+            piboSessionId,
+            action: "status",
+        });
+        printJson(event);
+        await router.disposeAll();
+    });
+    program
+        .command("gateway:web")
+        .description("Start the authenticated web gateway")
+        .option("--auth <mode>", "Auth service mode: 'better-auth' (default) or 'local' (loopback-only, no Google OAuth)")
+        .option("--web-host <host>", "Bind the HTTP web host, for example 0.0.0.0 for LAN access")
+        .option("--web-port <port>", "Bind the HTTP web host port", parsePort)
+        .option("--gateway-port <port>", "Bind the agent-runtime gateway port", parsePort)
+        .action(async (options) => {
+        warnIfUnsupportedGatewayNodeVersion();
+        const { runWebGatewayServer } = await import("./gateway/web.js");
+        const authMode = options.auth;
+        if (authMode !== undefined && authMode !== "better-auth" && authMode !== "local") {
+            throw new Error(`--auth must be 'better-auth' or 'local', got '${authMode}'`);
+        }
+        if (authMode === "local" && options.webHost !== undefined && !isLoopbackBindForCli(options.webHost) && !isComputeWorkerRuntimeForCli()) {
+            throw new Error(`--auth=local requires a loopback bind (127.0.0.1, ::1, or localhost). Got --web-host='${options.webHost}'. ` +
+                "Either drop --web-host or pick --auth=better-auth for a public bind.");
+        }
+        await runWebGatewayServer({
+            authMode: authMode,
+            port: options.gatewayPort ?? defaultGatewayPortForWebPort(options.webPort),
+            web: {
+                host: options.webHost,
+                port: options.webPort,
+            },
+        });
+    });
+    program
+        .command("client")
+        .argument("[piboSessionId]", "Pibo session id", "default")
+        .description("Start a console gateway client")
+        .action(async (piboSessionId) => {
+        const { runGatewayClient } = await import("./gateway/client.js");
+        await runGatewayClient({ piboSessionId });
+    });
+    if (argv.length <= 2) {
+        printRootDiscovery();
+        return;
+    }
+    await program.parseAsync(argv);
+}
+function warnIfUnsupportedGatewayNodeVersion() {
+    const major = Number(process.versions.node.split(".")[0]);
+    if (Number.isFinite(major) && major >= 24)
+        return;
+    const message = `Pibo gateway:web requires Node >=24; current runtime is ${process.version}. Upgrade Node before production gateway use.`;
+    if (process.env.PIBO_STRICT_NODE_ENGINE === "1")
+        throw new Error(message);
+    console.warn(`[pibo] warning: ${message}`);
+}
+function printRootDiscoveryText() {
+    return `pibo - agent-oriented CLI
+
+Commands:
+  config       Manage local pibo config
+  mcp          Discover and call configured MCP servers
+  tools        Install and inspect curated external CLI tools
+  pi-packages  Register Pi Coding Agent packages
+  debug        Inspect local Pibo data
+  data         Inspect and maintain Pibo data stores
+  compute      Manage Pibo Docker compute workers
+  resources    Inspect and safely reap managed compute and browser resources
+  setup        Plan user-host installs and developer-host upgrades
+  skills       Manage Pibo user skills
+  cron         Manage scheduled Pibo jobs
+  ralph        Manage continuous Ralph jobs
+  vscode       Manage the Pibo VS Code extension
+  profile      Inspect a pibo profile, including active saved Chat custom agents
+  tui          Start the direct Pi TUI
+  tui:routed   Start the local routed Pibo TUI
+  tui:sessions  Start the reduced Web Chat-derived session UI
+  gateway      Inspect and restart host gateways through safe CLI commands
+  gateway:web  Start a web gateway runtime (use --auth=local for loopback-only local auth)
+
+Options:
+  --version    Print the Pibo CLI version
+
+Next:
+  pibo <command> --help
+`;
+}
+function printConfigDiscoveryText() {
+    return `pibo config - local config at ${getDefaultPiboConfigPath()}
+
+Commands:
+  keys               List supported config keys
+  show               Print redacted config JSON
+  get <key>          Print one redacted config value
+  set <key> <value>  Set one config value
+  del <key>          Delete one config value
+
+Next:
+  pibo config keys
+`;
+}