@getpaseo/server 0.1.88 → 0.1.90

package/dist/server/server/agent/providers/mock-load-test-agent.js

@@ -62,6 +62,9 @@ const MODELS = [
 function shouldEmitPlanApprovalPrompt(prompt) {
     return /emit\s+(?:a\s+)?synthetic\s+plan\s+approval/i.test(promptToText(prompt));
 }
+function shouldEmitQuestionPrompt(prompt) {
+    return /emit\s+(?:a\s+)?synthetic\s+questions?/i.test(promptToText(prompt));
+}
 function resolveModelProfile(modelId) {
     const model = MODELS.find((entry) => entry.id === modelId) ?? MODELS[0];
     const metadata = model.metadata ?? {};
@@ -389,6 +392,9 @@ export class MockLoadTestAgentSession {
         if (shouldEmitPlanApprovalPrompt(prompt)) {
             this.schedulePlanApprovalTurn(turn);
         }
+        else if (shouldEmitQuestionPrompt(prompt)) {
+            this.scheduleQuestionPromptTurn(turn);
+        }
         else if (largePayload) {
             this.scheduleLargePayloadTurn(turn, largePayload);
         }
@@ -432,9 +438,11 @@ export class MockLoadTestAgentSession {
         return Array.from(this.pendingPermissions.values());
     }
     async respondToPermission(requestId, response) {
-        if (!this.pendingPermissions.delete(requestId)) {
+        const request = this.pendingPermissions.get(requestId);
+        if (!request) {
             return undefined;
         }
+        this.pendingPermissions.delete(requestId);
         const turn = this.activeTurn;
         this.emit({
             type: "permission_resolved",
@@ -444,7 +452,9 @@ export class MockLoadTestAgentSession {
             ...(turn ? { turnId: turn.turnId } : {}),
         });
         if (turn) {
-            this.finishTurnWithText(turn, "Synthetic plan approval resolved");
+            this.finishTurnWithText(turn, request.kind === "question"
+                ? "Synthetic questions resolved"
+                : "Synthetic plan approval resolved");
         }
         return undefined;
     }
@@ -527,6 +537,12 @@ export class MockLoadTestAgentSession {
         }, 0);
         turn.timer.unref?.();
     }
+    scheduleQuestionPromptTurn(turn) {
+        turn.timer = setTimeout(() => {
+            this.emitQuestionPromptTurn(turn);
+        }, 0);
+        turn.timer.unref?.();
+    }
     emitPlanApprovalTurn(turn) {
         if (this.activeTurn !== turn) {
             return;
@@ -575,6 +591,57 @@ export class MockLoadTestAgentSession {
             turnId: turn.turnId,
         });
     }
+    emitQuestionPromptTurn(turn) {
+        if (this.activeTurn !== turn) {
+            return;
+        }
+        this.clearTurnTimer(turn);
+        this.emit({
+            type: "turn_started",
+            provider: this.provider,
+            turnId: turn.turnId,
+        });
+        const request = {
+            id: `mock-questions-${turn.turnId}`,
+            provider: this.provider,
+            name: "MockQuestions",
+            kind: "question",
+            title: "Questions",
+            input: {
+                questions: [
+                    {
+                        question: "Which surface should this apply to?",
+                        header: "surface",
+                        options: [{ label: "App" }, { label: "Desktop" }],
+                        multiSelect: false,
+                    },
+                    {
+                        question: "Which rollout should we use?",
+                        header: "rollout",
+                        options: [{ label: "Immediately" }, { label: "Behind feature flag" }],
+                        multiSelect: false,
+                    },
+                    {
+                        question: "What success criteria should we use?",
+                        header: "success",
+                        options: [],
+                        multiSelect: false,
+                        placeholder: "Describe success...",
+                    },
+                ],
+            },
+            metadata: {
+                source: "mock_questions",
+            },
+        };
+        this.pendingPermissions.set(request.id, request);
+        this.emit({
+            type: "permission_requested",
+            provider: this.provider,
+            request,
+            turnId: turn.turnId,
+        });
+    }
     emitStressTurn(turn, stress) {
         if (this.activeTurn !== turn) {
             return;

package/dist/server/server/agent/providers/opencode-agent.js

@@ -1,5 +1,6 @@
 import { homedir } from "node:os";
 import { createPathEquivalenceMatcher } from "../../../utils/path.js";
+import pLimit from "p-limit";
 import { z } from "zod";
 import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
 import { isDefaultAgentCreateConfigUnattended, resolveDefaultAgentCreateConfig, } from "../create-agent-mode.js";
@@ -57,10 +58,17 @@ function withOpenCodeAutoAcceptFeature(featureValues, enabled) {
 }
 function resolveOpenCodeCreateConfig(input) {
     const legacyFullAccess = input.requestedMode === OPENCODE_LEGACY_FULL_ACCESS_MODE_ID;
-    const inheritsUnattended = input.requestedMode === undefined && input.parent?.isUnattended === true;
-    const requestedMode = legacyFullAccess ? OPENCODE_BUILD_MODE_ID : input.requestedMode;
+    const parent = input.parent;
+    const isUnattendedCreate = input.unattended || parent?.isUnattended === true;
+    const inheritsUnattended = input.requestedMode === undefined && isUnattendedCreate;
+    const inheritedOpenCodeMode = inheritsUnattended && parent?.provider === input.provider
+        ? (parent.modeId ?? undefined)
+        : undefined;
+    const requestedMode = legacyFullAccess
+        ? OPENCODE_BUILD_MODE_ID
+        : (input.requestedMode ?? inheritedOpenCodeMode);
     const featureValues = legacyFullAccess ||
-        (inheritsUnattended && input.featureValues?.[OPENCODE_AUTO_ACCEPT_FEATURE_ID] === undefined)
+        (isUnattendedCreate && input.featureValues?.[OPENCODE_AUTO_ACCEPT_FEATURE_ID] === undefined)
         ? withOpenCodeAutoAcceptFeature(input.featureValues, true)
         : input.featureValues;
     if (inheritsUnattended && requestedMode === undefined) {
@@ -124,6 +132,8 @@ function resolveOpenCodePermissionReply(response) {
 }
 const MCP_ALREADY_PRESENT_ERROR_TOKENS = ["already", "exists", "connected"];
 const OPENCODE_PROVIDER_LIST_TIMEOUT_MS = 30000;
+const OPENCODE_METADATA_CONCURRENCY = 4;
+const openCodeMetadataLimit = pLimit(OPENCODE_METADATA_CONCURRENCY);
 const OPENCODE_HANDLED_BUILTIN_SLASH_COMMANDS = [
     { name: "compact", description: "Compact the current session", argumentHint: "" },
     { name: "summarize", description: "Compact the current session", argumentHint: "" },
@@ -918,7 +928,7 @@ export class OpenCodeAgentClient {
         try {
             // Background model discovery can be legitimately slow while OpenCode refreshes
             // provider state, so allow longer than turn execution paths.
-            const response = await withTimeout(client.provider.list({ directory: options.cwd }), OPENCODE_PROVIDER_LIST_TIMEOUT_MS, `OpenCode provider.list timed out after ${OPENCODE_PROVIDER_LIST_TIMEOUT_MS / 1000}s - server may not be authenticated or connected to any providers`);
+            const response = await openCodeMetadataLimit(() => withTimeout(client.provider.list({ directory: options.cwd }), OPENCODE_PROVIDER_LIST_TIMEOUT_MS, `OpenCode provider.list timed out after ${OPENCODE_PROVIDER_LIST_TIMEOUT_MS / 1000}s - server may not be authenticated or connected to any providers`));
             if (response.error) {
                 throw new Error(`Failed to fetch OpenCode providers: ${JSON.stringify(response.error)}`);
             }
@@ -964,7 +974,7 @@ export class OpenCodeAgentClient {
         const directory = options.cwd;
         const client = this.runtime.createClient({ baseUrl: url, directory });
         try {
-            const response = await withTimeout(client.app.agents({ directory }), 10000, "OpenCode app.agents timed out after 10s");
+            const response = await openCodeMetadataLimit(() => withTimeout(client.app.agents({ directory }), 10000, "OpenCode app.agents timed out after 10s"));
             if (response.error || !response.data) {
                 return DEFAULT_MODES;
             }
@@ -1102,7 +1112,7 @@ export class OpenCodeAgentClient {
         return normalizeOpenCodeConfig({ ...config, provider: "opencode" });
     }
     async populateModelContextWindowCache(client, cwd) {
-        const response = await client.provider.list({ directory: cwd });
+        const response = await openCodeMetadataLimit(() => client.provider.list({ directory: cwd }));
         if (response.error || !response.data) {
             return;
         }
@@ -1794,6 +1804,7 @@ function appendOpenCodeQuestionAsked(event, state, events) {
                 header: q.header,
                 options,
                 ...(q.multiple === true ? { multiSelect: true } : {}),
+                allowOther: true,
             },
         ];
     });
@@ -2467,9 +2478,9 @@ class OpenCodeAgentSession {
         if (this.availableModesCache) {
             return this.availableModesCache;
         }
-        const response = await this.client.app.agents({
+        const response = await openCodeMetadataLimit(() => this.client.app.agents({
             directory: this.config.cwd,
-        });
+        }));
         const agents = response.error || !response.data ? [] : response.data;
         const discoveredModes = agents.filter(isSelectableOpenCodeAgent).map(mapOpenCodeAgentToMode);
         this.availableModesCache = mergeOpenCodeModes(discoveredModes);

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

@@ -1148,6 +1148,19 @@ export class PiRpcAgentSession {
         }
     }
     handleMessageEnd(event, turnId) {
+        if (event.message.role === "custom") {
+            const text = getUserMessageText(event.message.content);
+            if (text) {
+                this.emit({
+                    type: "timeline",
+                    provider: PI_PROVIDER,
+                    turnId,
+                    item: { type: "assistant_message", text },
+                });
+            }
+            this.completeTurn(turnId, []);
+            return;
+        }
         if (event.message.role !== "user") {
             return;
         }

package/dist/server/server/agent/providers/pi/rpc-types.d.ts

@@ -22,6 +22,9 @@ export type PiAssistantContent = PiTextContent | PiThinkingContent | PiToolCallC
 export type PiAgentMessage = {
     role: "user";
     content: string | Array<PiTextContent | PiImageContent>;
+} | {
+    role: "custom";
+    content: string | Array<PiTextContent | PiImageContent>;
 } | {
     role: "assistant";
     content: PiAssistantContent[];

package/dist/server/server/agent/timeline-projection.js

@@ -270,7 +270,36 @@ export function selectProjectedTimelinePage(input) {
     const limit = input.limit === undefined ? 0 : Math.max(0, Math.floor(input.limit));
     const bounds = input.bounds ?? getTimelineBounds(input.rows);
     const projectedAll = projectTimelineRows({ rows: input.rows, mode: "projected" });
-    if (projectedAll.length === 0 || !bounds) {
+    if (!bounds) {
+        return {
+            entries: [],
+            startSeq: null,
+            endSeq: null,
+            hasOlder: false,
+            hasNewer: false,
+        };
+    }
+    if (projectedAll.length === 0) {
+        if (input.direction === "after") {
+            const cursorSeq = input.cursorSeq ?? bounds.minSeq - 1;
+            return {
+                entries: [],
+                startSeq: null,
+                endSeq: null,
+                hasOlder: cursorSeq >= bounds.minSeq,
+                hasNewer: cursorSeq < bounds.maxSeq,
+            };
+        }
+        if (input.direction === "before") {
+            const cursorSeq = input.cursorSeq ?? bounds.maxSeq + 1;
+            return {
+                entries: [],
+                startSeq: null,
+                endSeq: null,
+                hasOlder: cursorSeq > bounds.minSeq,
+                hasNewer: cursorSeq <= bounds.maxSeq,
+            };
+        }
         return {
             entries: [],
             startSeq: null,

package/dist/server/server/atomic-file.d.ts

@@ -0,0 +1,3 @@
+export declare function writeFileAtomic(filePath: string, data: string | NodeJS.ArrayBufferView): Promise<void>;
+export declare function writeJsonFileAtomic(filePath: string, value: unknown): Promise<void>;
+//# sourceMappingURL=atomic-file.d.ts.map

package/dist/server/server/atomic-file.js

@@ -0,0 +1,19 @@
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export async function writeFileAtomic(filePath, data) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`);
+    try {
+        await fs.writeFile(tempPath, data, "utf8");
+        await fs.rename(tempPath, filePath);
+    }
+    catch (error) {
+        await fs.rm(tempPath, { force: true });
+        throw error;
+    }
+}
+export async function writeJsonFileAtomic(filePath, value) {
+    await writeFileAtomic(filePath, JSON.stringify(value, null, 2));
+}
+//# sourceMappingURL=atomic-file.js.map

package/dist/server/server/auto-archive-on-merge/archive-if-safe.d.ts

@@ -10,6 +10,7 @@ import type { TerminalManager } from "../../terminal/terminal-manager.js";
 import { isPaseoOwnedWorktreeCwd } from "../../utils/worktree.js";
 export interface AutoArchiveArchiveOptions {
     paseoHome: string;
+    worktreesRoot?: string;
     daemonConfigStore: DaemonConfigStore;
     workspaceGitService: WorkspaceGitServiceImpl;
     github: GitHubService;

package/dist/server/server/auto-archive-on-merge/archive-if-safe.js

@@ -34,16 +34,23 @@ export async function archiveIfSafe(input) {
         if (!snapshot) {
             return;
         }
-        if (snapshot.git.isDirty === true || (snapshot.git.aheadOfOrigin ?? 0) > 0) {
+        if (snapshot.git.isDirty === true || snapshot.git.aheadOfOrigin === null) {
             return;
         }
-        const ownership = await deps.isPaseoOwnedWorktreeCwd(cwd, { paseoHome: options.paseoHome });
+        if (snapshot.git.aheadOfOrigin > 0) {
+            return;
+        }
+        const ownership = await deps.isPaseoOwnedWorktreeCwd(cwd, {
+            paseoHome: options.paseoHome,
+            worktreesRoot: options.worktreesRoot,
+        });
         if (!ownership.allowed) {
             return;
         }
         try {
             await deps.archivePaseoWorktree({
                 paseoHome: options.paseoHome,
+                worktreesRoot: options.worktreesRoot,
                 github: options.github,
                 workspaceGitService: options.workspaceGitService,
                 agentManager: options.agentManager,
@@ -64,6 +71,7 @@ export async function archiveIfSafe(input) {
                 targetPath: cwd,
                 repoRoot: ownership.repoRoot ?? null,
                 worktreesRoot: ownership.worktreeRoot,
+                worktreesBaseRoot: options.worktreesRoot,
                 requestId: "auto-archive-on-merge",
             });
             log.info({ cwd }, "Auto-archived worktree after PR merge");

package/dist/server/server/bootstrap.d.ts

@@ -21,7 +21,7 @@ import type { PushNotificationSender } from "./push/notifications.js";
 import type { AgentClient, AgentProvider } from "./agent/agent-sdk-types.js";
 import type { AgentProviderRuntimeSettingsMap, ProviderOverride } from "./agent/provider-launch-config.js";
 import type { PersistedConfig } from "./persisted-config.js";
-import { ScriptRouteStore } from "./script-proxy.js";
+import { type ServiceProxySubsystem } from "./service-proxy.js";
 import { WorkspaceScriptRuntimeStore } from "./workspace-script-runtime-store.js";
 import { type HostnamesConfig } from "./hostnames.js";
 import { type DaemonAuthConfig } from "./auth.js";
@@ -49,6 +49,7 @@ export type DaemonLifecycleIntent = {
 export interface PaseoDaemonConfig {
     listen: string;
     paseoHome: string;
+    worktreesRoot?: string;
     corsAllowedOrigins: string[];
     allowedHosts?: HostnamesConfig;
     hostnames?: HostnamesConfig;
@@ -66,6 +67,10 @@ export interface PaseoDaemonConfig {
     relayPublicEndpoint?: string;
     relayUseTls?: boolean;
     relayPublicUseTls?: boolean;
+    serviceProxy?: {
+        publicBaseUrl: string | null;
+        standaloneListen: string | null;
+    };
     appBaseUrl?: string;
     auth?: DaemonAuthConfig;
     openai?: PaseoOpenAIConfig;
@@ -93,7 +98,7 @@ export interface PaseoDaemon {
     agentManager: AgentManager;
     agentStorage: AgentStorage;
     terminalManager: TerminalManager;
-    scriptRouteStore: ScriptRouteStore;
+    serviceProxy: ServiceProxySubsystem;
     scriptRuntimeStore: WorkspaceScriptRuntimeStore;
     start(): Promise<void>;
     stop(): Promise<void>;