@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/agent/providers/pi/runtime.js

@@ -0,0 +1,56 @@
+export function buildPiLaunch(input) {
+    const command = input.runtimeSettings?.command?.mode === "replace" && input.runtimeSettings.command.argv[0]
+        ? input.runtimeSettings.command.argv
+        : input.command;
+    const argv = [...command];
+    if (!hasModeRpc(argv)) {
+        argv.push("--mode", "rpc");
+    }
+    if (input.session.model) {
+        argv.push("--model", input.session.model);
+    }
+    if (input.session.thinkingOptionId) {
+        argv.push("--thinking", input.session.thinkingOptionId);
+    }
+    if (input.session.session) {
+        argv.push("--session", input.session.session);
+    }
+    const systemPrompt = input.session.systemPrompt?.trim();
+    if (systemPrompt) {
+        argv.push("--append-system-prompt", systemPrompt);
+    }
+    if (input.session.mcpConfigPath) {
+        argv.push("--mcp-config", input.session.mcpConfigPath);
+    }
+    for (const extensionPath of input.session.extensionPaths ?? []) {
+        argv.push("--extension", extensionPath);
+    }
+    return {
+        cwd: input.session.cwd,
+        argv,
+        env: input.runtimeSettings?.env || input.session.env
+            ? {
+                ...input.runtimeSettings?.env,
+                ...input.session.env,
+            }
+            : undefined,
+        model: input.session.model,
+        thinkingOptionId: input.session.thinkingOptionId,
+        session: input.session.session,
+        systemPrompt,
+        mcpConfigPath: input.session.mcpConfigPath,
+        extensionPaths: input.session.extensionPaths,
+    };
+}
+function hasModeRpc(argv) {
+    for (let i = 0; i < argv.length; i += 1) {
+        if (argv[i] === "--mode" && argv[i + 1] === "rpc") {
+            return true;
+        }
+        if (argv[i] === "--mode=rpc") {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=runtime.js.map

package/dist/server/server/agent/providers/pi/session-descriptor.d.ts

@@ -0,0 +1,16 @@
+import type { ImportableProviderSession, ListImportableSessionsOptions } from "../../agent-sdk-types.js";
+import type { ProviderRuntimeSettings } from "../../provider-launch-config.js";
+interface PiSessionDescriptorOptions extends ListImportableSessionsOptions {
+    sessionDir?: string;
+    runtimeSettings?: ProviderRuntimeSettings;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+}
+export interface PiImportSessionConfig {
+    model?: string;
+    thinkingOptionId?: string;
+}
+export declare function listPiImportableSessions(options?: PiSessionDescriptorOptions): Promise<ImportableProviderSession[]>;
+export declare function readPiImportSessionConfig(filePath: string): Promise<PiImportSessionConfig>;
+export {};
+//# sourceMappingURL=session-descriptor.d.ts.map

package/dist/server/server/agent/providers/pi/session-descriptor.js

@@ -0,0 +1,346 @@
+import { open, readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { createRealpathAwarePathMatcher } from "../../../../utils/path.js";
+const PI_CONFIG_DIR_NAME = ".pi";
+const PI_AGENT_DIR_ENV = "PI_CODING_AGENT_DIR";
+const PI_SESSION_DIR_ENV = "PI_CODING_AGENT_SESSION_DIR";
+const HEAD_BYTES = 64 * 1024;
+const TAIL_BYTES = 256 * 1024;
+const FULL_SCAN_LINE_LIMIT = 2000;
+export async function listPiImportableSessions(options = {}) {
+    const sessionsDir = await resolvePiSessionsDir(options);
+    const files = await walkJsonlFiles(sessionsDir);
+    const matchesCwd = options.cwd ? createRealpathAwarePathMatcher(options.cwd) : null;
+    const limit = options.limit ?? 20;
+    const sessions = [];
+    for (const file of files) {
+        const session = await readPiImportableSession(file);
+        if (!session)
+            continue;
+        if (matchesCwd && !matchesCwd(session.cwd))
+            continue;
+        sessions.push(session);
+    }
+    return sessions
+        .sort((left, right) => right.lastActivityAt.getTime() - left.lastActivityAt.getTime())
+        .slice(0, limit);
+}
+export async function readPiImportSessionConfig(filePath) {
+    const descriptor = await readPiSessionDescriptor(filePath);
+    if (!descriptor)
+        return {};
+    return toPiImportSessionConfig(descriptor);
+}
+async function resolvePiSessionsDir(options) {
+    const env = options.env ?? process.env;
+    const homeDir = options.homeDir ?? homedir();
+    const baseDir = options.cwd ?? process.cwd();
+    if (options.sessionDir?.trim()) {
+        return resolveConfigPath(options.sessionDir, { baseDir, homeDir });
+    }
+    const agentDir = resolvePiAgentDir({ runtimeSettings: options.runtimeSettings, env, homeDir });
+    const envSessionDir = options.runtimeSettings?.env?.[PI_SESSION_DIR_ENV] ?? env[PI_SESSION_DIR_ENV];
+    if (envSessionDir?.trim()) {
+        return resolveConfigPath(envSessionDir, { baseDir, homeDir });
+    }
+    const settingsSessionDir = await readConfiguredSessionDir({
+        agentDir,
+        cwd: options.cwd,
+    });
+    if (settingsSessionDir?.trim()) {
+        return resolveConfigPath(settingsSessionDir, { baseDir, homeDir });
+    }
+    return path.join(agentDir, "sessions");
+}
+function resolvePiAgentDir(input) {
+    const configured = input.runtimeSettings?.env?.[PI_AGENT_DIR_ENV] ?? input.env[PI_AGENT_DIR_ENV];
+    if (configured?.trim()) {
+        return resolveConfigPath(configured, { baseDir: process.cwd(), homeDir: input.homeDir });
+    }
+    return path.join(input.homeDir, PI_CONFIG_DIR_NAME, "agent");
+}
+async function readConfiguredSessionDir(input) {
+    const values = await Promise.all([
+        readSessionDirFromSettings(path.join(input.agentDir, "settings.json")),
+        input.cwd
+            ? readSessionDirFromSettings(path.join(input.cwd, PI_CONFIG_DIR_NAME, "settings.json"))
+            : null,
+    ]);
+    return values[1] ?? values[0] ?? null;
+}
+async function readSessionDirFromSettings(settingsPath) {
+    try {
+        const parsed = JSON.parse(await readFile(settingsPath, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return null;
+        }
+        const sessionDir = Reflect.get(parsed, "sessionDir");
+        return typeof sessionDir === "string" && sessionDir.trim() ? sessionDir : null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveConfigPath(value, options) {
+    if (value === "~") {
+        return options.homeDir;
+    }
+    if (value.startsWith("~/")) {
+        return path.join(options.homeDir, value.slice(2));
+    }
+    return path.isAbsolute(value) ? value : path.resolve(options.baseDir, value);
+}
+async function walkJsonlFiles(root) {
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const files = await Promise.all(entries.map(async (entry) => {
+        const entryPath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            return await walkJsonlFiles(entryPath);
+        }
+        return entry.isFile() && entry.name.endsWith(".jsonl") ? [entryPath] : [];
+    }));
+    return files.flat();
+}
+async function readPiImportableSession(filePath) {
+    const descriptor = await readPiSessionDescriptor(filePath);
+    if (!descriptor)
+        return null;
+    return {
+        providerHandleId: filePath,
+        cwd: descriptor.cwd,
+        title: descriptor.title,
+        firstPromptPreview: normalizePromptPreview(descriptor.firstUserMessage),
+        lastPromptPreview: normalizePromptPreview(descriptor.lastUserMessage ?? descriptor.firstUserMessage),
+        lastActivityAt: descriptor.lastActivityAt,
+    };
+}
+async function readPiSessionDescriptor(filePath) {
+    const firstLine = await readFirstLine(filePath);
+    if (!firstLine)
+        return null;
+    const header = parseSessionHeader(firstLine);
+    if (!header)
+        return null;
+    const tail = await readTail(filePath).catch(() => "");
+    const tailInfo = parseSessionTail(tail);
+    const headInfo = await scanSessionHead(filePath);
+    const title = tailInfo.title ?? headInfo.title ?? headInfo.firstUserMessage;
+    const model = tailInfo.model ?? headInfo.model;
+    const thinkingOptionId = tailInfo.thinkingOptionId ?? headInfo.thinkingOptionId;
+    const lastActivityAt = tailInfo.lastActivityAt ?? (await readFileMtime(filePath)) ?? header.createdAt ?? new Date(0);
+    return {
+        cwd: header.cwd,
+        title,
+        firstUserMessage: headInfo.firstUserMessage,
+        lastUserMessage: tailInfo.lastUserMessage,
+        lastActivityAt,
+        model,
+        thinkingOptionId,
+    };
+}
+function toPiImportSessionConfig(descriptor) {
+    return {
+        ...(descriptor.model ? { model: descriptor.model } : {}),
+        ...(descriptor.thinkingOptionId ? { thinkingOptionId: descriptor.thinkingOptionId } : {}),
+    };
+}
+async function readFirstLine(filePath) {
+    const handle = await open(filePath, "r").catch(() => null);
+    if (!handle)
+        return null;
+    try {
+        const buffer = Buffer.alloc(HEAD_BYTES);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        if (bytesRead <= 0)
+            return null;
+        const chunk = buffer.subarray(0, bytesRead).toString("utf8");
+        const newlineIndex = chunk.indexOf("\n");
+        return (newlineIndex === -1 ? chunk : chunk.slice(0, newlineIndex)).trim();
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+}
+async function readTail(filePath) {
+    const fileStats = await stat(filePath);
+    const start = Math.max(0, fileStats.size - TAIL_BYTES);
+    const length = fileStats.size - start;
+    const handle = await open(filePath, "r");
+    try {
+        const buffer = Buffer.alloc(length);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, start);
+        return buffer.subarray(0, bytesRead).toString("utf8");
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+}
+async function readFileMtime(filePath) {
+    try {
+        return (await stat(filePath)).mtime;
+    }
+    catch {
+        return null;
+    }
+}
+function parseSessionHeader(firstLine) {
+    const entry = parseJsonRecord(firstLine);
+    if (!entry || entry.type !== "session")
+        return null;
+    const sessionId = typeof entry.id === "string" ? entry.id : null;
+    const cwd = typeof entry.cwd === "string" ? entry.cwd : null;
+    if (!sessionId || !cwd)
+        return null;
+    const createdAt = parseDate(entry.timestamp);
+    return { sessionId, cwd, createdAt };
+}
+function parseSessionTail(tail) {
+    const lines = tail.split(/\r?\n/u);
+    let title = null;
+    let lastActivityAt = null;
+    let fallbackTimestamp = null;
+    let lastUserMessage = null;
+    let model = null;
+    let thinkingOptionId = null;
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const entry = parseJsonRecord(lines[index].trim());
+        if (!entry)
+            continue;
+        if (!title && entry.type === "session_info") {
+            title = readNonEmptyString(entry.name);
+        }
+        if (!model) {
+            model = extractModel(entry);
+        }
+        if (!thinkingOptionId) {
+            thinkingOptionId = extractThinkingOptionId(entry);
+        }
+        const entryTimestamp = parseDate(entry.timestamp);
+        if (!fallbackTimestamp && entryTimestamp) {
+            fallbackTimestamp = entryTimestamp;
+        }
+        if (entry.type !== "message")
+            continue;
+        if (!lastActivityAt && entryTimestamp) {
+            lastActivityAt = entryTimestamp;
+        }
+        if (!lastUserMessage && isRecord(entry.message) && entry.message.role === "user") {
+            lastUserMessage = extractMessageText(entry.message.content);
+        }
+    }
+    return {
+        title,
+        lastActivityAt: lastActivityAt ?? fallbackTimestamp,
+        lastUserMessage,
+        model,
+        thinkingOptionId,
+    };
+}
+async function scanSessionHead(filePath) {
+    let content;
+    try {
+        content = await readFile(filePath, "utf8");
+    }
+    catch {
+        return { title: null, firstUserMessage: null, model: null, thinkingOptionId: null };
+    }
+    let title = null;
+    let firstUserMessage = null;
+    let model = null;
+    let thinkingOptionId = null;
+    let lineCount = 0;
+    for (const rawLine of content.split(/\r?\n/u)) {
+        lineCount += 1;
+        const entry = parseJsonRecord(rawLine.trim());
+        if (!entry)
+            continue;
+        if (entry.type === "session_info") {
+            title = readNonEmptyString(entry.name) ?? title;
+        }
+        model = extractModel(entry) ?? model;
+        thinkingOptionId = extractThinkingOptionId(entry) ?? thinkingOptionId;
+        if (!firstUserMessage && entry.type === "message" && isRecord(entry.message)) {
+            if (entry.message.role === "user") {
+                firstUserMessage = extractMessageText(entry.message.content);
+            }
+        }
+        if (title && firstUserMessage && model && thinkingOptionId) {
+            break;
+        }
+        if (lineCount >= FULL_SCAN_LINE_LIMIT && firstUserMessage) {
+            break;
+        }
+    }
+    return { title, firstUserMessage, model, thinkingOptionId };
+}
+function extractModel(entry) {
+    if (entry.type === "model_change") {
+        return buildModelId(entry.provider, entry.modelId);
+    }
+    if (entry.type === "message" && isRecord(entry.message)) {
+        return buildModelId(entry.message.provider, entry.message.model);
+    }
+    return null;
+}
+function extractThinkingOptionId(entry) {
+    return entry.type === "thinking_level_change" ? readNonEmptyString(entry.thinkingLevel) : null;
+}
+function buildModelId(provider, modelId) {
+    const providerName = readNonEmptyString(provider);
+    const modelName = readNonEmptyString(modelId);
+    if (!providerName || !modelName) {
+        return null;
+    }
+    return `${providerName}/${modelName}`;
+}
+function parseJsonRecord(line) {
+    if (!line)
+        return null;
+    try {
+        const parsed = JSON.parse(line);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readNonEmptyString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function normalizePromptPreview(text) {
+    const normalized = text?.trim().replace(/\s+/g, " ") ?? "";
+    if (!normalized)
+        return null;
+    return normalized.length > 160 ? normalized.slice(0, 160) : normalized;
+}
+function parseDate(value) {
+    if (typeof value !== "string" && typeof value !== "number") {
+        return null;
+    }
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+function extractMessageText(content) {
+    if (typeof content === "string") {
+        return content.trim() || null;
+    }
+    if (!Array.isArray(content)) {
+        return null;
+    }
+    const text = content
+        .flatMap((part) => isRecord(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : [])
+        .join("\n\n")
+        .trim();
+    return text || null;
+}
+//# sourceMappingURL=session-descriptor.js.map

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

@@ -0,0 +1,83 @@
+import type { PiRuntime, PiRuntimeLaunch, PiRuntimeSession, PiStartSessionInput } from "../runtime.js";
+import type { PiAgentMessage, PiModel, PiRpcSlashCommand, PiRuntimeEvent, PiSessionState, PiSessionStats } from "../rpc-types.js";
+export declare class FakePi implements PiRuntime {
+    readonly recordedLaunches: PiRuntimeLaunch[];
+    private readonly sessions;
+    private readonly command;
+    private readonly queuedCommands;
+    constructor(command?: [string, ...string[]]);
+    startSession(input: PiStartSessionInput): Promise<FakePiSession>;
+    queueCommands(commands: PiRpcSlashCommand[]): void;
+    latestSession(): FakePiSession;
+}
+export declare class FakePiSession implements PiRuntimeSession {
+    readonly prompts: Array<{
+        message: string;
+        imageCount: number;
+    }>;
+    readonly compactRequests: Array<{
+        customInstructions?: string;
+    }>;
+    readonly setAutoCompactionRequests: boolean[];
+    readonly setModelRequests: Array<{
+        provider: string;
+        modelId: string;
+    }>;
+    readonly setThinkingLevelRequests: string[];
+    readonly treeNavigationRequests: string[];
+    capturedUserEntries: Array<{
+        id: string;
+        parentId: string | null;
+        text: string;
+    }>;
+    abortRequested: boolean;
+    readonly canceledExtensionUiRequests: string[];
+    readonly extensionUiResponses: Array<{
+        id: string;
+        response: {
+            value?: string;
+            confirmed?: boolean;
+            cancelled?: boolean;
+        };
+    }>;
+    setModelResult: PiModel | null;
+    models: PiModel[];
+    messages: PiAgentMessage[];
+    stats: PiSessionStats;
+    commands: PiRpcSlashCommand[];
+    compactError: Error | null;
+    emitCompactEnd: boolean;
+    state: PiSessionState;
+    private readonly subscribers;
+    constructor(launch: PiRuntimeLaunch);
+    onEvent(callback: (event: PiRuntimeEvent) => void): () => void;
+    prompt(message: string, images?: Array<{
+        type: "image";
+        data: string;
+        mimeType: string;
+    }>): Promise<void>;
+    compact(customInstructions?: string): Promise<void>;
+    setAutoCompaction(enabled: boolean): Promise<void>;
+    abort(): Promise<void>;
+    getState(): Promise<PiSessionState>;
+    getMessages(): Promise<PiAgentMessage[]>;
+    getAvailableModels(_timeoutMs?: number): Promise<PiModel[]>;
+    setModel(provider: string, modelId: string): Promise<PiModel>;
+    setThinkingLevel(level: string): Promise<void>;
+    getSessionStats(): Promise<PiSessionStats>;
+    getCommands(): Promise<PiRpcSlashCommand[]>;
+    respondToExtensionUiRequest(id: string, response: {
+        value?: string;
+        confirmed?: boolean;
+        cancelled?: boolean;
+    }): void;
+    cancelExtensionUiRequest(id: string): void;
+    close(): Promise<void>;
+    emit(event: PiRuntimeEvent): void;
+    finishTurn(message?: PiAgentMessage): void;
+    private handleTreeNavigationCommand;
+    private handleEntryCaptureCommand;
+    emitEntryCapture(requestId?: string, reason?: string): void;
+    private emitExtensionCommandResult;
+}
+//# sourceMappingURL=fake-pi.d.ts.map

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

@@ -0,0 +1,184 @@
+import { buildPiLaunch } from "../runtime.js";
+export class FakePi {
+    constructor(command = ["pi"]) {
+        this.recordedLaunches = [];
+        this.sessions = [];
+        this.queuedCommands = [];
+        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.sessions.push(session);
+        return session;
+    }
+    queueCommands(commands) {
+        this.queuedCommands.push(commands);
+    }
+    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.compactRequests = [];
+        this.setAutoCompactionRequests = [];
+        this.setModelRequests = [];
+        this.setThinkingLevelRequests = [];
+        this.treeNavigationRequests = [];
+        this.capturedUserEntries = [];
+        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.compactError = null;
+        this.emitCompactEnd = true;
+        this.subscribers = new Set();
+        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 });
+        this.handleTreeNavigationCommand(message);
+        this.handleEntryCaptureCommand(message);
+    }
+    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.abortRequested = true;
+    }
+    async getState() {
+        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");
+        }
+        return this.setModelResult;
+    }
+    async setThinkingLevel(level) {
+        this.setThinkingLevelRequests.push(level);
+    }
+    async getSessionStats() {
+        return this.stats;
+    }
+    async getCommands() {
+        return this.commands;
+    }
+    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);
+        }
+    }
+    finishTurn(message = { role: "assistant", content: [] }) {
+        this.messages = [...this.messages, message];
+        this.emit({ type: "agent_end", messages: this.messages });
+    }
+    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,
+                entries: this.capturedUserEntries,
+            })}`,
+        });
+    }
+    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