@getpaseo/server 0.1.101 → 0.1.102-beta.2

package/dist/server/server/session/daemon/install-origin.js

@@ -0,0 +1,64 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { isRealpathInsideRoot } from "../../../utils/path.js";
+import { PASEO_CLI_PACKAGE } from "./npm-global-cli.js";
+const PackageJsonSchema = z.object({ name: z.string().optional() }).passthrough();
+export const daemonInstallOriginRuntime = {
+    resolveCurrentServerPackageRoot,
+};
+export function validateDaemonInstallOrigin(install, daemonVersion, runtime = daemonInstallOriginRuntime) {
+    if (install.isLinked) {
+        return `The global ${PASEO_CLI_PACKAGE} install is linked; self-update only supports normal npm global installs.`;
+    }
+    if (daemonVersion && install.version !== daemonVersion) {
+        return `This daemon is not running from the npm global ${PASEO_CLI_PACKAGE} install (global npm has ${install.version}, daemon is ${daemonVersion}).`;
+    }
+    const currentServerPackageRoot = runtime.resolveCurrentServerPackageRoot();
+    if (!currentServerPackageRoot) {
+        return "Unable to verify that this daemon is running from an npm global install.";
+    }
+    if (!isCurrentServerUnderNpmInstall(currentServerPackageRoot, install)) {
+        return `This daemon is not running from the npm global ${PASEO_CLI_PACKAGE} install.`;
+    }
+    return null;
+}
+function isCurrentServerUnderNpmInstall(currentServerPackageRoot, install) {
+    const roots = install.globalRootPath
+        ? [install.packagePath, globalNodeModulesPath(install.globalRootPath)]
+        : [install.packagePath];
+    return roots.some((root) => isRealpathInsideRoot(root, currentServerPackageRoot));
+}
+function globalNodeModulesPath(globalRootPath) {
+    const normalized = path.normalize(globalRootPath);
+    return path.basename(normalized) === "node_modules"
+        ? normalized
+        : path.join(normalized, "node_modules");
+}
+function resolveCurrentServerPackageRoot() {
+    return resolvePackageRootFrom(fileURLToPath(import.meta.url), "@getpaseo/server");
+}
+function resolvePackageRootFrom(startPath, packageName) {
+    let currentDir = path.dirname(startPath);
+    while (true) {
+        const packageJsonPath = path.join(currentDir, "package.json");
+        if (existsSync(packageJsonPath)) {
+            try {
+                const packageJson = PackageJsonSchema.parse(JSON.parse(readFileSync(packageJsonPath, "utf8")));
+                if (packageJson.name === packageName) {
+                    return currentDir;
+                }
+            }
+            catch {
+                return null;
+            }
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}
+//# sourceMappingURL=install-origin.js.map

package/dist/server/server/session/daemon/npm-global-cli.d.ts

@@ -0,0 +1,29 @@
+export declare const PASEO_CLI_PACKAGE = "@getpaseo/cli";
+export interface CommandOptions {
+    timeout?: number;
+    maxBuffer?: number;
+}
+export interface CommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface NpmGlobalPaseoInstall {
+    version: string;
+    packagePath: string;
+    globalRootPath: string | null;
+    isLinked: boolean;
+}
+export interface NpmGlobalPaseoCli {
+    inspect(): Promise<NpmGlobalPaseoInstall>;
+    installLatest(): Promise<CommandResult>;
+}
+export type CommandRunner = (command: string, args: string[], options?: CommandOptions) => Promise<CommandResult>;
+export declare class DefaultNpmGlobalPaseoCli implements NpmGlobalPaseoCli {
+    private readonly runCommand;
+    constructor(runCommand?: CommandRunner);
+    inspect(): Promise<NpmGlobalPaseoInstall>;
+    installLatest(): Promise<CommandResult>;
+}
+export declare const npmGlobalPaseoCli: DefaultNpmGlobalPaseoCli;
+//# sourceMappingURL=npm-global-cli.d.ts.map

package/dist/server/server/session/daemon/npm-global-cli.js

@@ -0,0 +1,98 @@
+import { getErrorMessage } from "@getpaseo/protocol/error-utils";
+import { z } from "zod";
+import { execCommand } from "../../../utils/spawn.js";
+export const PASEO_CLI_PACKAGE = "@getpaseo/cli";
+const NPM_PROBE_TIMEOUT_MS = 10000;
+const NPM_INSTALL_TIMEOUT_MS = 300000;
+const NPM_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+const NpmGlobalListSchema = z
+    .object({
+    path: z.string().optional(),
+    dependencies: z.record(z.string(), z.unknown()).optional(),
+})
+    .passthrough();
+const NpmGlobalCliPackageSchema = z
+    .object({
+    version: z.string(),
+    path: z.string(),
+    link: z.boolean().optional(),
+})
+    .passthrough();
+const CommandErrorSchema = z
+    .object({
+    code: z.union([z.number(), z.string()]).optional(),
+    stdout: z.string().optional(),
+    stderr: z.string().optional(),
+})
+    .passthrough();
+async function runExternalCommand(command, args, options) {
+    try {
+        const { stdout, stderr } = await execCommand(command, args, {
+            timeout: options?.timeout,
+            maxBuffer: options?.maxBuffer,
+        });
+        return { exitCode: 0, stdout, stderr };
+    }
+    catch (error) {
+        const parsed = CommandErrorSchema.safeParse(error);
+        if (!parsed.success) {
+            return { exitCode: 1, stdout: "", stderr: getErrorMessage(error) };
+        }
+        return {
+            exitCode: typeof parsed.data.code === "number" ? parsed.data.code : 1,
+            stdout: parsed.data.stdout ?? "",
+            stderr: parsed.data.stderr || getErrorMessage(error),
+        };
+    }
+}
+function parseNpmGlobalPaseoInstall(stdout) {
+    let parsedJson;
+    try {
+        parsedJson = JSON.parse(stdout);
+    }
+    catch {
+        return null;
+    }
+    const list = NpmGlobalListSchema.safeParse(parsedJson);
+    if (!list.success) {
+        return null;
+    }
+    const rawCliPackage = list.data.dependencies?.[PASEO_CLI_PACKAGE];
+    const cliPackage = NpmGlobalCliPackageSchema.safeParse(rawCliPackage);
+    if (!cliPackage.success) {
+        return null;
+    }
+    return {
+        version: cliPackage.data.version,
+        packagePath: cliPackage.data.path,
+        globalRootPath: list.data.path ?? null,
+        isLinked: cliPackage.data.link === true,
+    };
+}
+export class DefaultNpmGlobalPaseoCli {
+    constructor(runCommand = runExternalCommand) {
+        this.runCommand = runCommand;
+    }
+    async inspect() {
+        const result = await this.runCommand("npm", ["-g", "ls", PASEO_CLI_PACKAGE, "--json", "--depth=0", "--long"], {
+            timeout: NPM_PROBE_TIMEOUT_MS,
+            maxBuffer: NPM_MAX_BUFFER_BYTES,
+        });
+        if (result.exitCode !== 0 && result.stdout.trim().length === 0) {
+            throw new Error(result.stderr.trim() || "npm is not available on this host");
+        }
+        const install = parseNpmGlobalPaseoInstall(result.stdout);
+        if (!install) {
+            throw new Error(`${PASEO_CLI_PACKAGE} is not installed with npm -g on this host`);
+        }
+        return install;
+    }
+    installLatest() {
+        return this.runCommand("npm", ["install", "-g", `${PASEO_CLI_PACKAGE}@latest`], {
+            timeout: NPM_INSTALL_TIMEOUT_MS,
+            maxBuffer: NPM_MAX_BUFFER_BYTES,
+        });
+    }
+}
+export const npmGlobalPaseoCli = new DefaultNpmGlobalPaseoCli();
+//# sourceMappingURL=npm-global-cli.js.map

package/dist/server/server/session/provider/provider-catalog-session.js

@@ -1,5 +1,5 @@
 import { getErrorMessage } from "@getpaseo/protocol/error-utils";
-import { resolveSnapshotCwd, } from "../../agent/provider-snapshot-manager.js";
+import { isGlobalProviderSnapshotKey, } from "../../agent/provider-snapshot-manager.js";
 import { expandTilde } from "../../../utils/path.js";
 // COMPAT(customModeIcons): the only mode icons known to clients before v0.1.84. Any
 // other icon name is downgraded to "ShieldCheck" for those clients.
@@ -28,7 +28,7 @@ export class ProviderCatalogSession {
         const handleProviderSnapshotChange = (entries, cwd) => {
             // COMPAT(providersSnapshot): keep provider visibility gating for older clients.
             const visibleEntries = entries.filter((entry) => this.host.isProviderVisibleToClient(entry.provider));
-            const snapshotCwd = cwd === resolveSnapshotCwd() ? undefined : cwd;
+            const snapshotCwd = isGlobalProviderSnapshotKey(cwd) ? undefined : cwd;
             this.host.emit({
                 type: "providers_snapshot_update",
                 payload: {
@@ -77,7 +77,7 @@ export class ProviderCatalogSession {
         }
     }
     async handleListProviderModelsRequest(msg) {
-        const cwd = resolveSnapshotCwd(msg.cwd ? expandTilde(msg.cwd) : undefined);
+        const cwd = resolveCatalogRequestCwd(msg.cwd);
         const fetchedAt = new Date().toISOString();
         const entry = await this.getProviderSnapshotEntryForRead(cwd, msg.provider);
         if (!entry) {
@@ -124,7 +124,7 @@ export class ProviderCatalogSession {
     }
     async handleListProviderModesRequest(msg) {
         const fetchedAt = new Date().toISOString();
-        const cwd = resolveSnapshotCwd(msg.cwd ? expandTilde(msg.cwd) : undefined);
+        const cwd = resolveCatalogRequestCwd(msg.cwd);
         const entry = await this.getProviderSnapshotEntryForRead(cwd, msg.provider);
         if (!entry) {
             this.host.emit({
@@ -336,4 +336,8 @@ export class ProviderCatalogSession {
         }
     }
 }
+function resolveCatalogRequestCwd(cwd) {
+    const trimmed = cwd?.trim();
+    return trimmed ? expandTilde(trimmed) : undefined;
+}
 //# sourceMappingURL=provider-catalog-session.js.map

package/dist/server/server/session.d.ts

@@ -110,11 +110,12 @@ export type SessionLifecycleIntent = {
     type: "shutdown";
     clientId: string;
     requestId: string;
+    reason: string;
 } | {
     type: "restart";
     clientId: string;
     requestId: string;
-    reason?: string;
+    reason: string;
 };
 /**
  * Session represents a single connected client session.
@@ -227,7 +228,6 @@ export declare class Session {
     private isProviderVisibleToClient;
     private buildProjectPlacementForWorkspace;
     private buildProjectPlacementForWorkspaceId;
-    private buildProjectPlacementForExistingWorkspaceProject;
     /**
      * Main entry point for processing session messages
      */
@@ -236,6 +236,7 @@ export declare class Session {
     private dispatchVoiceAndControlMessage;
     private dispatchAgentRewindMessage;
     private dispatchAgentRelationshipMessage;
+    private dispatchAgentTimelineMessage;
     private dispatchAgentLifecycleMessage;
     private dispatchAgentConfigMessage;
     private dispatchCheckoutMessage;
@@ -245,6 +246,7 @@ export declare class Session {
     private dispatchChatScheduleLoopMessage;
     private dispatchMiscMessage;
     resetPeakInflight(): void;
+    getSessionId(): string;
     handleBinaryFrame(binaryFrame: BinaryFrame): Promise<void>;
     private handleRestartServerRequest;
     private handleShutdownServerRequest;
@@ -276,7 +278,6 @@ export declare class Session {
     private scheduleAutoNameWorkspaceBranchForFirstAgent;
     private maybeAutoNameWorkspaceBranchForFirstAgent;
     private applyGeneratedWorkspaceTitle;
-    private writeInitialWorkspaceTitleIfUntitled;
     private generateWorkspaceTitleFromContext;
     private maybeAutoNameDirectoryWorkspaceTitle;
     private scheduleAutoNameLocalWorkspaceTitleForFirstAgent;
@@ -374,6 +375,7 @@ export declare class Session {
     private selectProjectedTimelineProjection;
     private selectTimelineProjection;
     private handleFetchAgentTimelineRequest;
+    private handleAgentForkContextRequest;
     private handleSendAgentMessageRequest;
     private handleWaitForFinish;
     /**

package/dist/server/server/session.js

@@ -18,11 +18,13 @@ import { createWorkspaceScriptsService, } from "./session/workspace-scripts/work
 import { getErrorMessage, getErrorMessageOr } from "@getpaseo/protocol/error-utils";
 import { getAgentStatusPriority } from "@getpaseo/protocol/agent-state-bucket";
 import { getParentAgentIdFromLabels } from "@getpaseo/protocol/agent-labels";
+import { CLIENT_SHUTDOWN_RPC_REASON, normalizeClientRestartRpcReason, } from "./lifecycle-reasons.js";
 import { createAgentCommand } from "./agent/create-agent/create.js";
 import { archiveAgentCommand, cancelAgentRunCommand, closeAgentCommand, detachAgentCommand, setAgentModeCommand, updateAgentCommand, } from "./agent/lifecycle-command.js";
 import { buildStoredAgentPayload, resolveStoredAgentPayloadUpdatedAt, toAgentPayload, } from "./agent/agent-projections.js";
 import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from "./agent/timeline-append.js";
 import { projectTimelineRows, selectProjectedTimelinePage, } from "./agent/timeline-projection.js";
+import { buildAgentForkContextAttachment } from "./agent/activity-curator.js";
 import { getAgentStreamEventTurnId, } from "./agent/agent-sdk-types.js";
 import { ImportSessionsRequestError, importProviderSession, listImportableProviderSessions, normalizeImportAgentRequest, } from "./agent/import-sessions.js";
 import { checkoutLiteFromGitSnapshot, deriveWorkspaceDisplayName, } from "./workspace-registry-model.js";
@@ -355,7 +357,9 @@ export class Session {
         this.daemonSession = new DaemonSession({
             host: {
                 emit: (msg) => this.emit(msg),
+                emitLifecycleIntent: (intent) => this.emitLifecycleIntent(intent),
             },
+            clientId: this.clientId,
             paseoHome: this.paseoHome,
             serverId,
             daemonVersion,
@@ -746,12 +750,6 @@ export class Session {
         };
     }
     async buildProjectPlacementForWorkspaceId(workspaceId) {
-        const workspace = await this.workspaceRegistry.get(workspaceId);
-        if (!workspace)
-            return null;
-        return this.buildProjectPlacementForWorkspace(workspace);
-    }
-    async buildProjectPlacementForExistingWorkspaceProject(workspaceId) {
         const workspace = await this.workspaceRegistry.get(workspaceId);
         if (!workspace)
             return null;
@@ -815,6 +813,7 @@ export class Session {
         const promise = this.dispatchVoiceAndControlMessage(msg) ??
             this.dispatchAgentRewindMessage(msg) ??
             this.dispatchAgentRelationshipMessage(msg) ??
+            this.dispatchAgentTimelineMessage(msg) ??
             this.dispatchAgentLifecycleMessage(msg) ??
             this.dispatchAgentConfigMessage(msg) ??
             this.dispatchCheckoutMessage(msg) ??
@@ -891,6 +890,16 @@ export class Session {
                 return undefined;
         }
     }
+    dispatchAgentTimelineMessage(msg) {
+        switch (msg.type) {
+            case "fetch_agent_timeline_request":
+                return this.handleFetchAgentTimelineRequest(msg);
+            case "agent.fork_context.request":
+                return this.handleAgentForkContextRequest(msg);
+            default:
+                return undefined;
+        }
+    }
     dispatchAgentLifecycleMessage(msg) {
         switch (msg.type) {
             case "fetch_agents_request":
@@ -925,8 +934,6 @@ export class Session {
                 return this.handleRefreshAgentRequest(msg);
             case "cancel_agent_request":
                 return this.handleCancelAgentRequest(msg.agentId, msg.requestId);
-            case "fetch_agent_timeline_request":
-                return this.handleFetchAgentTimelineRequest(msg);
             case "agent_permission_response":
                 return this.handleAgentPermissionResponse(msg.agentId, msg.requestId, msg.response);
             case "clear_agent_attention":
@@ -957,6 +964,8 @@ export class Session {
                 return this.daemonSession.handleGetPairingOfferRequest(msg);
             case "diagnostics.request":
                 return this.daemonSession.handleDiagnosticsRequest(msg);
+            case "daemon.update.request":
+                return this.daemonSession.handleUpdateRequest(msg);
             case "set_daemon_config_request":
                 this.emit({
                     type: "set_daemon_config_response",
@@ -1164,6 +1173,9 @@ export class Session {
     resetPeakInflight() {
         this.peakInflightRequests = this.inflightRequests;
     }
+    getSessionId() {
+        return this.sessionId;
+    }
     async handleBinaryFrame(binaryFrame) {
         if (binaryFrame.kind === "file_transfer") {
             await this.workspaceFilesSession.handleFileTransferFrame(binaryFrame.frame);
@@ -1172,6 +1184,7 @@ export class Session {
         this.terminalController.handleBinaryFrame(binaryFrame.frame);
     }
     async handleRestartServerRequest(requestId, reason) {
+        const lifecycleReason = normalizeClientRestartRpcReason(reason);
         const payload = {
             status: "restart_requested",
             clientId: this.clientId,
@@ -1180,7 +1193,7 @@ export class Session {
             payload.reason = reason;
         }
         payload.requestId = requestId;
-        this.sessionLogger.warn({ reason }, "Restart requested via websocket");
+        this.sessionLogger.warn({ reason: lifecycleReason }, "Restart requested via websocket");
         this.emit({
             type: "status",
             payload,
@@ -1189,11 +1202,12 @@ export class Session {
             type: "restart",
             clientId: this.clientId,
             requestId,
-            ...(reason ? { reason } : {}),
+            reason: lifecycleReason,
         });
     }
     async handleShutdownServerRequest(requestId) {
-        this.sessionLogger.warn("Shutdown requested via websocket");
+        const reason = CLIENT_SHUTDOWN_RPC_REASON;
+        this.sessionLogger.warn({ reason }, "Shutdown requested via websocket");
         this.emit({
             type: "status",
             payload: {
@@ -1206,6 +1220,7 @@ export class Session {
             type: "shutdown",
             clientId: this.clientId,
             requestId,
+            reason,
         });
     }
     emitLifecycleIntent(intent) {
@@ -1691,6 +1706,7 @@ export class Session {
                 cwd: createAgentConfig.cwd,
                 initialTitle: workspacePromptTitle,
             });
+            const createdDirectoryWorkspaceForAgent = !createdWorktree && !msg.workspaceId;
             const { snapshot, liveSnapshot } = await createAgentCommand({
                 agentManager: this.agentManager,
                 agentStorage: this.agentStorage,
@@ -1716,11 +1732,8 @@ export class Session {
                 buildSessionConfig: (sessionConfig, gitOptions, legacyWorktreeName, ctx) => this.buildAgentSessionConfig(sessionConfig, gitOptions, legacyWorktreeName, ctx),
             });
             createdAgentId = snapshot.id;
-            if (!createdWorktree && msg.workspaceId) {
-                await this.writeInitialWorkspaceTitleIfUntitled(workspaceId, workspacePromptTitle);
-            }
             await this.agentUpdates.forwardLiveAgent(snapshot);
-            if (!createdWorktree && trimmedPrompt) {
+            if (createdDirectoryWorkspaceForAgent && trimmedPrompt) {
                 await this.scheduleAutoNameLocalWorkspaceTitleForFirstAgent({
                     workspaceId,
                     cwd: createAgentConfig.cwd,
@@ -2118,20 +2131,6 @@ export class Session {
             updatedAt: new Date().toISOString(),
         });
     }
-    async writeInitialWorkspaceTitleIfUntitled(workspaceId, title) {
-        if (!title) {
-            return;
-        }
-        const current = await this.workspaceRegistry.get(workspaceId);
-        if (!current || current.title) {
-            return;
-        }
-        await this.workspaceRegistry.upsert({
-            ...current,
-            title,
-            updatedAt: new Date().toISOString(),
-        });
-    }
     // Wraps the injected workspace-name generator for a directory workspace.
     async generateWorkspaceTitleFromContext(input) {
         return this.generateWorkspaceName({
@@ -2624,9 +2623,7 @@ export class Session {
             if (existing) {
                 return existing;
             }
-            const placementPromise = request.type === "fetch_agent_history_request"
-                ? this.buildProjectPlacementForExistingWorkspaceProject(workspaceId)
-                : this.buildProjectPlacementForWorkspaceId(workspaceId);
+            const placementPromise = this.buildProjectPlacementForWorkspaceId(workspaceId);
             placementByWorkspaceId.set(workspaceId, placementPromise);
             return placementPromise;
         };
@@ -4038,6 +4035,51 @@ export class Session {
             });
         }
     }
+    async handleAgentForkContextRequest(msg) {
+        try {
+            const snapshot = await ensureAgentLoaded(msg.agentId, {
+                agentManager: this.agentManager,
+                agentStorage: this.agentStorage,
+                logger: this.sessionLogger,
+            });
+            const agentPayload = await this.buildAgentPayload(snapshot);
+            const rows = this.agentManager.fetchTimeline(msg.agentId, {
+                direction: "tail",
+                limit: 0,
+            }).rows;
+            const forkContext = buildAgentForkContextAttachment({
+                rows,
+                boundaryMessageId: msg.boundaryMessageId,
+                agentTitle: agentPayload.title,
+                cwd: snapshot.cwd,
+            });
+            this.emit({
+                type: "agent.fork_context.response",
+                payload: {
+                    requestId: msg.requestId,
+                    agentId: msg.agentId,
+                    attachment: forkContext.attachment,
+                    itemCount: forkContext.itemCount,
+                    boundaryMessageId: forkContext.boundaryMessageId,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error, agentId: msg.agentId }, "Failed to handle agent.fork_context.request");
+            this.emit({
+                type: "agent.fork_context.response",
+                payload: {
+                    requestId: msg.requestId,
+                    agentId: msg.agentId,
+                    attachment: null,
+                    itemCount: 0,
+                    boundaryMessageId: msg.boundaryMessageId ?? null,
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
     async handleSendAgentMessageRequest(msg) {
         const resolved = await this.resolveAgentIdentifier(msg.agentId);
         if (!resolved.ok) {

package/dist/server/server/web-ui.d.ts

@@ -0,0 +1,10 @@
+import type { RequestHandler } from "express";
+import type { Logger } from "pino";
+export interface WebUiMiddlewareOptions {
+    enabled: boolean;
+    distDir: string | null;
+    label: string;
+    logger: Logger;
+}
+export declare function createWebUiMiddleware(options: WebUiMiddlewareOptions): RequestHandler;
+//# sourceMappingURL=web-ui.d.ts.map