@pasko70/pibo 2.3.0 → 2.4.1

package/dist/mcp/index.js

@@ -9,9 +9,8 @@
  *   mcp-cli call <server> <tool>     Call tool (reads JSON from stdin if no args)
  *   mcp-cli call <server> <tool> {}  Call tool with JSON args
  */
-import { readFileSync } from 'node:fs';
 import { configCommand } from './config-command.js';
-import { ensureConfigExists, } from './config.js';
+import { ensureConfigExists, listServerNames, loadConfigUnresolved, } from './config.js';
 import { ErrorCode, ambiguousCommandError, formatCliError, missingArgumentError, tooManyArgumentsError, unknownOptionError, unknownSubcommandError, } from './errors.js';
 import { registryCommand } from './registry.js';
 import { VERSION } from './version.js';
@@ -127,37 +126,8 @@ function parseArgs(args) {
         result.command = 'info';
         const remaining = positional.slice(1);
         const { server, tool } = parseServerTool(remaining);
-        // info requires a server argument - show available servers in error
         if (!server) {
-            // Try to load config synchronously to show available servers
-            let availableServers = [];
-            const configPaths = [
-                result.configPath,
-                process.env.MCP_CONFIG_PATH,
-                './mcp_servers.json',
-                `${process.env.HOME}/.mcp_servers.json`,
-                `${process.env.HOME}/.config/mcp/mcp_servers.json`,
-            ].filter(Boolean);
-            for (const cfgPath of configPaths) {
-                try {
-                    const content = readFileSync(cfgPath, 'utf-8');
-                    const config = JSON.parse(content);
-                    if (config.mcpServers) {
-                        availableServers = Object.keys(config.mcpServers);
-                        break;
-                    }
-                }
-                catch {
-                    // Try next path
-                }
-            }
-            const serverList = availableServers.length > 0
-                ? availableServers.join(', ')
-                : '(none found)';
-            console.error('Error [MISSING_ARGUMENT]: Missing required argument for info: server');
-            console.error(`  Available servers: ${serverList}`);
-            console.error(`  Suggestion: Use 'pibo mcp info <server>' to see server details, or just 'pibo mcp' to list all`);
-            process.exit(ErrorCode.CLIENT_ERROR);
+            return result;
         }
         result.server = server;
         result.tool = tool;
@@ -371,10 +341,26 @@ export async function runMcpCli(argv = process.argv) {
                 }
                 break;
             case 'info':
+                if (!args.server) {
+                    let availableServers = [];
+                    try {
+                        availableServers = listServerNames(await loadConfigUnresolved(args.configPath));
+                    }
+                    catch {
+                        // Keep the missing-argument error focused when no valid config exists.
+                    }
+                    const serverList = availableServers.length > 0
+                        ? availableServers.join(', ')
+                        : '(none found)';
+                    console.error('Error [MISSING_ARGUMENT]: Missing required argument for info: server');
+                    console.error(`  Available servers: ${serverList}`);
+                    console.error(`  Suggestion: Use 'pibo mcp info <server>' to see server details, or just 'pibo mcp' to list all`);
+                    process.exitCode = ErrorCode.CLIENT_ERROR;
+                    break;
+                }
                 await ensureConfigExists(args.configPath);
                 {
                     const { infoCommand } = await import('./commands/info.js');
-                    // info always has a server (validated in parseArgs)
                     await infoCommand({
                         target: buildTarget(args.server, args.tool),
                         withDescriptions: args.withDescriptions,

package/dist/resources/lifecycle.js

@@ -6,6 +6,8 @@ import { promisify } from "node:util";
 import { applyComputeWorkerReapPlan, buildComputeWorkerReapPlan, planReapWorkers, } from "../compute/docker.js";
 import { defaultBrowserPoolRoot, defaultBrowserUseHome, getComputeResourceHealth, parseProcessList, } from "../compute/resource-health.js";
 import { loadBrowserPoolState, reapIdleBrowserPool, } from "../tools/browser-pool.js";
+import { resolveDeploymentPoolConfig } from "../compute/pool/config.js";
+import { applyDeploymentPoolReapPlan, planDeploymentPoolReap } from "../compute/pool/service.js";
 const execFileAsync = promisify(execFile);
 export async function collectManagedBrowserPools(rootDir) {
     const records = [];
@@ -56,7 +58,7 @@ export async function getActiveResourceLeases(browserPoolRoot = defaultBrowserPo
 export async function planResourceReap(options = {}) {
     const now = options.now ?? new Date();
     const resolved = resolveReapOptions(options);
-    const [records, staleFiles, compute, health] = await Promise.all([
+    const [records, staleFiles, compute, health, deploymentPool] = await Promise.all([
         collectManagedBrowserPools(resolved.browserPoolRoot),
         planStaleCdpFiles(resolved.browserUseHome),
         planComputeReapSafely({ includeDev: resolved.includeDev, maxAgeMinutes: resolved.maxAgeMinutes, now }),
@@ -66,9 +68,10 @@ export async function planResourceReap(options = {}) {
             browserUseHome: resolved.browserUseHome,
             exemptBrowserUserDataDirs: [],
         }),
+        planDeploymentPoolReapSafely(now),
     ]);
     const unmanagedBrowsers = buildUnmanagedBrowserPlanItems(health.browserProcesses.unassignedMainProcessDetails, resolved.unmanagedBrowserGraceMinutes, new Set(resolved.exemptBrowserPids), new Set(resolved.exemptBrowserUserDataDirs), resolved.browserUseHome);
-    return buildResourceReapPlan({ now, options: resolved, records, staleFiles, unmanagedBrowsers, compute });
+    return buildResourceReapPlan({ now, options: resolved, records, staleFiles, unmanagedBrowsers, compute, deploymentPool });
 }
 export function buildResourceReapPlan(input) {
     const browserItems = input.records.map((record) => buildBrowserReapPlanItem(record, input.now, input.options.idleTimeoutMinutes));
@@ -89,6 +92,7 @@ export function buildResourceReapPlan(input) {
             skipped: unmanagedBrowsers.filter((item) => item.action === "skip").length,
         },
         compute: input.compute,
+        deploymentPool: input.deploymentPool,
         worktreesPreserved: true,
     };
 }
@@ -112,6 +116,9 @@ export async function applyResourceReapPlan(plan, dependencies = {}) {
     }
     const removedStaleFiles = await applyStaleCdpFilePlan(confirmed.staleFiles.items, dependencies.isPidAlive);
     const removedComputeWorkers = await (dependencies.applyCompute ?? applyComputeWorkerReapPlan)(confirmed.compute);
+    const deploymentPoolResult = confirmed.deploymentPool
+        ? await (dependencies.applyDeploymentPool ?? applyDeploymentPoolReapPlan)(confirmed.deploymentPool)
+        : undefined;
     return {
         applied: true,
         plan: confirmed,
@@ -119,6 +126,8 @@ export async function applyResourceReapPlan(plan, dependencies = {}) {
         terminatedUnmanagedBrowsers,
         removedStaleFiles,
         removedComputeWorkers,
+        deploymentPoolResult,
+        removedDeploymentLeases: deploymentPoolResult?.releasedLeases ?? [],
         worktreesPreserved: true,
     };
 }
@@ -287,6 +296,17 @@ export async function planComputeReapSafely(options, planCompute = planReapWorke
         return plan;
     }
 }
+async function planDeploymentPoolReapSafely(now) {
+    const config = resolveDeploymentPoolConfig();
+    if (!existsSync(config.databasePath))
+        return undefined;
+    try {
+        return await planDeploymentPoolReap({ config, now });
+    }
+    catch {
+        return undefined;
+    }
+}
 async function planStaleCdpFiles(browserUseHome, isPidAlive = defaultIsPidAlive) {
     const stateDir = join(browserUseHome, "pibo-cdp");
     let files;

package/dist/resources/reaper.js

@@ -95,6 +95,7 @@ export class ResourceReaperService {
                     unmanagedBrowsers: result.terminatedUnmanagedBrowsers.length,
                     staleFiles: result.removedStaleFiles.length,
                     computeWorkers: result.removedComputeWorkers.length,
+                    ...(result.deploymentPoolResult ? { deploymentLeases: result.removedDeploymentLeases?.length ?? 0 } : {}),
                 },
                 lastError: undefined,
             };

package/dist/session-ui/sessionActivity.js

@@ -1,12 +1,16 @@
+import { resolveSessionSignalStatus } from "../signals/status.js";
 export function resolveSessionActivity(signal, fallback = {}) {
     if (!signal)
         return fallbackSessionActivity(fallback);
     const latestTurn = signal.latestTurn;
     const isTurnActive = latestTurn?.state === "running";
     const isTreeActive = signal.isTreeActive || isTurnActive;
-    const hasError = signal.hasError || signal.hasErrorDescendant || signal.aggregateStatus === "error";
     return {
-        status: hasError ? "error" : isTreeActive ? "running" : "idle",
+        status: resolveSessionSignalStatus({
+            isTreeActive,
+            localStatus: signal.localStatus,
+            latestTurn,
+        }),
         isTreeActive,
         isTurnActive,
         activeTurnId: isTurnActive ? latestTurn.eventId : undefined,

package/dist/signals/status.js

@@ -1,12 +1,17 @@
+export function resolveSessionSignalStatus(snapshot) {
+    if (snapshot.isTreeActive || snapshot.latestTurn?.state === "running")
+        return "running";
+    if (snapshot.localStatus === "error" || snapshot.latestTurn?.state === "failed")
+        return "error";
+    return "idle";
+}
 export function summarizeSessionSignalStatus(snapshot) {
-    const isTurnActive = snapshot.latestTurn?.state === "running";
-    const hasError = snapshot.hasError || snapshot.hasErrorDescendant || snapshot.aggregateStatus === "error";
-    const isTreeActive = snapshot.isTreeActive || isTurnActive;
+    const isTreeActive = snapshot.isTreeActive || snapshot.latestTurn?.state === "running";
     return {
         piboSessionId: snapshot.piboSessionId,
         rootPiboSessionId: snapshot.rootPiboSessionId,
         updatedAt: snapshot.updatedAt,
-        status: isTreeActive ? "running" : hasError ? "error" : "idle",
+        status: resolveSessionSignalStatus(snapshot),
         isTreeActive,
     };
 }

package/dist/tools/guides.js

@@ -46,7 +46,7 @@ pibo loop stop <job-id>
 pibo loop cancel <job-id>
 \`\`\`
 
-Token budgets count usage reported by completed assistant model messages. One request can overshoot because usage is known after the response returns.
+New Goals persist token-accounting version \`1\` with basis \`uncached\`: their budgets count uncached input and output usage reported by completed assistant model messages, while cache-read and cache-write tokens remain telemetry and do not consume the budget. Legacy persisted Goal jobs and runs without an accounting descriptor remain on version \`1\` basis \`total\`, including cache reads and writes, so their existing counters are neither relabeled nor numerically reconstructed without source data. Inspect \`pibo loop list --all --json\` and \`pibo loop runs --job <job-id> --json\` for the persisted basis. Both bases are soft because usage arrives after the response, so one request can overshoot.
 `,
 };
 export const RALPH_GUIDE = {

package/dist/web/channel.js

@@ -78,7 +78,13 @@ export function stripSocketPeerHeaderFromResponse(response) {
         headers,
     });
 }
-function createRequestBaseURL(nodeRequest, host, port) {
+function createRequestBaseURL(nodeRequest, host, port, canonicalBaseURL) {
+    const requestHost = firstHeaderValue(nodeRequest.headers.host);
+    if (canonicalBaseURL && requestHost) {
+        const canonical = new URL(canonicalBaseURL);
+        if (requestHost.toLowerCase() === canonical.host.toLowerCase())
+            return canonical.origin;
+    }
     if (isLoopbackAddress(nodeRequest.socket.remoteAddress)) {
         const forwardedHost = firstHeaderValue(nodeRequest.headers["x-forwarded-host"]);
         const forwardedProto = firstHeaderValue(nodeRequest.headers["x-forwarded-proto"]);
@@ -86,7 +92,7 @@ function createRequestBaseURL(nodeRequest, host, port) {
             return `${forwardedProto}://${forwardedHost}`;
         }
     }
-    return `http://${nodeRequest.headers.host ?? `${host}:${port}`}`;
+    return `http://${requestHost ?? `${host}:${port}`}`;
 }
 function isActiveRunStatus(status) {
     return typeof status === "string" && ["queued", "starting", "running", "streaming", "waiting", "blocked", "retrying", "compacting", "pausing"].includes(status);
@@ -235,7 +241,7 @@ export function createWebHostChannel(options = {}) {
     };
     const handleRequest = async (nodeRequest, nodeResponse) => {
         try {
-            const baseURL = createRequestBaseURL(nodeRequest, host, port);
+            const baseURL = createRequestBaseURL(nodeRequest, host, port, options.canonicalBaseURL);
             const baseRequest = await nodeRequestToWebRequest(nodeRequest, baseURL);
             // Inject the TCP socket peer into every request so the local auth
             // plugin can apply the same loopback predicate from `getSession`
@@ -278,11 +284,17 @@ export function createWebHostChannel(options = {}) {
                 await sendResponse(nodeResponse, response ?? notFound());
                 return;
             }
-            if (url.pathname === "/" && apps[0]) {
-                await sendResponse(nodeResponse, redirect(apps[0].mountPath));
-                return;
-            }
             if (url.pathname === "/") {
+                const landingApp = options.landingAppName
+                    ? apps.find((candidate) => candidate.name === options.landingAppName)
+                    : apps[0];
+                if (options.landingAppName && !landingApp) {
+                    throw new Error(`Configured landing web app "${options.landingAppName}" is not registered`);
+                }
+                if (landingApp) {
+                    await sendResponse(nodeResponse, redirect(`${landingApp.mountPath}${url.search}`));
+                    return;
+                }
                 await sendResponse(nodeResponse, responseHtml("<!doctype html><title>Pibo</title><p>No web apps registered.</p>"));
                 return;
             }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@pasko70/pibo",
-  "version": "2.3.0",
+  "version": "2.4.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@pasko70/pibo",
-      "version": "2.3.0",
+      "version": "2.4.1",
       "workspaces": [
         "packages/workflows"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "2.3.0",
+  "version": "2.4.1",
   "type": "module",
   "workspaces": [
     "packages/workflows"

package/skills/builtin/loop/SKILL.md

@@ -51,7 +51,7 @@ Prefer creating the job stopped when its prompt, target, profile, or safety boun
 
 ## Token budgets
 
-Goal token budgets are soft: Pibo accumulates usage reported after model responses, so the final turn can overshoot. Each Goal run records tokens used before the turn, remaining tokens before the turn, turn usage, and overshoot.
+Goal token budgets are soft because usage arrives after model responses, so the final turn can overshoot. New Goals use versioned `uncached` accounting: cache-read and cache-write tokens do not consume the budget. Legacy persisted Goals without an accounting descriptor remain on `total` accounting, including cache usage, because their existing counters cannot be reconstructed safely. Job status and each Goal run expose the accounting basis together with tokens used before the turn, remaining tokens, turn usage, and overshoot.
 
 Set `--token-reserve <n>` to require more than `n` tokens to remain before Pibo starts another turn. Increase or clear the budget, or lower the reserve, before resuming a budget-limited Goal.