@getpaseo/server 0.9.2 → 0.10.0

package/dist/server/server/agent/providers/pi/test-utils/fake-pi.js

@@ -0,0 +1,355 @@
+import { buildPiLaunch } from "../runtime.js";
+export class FakePi {
+    constructor(command = ["pi"]) {
+        this.recordedLaunches = [];
+        this.sessions = [];
+        this.queuedCommands = [];
+        this.queuedSessionSetups = [];
+        this.command = command;
+    }
+    async startSession(input) {
+        const launch = buildPiLaunch({
+            command: this.command,
+            session: input,
+        });
+        this.recordedLaunches.push(launch);
+        const session = new FakePiSession(launch);
+        session.commands = this.queuedCommands.shift() ?? [];
+        this.queuedSessionSetups.shift()?.(session);
+        this.sessions.push(session);
+        return session;
+    }
+    queueCommands(commands) {
+        this.queuedCommands.push(commands);
+    }
+    queueSessionSetup(setup) {
+        this.queuedSessionSetups.push(setup);
+    }
+    latestSession() {
+        const session = this.sessions.at(-1);
+        if (!session) {
+            throw new Error("FakePi has no sessions");
+        }
+        return session;
+    }
+}
+export class FakePiSession {
+    constructor(launch) {
+        this.prompts = [];
+        this.steerCalls = [];
+        this.steerError = null;
+        this.controlRequests = [];
+        this.clearQueueError = null;
+        this.compactRequests = [];
+        this.setAutoCompactionRequests = [];
+        this.subagentSubscriptionRequests = [];
+        this.subagentMessageRequests = [];
+        this.setModelRequests = [];
+        this.setThinkingLevelRequests = [];
+        this.treeNavigationRequests = [];
+        this.handoffRequests = [];
+        this.sessionNameRequests = [];
+        this.rawFrames = [];
+        // Every user entry in the session file, including rewound and compacted ones.
+        this.treeUserEntries = [];
+        // The user entries on the current branch that getMessages() replays.
+        this.contextUserEntries = [];
+        this.abortRequested = false;
+        this.canceledExtensionUiRequests = [];
+        this.extensionUiResponses = [];
+        this.setModelResult = null;
+        this.models = [];
+        this.messages = [];
+        this.stats = {
+            tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+            cost: 0,
+        };
+        this.commands = [];
+        this.subagents = [];
+        this.subagentSubscriptionError = null;
+        this.setSessionNameError = null;
+        this.compactError = null;
+        this.emitCompactEnd = true;
+        this.getStateError = null;
+        this.getSessionStatsError = null;
+        this.promptAck = {};
+        this.branchResponse = { text: "" };
+        this.branchRequests = [];
+        this.subscribers = new Set();
+        this.subagentMessageResults = new Map();
+        this.nextHeldPrompt = null;
+        this.activeHeldPrompt = null;
+        this.state = {
+            model: null,
+            thinkingLevel: "medium",
+            isStreaming: false,
+            isCompacting: false,
+            autoCompactionEnabled: true,
+            sessionFile: launch.session ?? "/tmp/pi-session",
+            sessionId: "pi-session-1",
+            messageCount: 0,
+            pendingMessageCount: 0,
+        };
+    }
+    onEvent(callback) {
+        this.subscribers.add(callback);
+        return () => {
+            this.subscribers.delete(callback);
+        };
+    }
+    async prompt(message, images) {
+        this.prompts.push({ message, imageCount: images?.length ?? 0 });
+        const heldPrompt = this.nextHeldPrompt;
+        if (heldPrompt) {
+            this.nextHeldPrompt = null;
+            this.activeHeldPrompt = heldPrompt;
+            try {
+                await heldPrompt.promise;
+            }
+            finally {
+                if (this.activeHeldPrompt === heldPrompt) {
+                    this.activeHeldPrompt = null;
+                }
+            }
+        }
+        this.handleTreeNavigationCommand(message);
+        this.handleEntryCaptureCommand(message);
+        return this.promptAck;
+    }
+    holdNextPrompt() {
+        if (this.nextHeldPrompt || this.activeHeldPrompt) {
+            throw new Error("FakePi already has a held prompt");
+        }
+        let reject;
+        const promise = new Promise((_resolve, rejectPromise) => {
+            reject = rejectPromise;
+        });
+        this.nextHeldPrompt = { promise, reject };
+    }
+    async failHeldPrompt(error) {
+        const heldPrompt = this.activeHeldPrompt ?? this.nextHeldPrompt;
+        if (!heldPrompt) {
+            throw new Error("FakePi has no held prompt");
+        }
+        heldPrompt.reject(error);
+        await new Promise((resolve) => setImmediate(resolve));
+    }
+    async steer(message, images) {
+        this.steerCalls.push({ message, imageCount: images?.length ?? 0 });
+        if (this.steerError) {
+            throw this.steerError;
+        }
+    }
+    async clearQueue() {
+        this.controlRequests.push("clear_queue");
+        if (this.clearQueueError) {
+            throw this.clearQueueError;
+        }
+    }
+    async compact(customInstructions) {
+        this.compactRequests.push(customInstructions === undefined ? {} : { customInstructions });
+        this.emit({ type: "compaction_start", reason: "manual" });
+        if (this.emitCompactEnd) {
+            this.emit({ type: "compaction_end", reason: "manual" });
+        }
+        if (this.compactError) {
+            throw this.compactError;
+        }
+    }
+    async setAutoCompaction(enabled) {
+        this.setAutoCompactionRequests.push(enabled);
+        this.state = {
+            ...this.state,
+            autoCompactionEnabled: enabled,
+        };
+    }
+    async abort() {
+        this.controlRequests.push("abort");
+        this.abortRequested = true;
+    }
+    async getState() {
+        if (this.getStateError) {
+            throw this.getStateError;
+        }
+        return this.state;
+    }
+    async getMessages() {
+        return this.messages;
+    }
+    async getAvailableModels(_timeoutMs) {
+        return this.models;
+    }
+    async setModel(provider, modelId) {
+        this.setModelRequests.push({ provider, modelId });
+        if (!this.setModelResult) {
+            throw new Error("FakePi setModel requires setModelResult to be scripted");
+        }
+        this.state = { ...this.state, model: this.setModelResult };
+        return this.setModelResult;
+    }
+    async setThinkingLevel(level) {
+        this.setThinkingLevelRequests.push(level);
+    }
+    async getSessionStats() {
+        if (this.getSessionStatsError) {
+            throw this.getSessionStatsError;
+        }
+        return this.stats;
+    }
+    async setSubagentSubscription(level) {
+        this.subagentSubscriptionRequests.push(level);
+        if (this.subagentSubscriptionError) {
+            throw this.subagentSubscriptionError;
+        }
+    }
+    async getSubagents() {
+        return this.subagents;
+    }
+    async getSubagentMessages(selector) {
+        this.subagentMessageRequests.push(selector);
+        const key = selector.sessionFile ?? selector.subagentId;
+        if (!key) {
+            throw new Error("FakePi getSubagentMessages requires a selector");
+        }
+        const results = this.subagentMessageResults.get(key);
+        const result = results?.shift();
+        if (!result) {
+            throw new Error(`FakePi has no subagent messages queued for ${key}`);
+        }
+        return result;
+    }
+    queueSubagentMessages(result) {
+        const results = this.subagentMessageResults.get(result.sessionFile) ?? [];
+        results.push(result);
+        this.subagentMessageResults.set(result.sessionFile, results);
+    }
+    async getCommands() {
+        return this.commands;
+    }
+    sendRawFrame(frame) {
+        this.rawFrames.push(frame);
+    }
+    async request(command) {
+        switch (command.type) {
+            case "set_subagent_subscription":
+                await this.setSubagentSubscription(command.level);
+                return {};
+            case "get_subagents":
+                return { subagents: await this.getSubagents() };
+            case "get_subagent_messages":
+                return await this.getSubagentMessages({
+                    ...(typeof command.subagentId === "string" ? { subagentId: command.subagentId } : {}),
+                    ...(typeof command.sessionFile === "string" ? { sessionFile: command.sessionFile } : {}),
+                    ...(typeof command.fromByte === "number" ? { fromByte: command.fromByte } : {}),
+                });
+            case "branch": {
+                const entryId = typeof command.entryId === "string" ? command.entryId : "";
+                this.branchRequests.push(entryId);
+                return this.branchResponse;
+            }
+            case "handoff":
+                this.handoffRequests.push(typeof command.customInstructions === "string"
+                    ? { customInstructions: command.customInstructions }
+                    : {});
+                return {};
+            case "set_session_name":
+                this.sessionNameRequests.push(typeof command.name === "string" ? command.name : "");
+                if (this.setSessionNameError) {
+                    throw this.setSessionNameError;
+                }
+                return {};
+            default:
+                throw new Error(`FakePi request does not implement ${command.type}`);
+        }
+    }
+    respondToExtensionUiRequest(id, response) {
+        this.extensionUiResponses.push({ id, response });
+    }
+    cancelExtensionUiRequest(id) {
+        this.canceledExtensionUiRequests.push(id);
+        this.respondToExtensionUiRequest(id, { cancelled: true });
+    }
+    async close() { }
+    emit(event) {
+        for (const subscriber of this.subscribers) {
+            subscriber(event);
+        }
+    }
+    finishAgentRun({ message, willRetry }) {
+        this.messages = [...this.messages, message];
+        this.emit({
+            type: "agent_end",
+            messages: this.messages,
+            willRetry,
+        });
+    }
+    settleTurn() {
+        this.emit({ type: "agent_settled" });
+    }
+    finishTurn(message = { role: "assistant", content: [] }) {
+        this.finishAgentRun({ message, willRetry: false });
+        this.settleTurn();
+    }
+    finishLegacyTurn(message = { role: "assistant", content: [] }) {
+        this.messages = [...this.messages, message];
+        this.emit({ type: "agent_end", messages: this.messages });
+    }
+    finishSubmittedUserMessage(entry) {
+        this.emit({
+            type: "message_end",
+            message: { role: "user", content: entry.text },
+        });
+        this.emit({
+            type: "extension_ui_request",
+            id: `submitted-user-${entry.id}`,
+            method: "notify",
+            message: `PASEO_SUBMITTED_USER_ENTRY ${JSON.stringify({ entry })}`,
+        });
+    }
+    handleTreeNavigationCommand(message) {
+        const prefix = "/paseo_tree ";
+        if (!message.startsWith(prefix)) {
+            return;
+        }
+        const payload = JSON.parse(Buffer.from(message.slice(prefix.length), "base64url").toString("utf8"));
+        if (typeof payload.targetId !== "string" || typeof payload.requestId !== "string") {
+            return;
+        }
+        this.treeNavigationRequests.push(payload.targetId);
+        this.emitEntryCapture(undefined, "tree_navigation");
+        this.emitExtensionCommandResult(payload.requestId, { ok: true, result: {} });
+    }
+    handleEntryCaptureCommand(message) {
+        const prefix = "/paseo_capture_entries ";
+        if (!message.startsWith(prefix)) {
+            return;
+        }
+        const payload = JSON.parse(Buffer.from(message.slice(prefix.length), "base64url").toString("utf8"));
+        if (typeof payload.requestId !== "string") {
+            return;
+        }
+        this.emitEntryCapture(payload.requestId, typeof payload.reason === "string" ? payload.reason : "command");
+    }
+    emitEntryCapture(requestId, reason = "test") {
+        this.emit({
+            type: "extension_ui_request",
+            id: `capture-${requestId ?? reason}`,
+            method: "notify",
+            message: `PASEO_ENTRY_CAPTURE ${JSON.stringify({
+                reason,
+                requestId,
+                treeEntries: this.treeUserEntries,
+                contextEntries: this.contextUserEntries,
+            })}`,
+        });
+    }
+    emitExtensionCommandResult(requestId, result) {
+        this.emit({
+            type: "extension_ui_request",
+            id: `command-${requestId}`,
+            method: "notify",
+            message: `PASEO_COMMAND_RESULT ${JSON.stringify({ requestId, ...result })}`,
+        });
+    }
+}
+//# sourceMappingURL=fake-pi.js.map

package/dist/server/server/agent/providers/pi/tool-call-mapper.d.ts

@@ -48,11 +48,7 @@ interface PiToolResultObject {
 }
 interface PiToolResultDetails {
     diff?: string;
-    mode?: string;
-    server?: string;
-    tool?: string;
-    mcpResult?: unknown;
-    xdev?: unknown;
+    [key: string]: unknown;
 }
 interface PiToolResultTextContent {
     type: "text";
@@ -107,7 +103,6 @@ export type PiTrackedToolCall = PiBashToolCall | PiReadToolCall | PiEditToolCall
 export declare function parseToolResult(rawResult: unknown): PiToolResult;
 export declare function extractTextFromToolResult(result: PiToolResult): string | undefined;
 export declare function parseToolArgs(toolName: string, rawArgs: unknown): PiTrackedToolCall;
-export declare function resolveToolCallName(toolCall: PiTrackedToolCall, result?: PiToolResult): string;
 export declare function mapToolDetail(toolCall: PiTrackedToolCall, result?: PiToolResult): ToolCallDetail;
 export {};
 //# sourceMappingURL=tool-call-mapper.d.ts.map

package/dist/server/server/agent/providers/pi/tool-call-mapper.js

@@ -17,12 +17,6 @@ const PiToolResultDetailsSchema = z
     diff: z.string().optional(),
 })
     .passthrough();
-const XdevExecuteDetailsSchema = z.object({
-    tool: z.string().trim().min(1),
-    mode: z.literal("execute"),
-    args: z.unknown().optional(),
-    inner: z.unknown().optional(),
-});
 const PiToolResultObjectSchema = z
     .object({
     output: z.string().optional(),
@@ -35,12 +29,6 @@ const PiToolResultObjectSchema = z
 })
     .passthrough();
 const PiToolResultSchema = z.union([z.string(), PiToolResultObjectSchema, z.null()]);
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readNonEmptyString(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
 const BashToolInputSchema = z.object({
     command: z.string(),
     timeout: z.number().optional(),
@@ -128,47 +116,8 @@ export function parseToolArgs(toolName, rawArgs) {
     }
     return { kind: "unknown", toolName, args: rawArgs ?? null };
 }
-function stripMcpProxyPrefix(toolName, serverName) {
-    const prefix = `${serverName}_`;
-    return toolName.startsWith(prefix) ? toolName.slice(prefix.length) : toolName;
-}
-export function resolveToolCallName(toolCall, result) {
-    if (toolCall.kind === "write" && result && typeof result !== "string") {
-        const xdev = XdevExecuteDetailsSchema.safeParse(result.details?.xdev);
-        if (xdev.success) {
-            return xdev.data.tool;
-        }
-    }
-    if (toolCall.toolName !== "mcp") {
-        return toolCall.toolName;
-    }
-    if (result && typeof result !== "string") {
-        const serverName = readNonEmptyString(result.details?.server);
-        const toolName = readNonEmptyString(result.details?.tool);
-        if (serverName && toolName) {
-            return `${serverName}.${toolName}`;
-        }
-    }
-    if (isRecord(toolCall.args)) {
-        const requestedTool = readNonEmptyString(toolCall.args.tool);
-        const requestedServer = readNonEmptyString(toolCall.args.server);
-        if (requestedTool && requestedServer) {
-            return `${requestedServer}.${stripMcpProxyPrefix(requestedTool, requestedServer)}`;
-        }
-        if (requestedTool) {
-            const [serverName, ...toolParts] = requestedTool.split("_");
-            if (serverName && toolParts.length > 0) {
-                return `${serverName}.${toolParts.join("_")}`;
-            }
-        }
-    }
-    return toolCall.toolName;
-}
 export function mapToolDetail(toolCall, result) {
     const parsedResult = result ?? null;
-    if (isTaskToolCall(toolCall)) {
-        return mapTaskToolDetail(toolCall.args, parsedResult);
-    }
     switch (toolCall.kind) {
         case "bash": {
             const summary = resolveToolCallOutput(parsedResult);
@@ -199,7 +148,7 @@ export function mapToolDetail(toolCall, result) {
             };
         }
         case "write":
-            return mapWriteToolDetail(toolCall.args, parsedResult);
+            return { type: "write", filePath: toolCall.args.path, content: toolCall.args.content };
         case "find":
             return mapFindToolDetail(toolCall.args, parsedResult);
         case "grep":
@@ -214,51 +163,6 @@ export function mapToolDetail(toolCall, result) {
             };
     }
 }
-function isTaskToolCall(toolCall) {
-    if (toolCall.toolName === "task") {
-        return true;
-    }
-    if (toolCall.toolName !== "subagent" || !isRecord(toolCall.args)) {
-        return false;
-    }
-    return (toolCall.args.action === undefined &&
-        (readNonEmptyString(toolCall.args.agent) !== undefined ||
-            readNonEmptyString(toolCall.args.task) !== undefined));
-}
-function mapTaskToolDetail(args, result) {
-    const argRecord = isRecord(args) ? args : {};
-    return {
-        type: "sub_agent",
-        subAgentType: readNonEmptyString(argRecord.agent),
-        description: readNonEmptyString(argRecord.task),
-        log: extractTextFromToolResult(result)?.trim() ?? "",
-    };
-}
-function mapWriteToolDetail(args, result) {
-    if (result && typeof result !== "string" && result.details && "xdev" in result.details) {
-        const xdev = XdevExecuteDetailsSchema.safeParse(result.details.xdev);
-        if (xdev.success) {
-            return {
-                type: "unknown",
-                input: xdev.data.args ?? null,
-                output: {
-                    ...result,
-                    details: xdev.data.inner ?? null,
-                },
-            };
-        }
-        return {
-            type: "unknown",
-            input: args,
-            output: result,
-        };
-    }
-    return {
-        type: "write",
-        filePath: args.path,
-        content: args.content,
-    };
-}
 function resolveToolCallOutput(result) {
     if (typeof result === "string") {
         return { output: result };

package/dist/server/server/agent/tools/paseo-tools.js

@@ -1394,6 +1394,7 @@ export function createPaseoToolCatalog(options) {
                 throw new Error("unreachable");
         }
     }
+    const PROMPTED_AGENT_NOTIFICATION_GUIDANCE = "You will get notified when the prompted agent finishes, errors, or needs permission. Do not poll for status; continue with other work until the notification arrives.";
     registerTool("send_agent_prompt", {
         title: "Send agent prompt",
         description: "Send a task to a running agent. Agent-scoped callers run in background by default; top-level callers wait by default.",
@@ -1406,16 +1407,10 @@ export function createPaseoToolCatalog(options) {
             guidance: z.string().optional(),
         },
     }, async ({ agentId, prompt, sessionMode, background = Boolean(callerAgentId), notifyOnFinish = Boolean(callerAgentId), }) => {
-        const shouldNotifyOnFinish = Boolean(callerAgentId && notifyOnFinish && background);
-        await sendPromptToAgent({
-            agentManager,
-            agentStorage,
-            agentId,
-            prompt,
-            sessionMode,
-            logger: childLogger,
-        });
-        if (shouldNotifyOnFinish && callerAgentId) {
+        function armFinishNotification() {
+            if (!callerAgentId || !notifyOnFinish) {
+                return false;
+            }
             setupFinishNotification({
                 agentManager,
                 agentStorage,
@@ -1423,17 +1418,32 @@ export function createPaseoToolCatalog(options) {
                 callerAgentId,
                 logger: childLogger,
             });
+            return true;
         }
+        await sendPromptToAgent({
+            agentManager,
+            agentStorage,
+            agentId,
+            prompt,
+            sessionMode,
+            logger: childLogger,
+        });
         // If not running in background, wait for completion
         if (!background) {
             const result = await waitForAgentWithTimeout(agentManager, agentId, {
                 waitForActive: true,
             });
+            // The wait ran out while the agent keeps working, so its result arrives as a
+            // finish notification instead of in this response.
+            const notifying = result.timedOut &&
+                agentManager.getAgent(agentId)?.lifecycle === "running" &&
+                armFinishNotification();
             const responseData = {
                 success: true,
                 status: result.status,
                 lastMessage: result.lastMessage,
                 permission: sanitizePermissionRequest(result.permission),
+                ...(notifying ? { guidance: PROMPTED_AGENT_NOTIFICATION_GUIDANCE } : {}),
             };
             const validJson = ensureValidJson(responseData);
             const response = {
@@ -1442,6 +1452,7 @@ export function createPaseoToolCatalog(options) {
             };
             return response;
         }
+        const notifying = armFinishNotification();
         // Return immediately if background=true
         // Re-fetch snapshot since the state may have changed
         const currentSnapshot = agentManager.getAgent(agentId);
@@ -1450,11 +1461,7 @@ export function createPaseoToolCatalog(options) {
             status: currentSnapshot?.lifecycle ?? "idle",
             lastMessage: null,
             permission: null,
-            ...(shouldNotifyOnFinish
-                ? {
-                    guidance: "You will get notified when the prompted agent finishes, errors, or needs permission. Do not poll for status; continue with other work until the notification arrives.",
-                }
-                : {}),
+            ...(notifying ? { guidance: PROMPTED_AGENT_NOTIFICATION_GUIDANCE } : {}),
         };
         const validJson = ensureValidJson(responseData);
         const response = {

package/dist/server/server/auth.d.ts

@@ -2,6 +2,7 @@ import type { RequestHandler } from "express";
 export declare const DAEMON_PASSWORD_BCRYPT_COST = 12;
 export interface DaemonAuthConfig {
     password?: string;
+    localCredential?: () => string | null;
 }
 export interface BearerAuthRejectContext {
     path: string;
@@ -12,9 +13,7 @@ interface BearerValidationInput {
     password: string | undefined;
     token: string | null;
 }
-export declare function isBearerTokenValid(input: BearerValidationInput): boolean;
 export declare function isBearerTokenValidAsync(input: BearerValidationInput): Promise<boolean>;
-export declare function isBearerTokenValidSync(input: BearerValidationInput): boolean;
 export declare function hashDaemonPassword(password: string): string;
 export declare function extractHttpBearerToken(value: string | undefined): string | null;
 export declare function extractWsBearerProtocol(value: string | undefined): string | null;

package/dist/server/server/auth.js

@@ -1,9 +1,7 @@
-import { compare, compareSync, hashSync } from "bcryptjs";
+import { compare, hashSync } from "bcryptjs";
 import { timingSafeEqual } from "node:crypto";
+import { matchesLocalCredential } from "./local-credential.js";
 export const DAEMON_PASSWORD_BCRYPT_COST = 12;
-export function isBearerTokenValid(input) {
-    return isBearerTokenValidSync(input);
-}
 export async function isBearerTokenValidAsync(input) {
     if (!input.password) {
         return true;
@@ -13,15 +11,6 @@ export async function isBearerTokenValidAsync(input) {
     }
     return compare(input.token, input.password);
 }
-export function isBearerTokenValidSync(input) {
-    if (!input.password) {
-        return true;
-    }
-    if (input.token === null) {
-        return false;
-    }
-    return compareSync(input.token, input.password);
-}
 export function hashDaemonPassword(password) {
     return hashSync(password, DAEMON_PASSWORD_BCRYPT_COST);
 }
@@ -68,7 +57,12 @@ export function createRequireBearerMiddleware(auth, onReject) {
         void (async () => {
             try {
                 const token = extractHttpBearerToken(req.header("authorization"));
-                if (!(await isBearerTokenValidAsync({ password, token }))) {
+                const localCredential = req.path === "/api/status" ? auth?.localCredential?.() : null;
+                const isLocal = localCredential !== null &&
+                    localCredential !== undefined &&
+                    token !== null &&
+                    matchesLocalCredential(localCredential, token);
+                if (!isLocal && !(await isBearerTokenValidAsync({ password, token }))) {
                     onReject?.({
                         path: req.path,
                         method: req.method,