@getpaseo/server 0.1.104-beta.2 → 0.1.104-beta.3

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

@@ -331,6 +331,20 @@ export function createPaseoToolCatalog(options) {
         }
         return options.ensureWorkspaceForCreate(resolvedCwd);
     }
+    function resolveWorkspaceIdForRename(requestedWorkspaceId) {
+        const explicitWorkspaceId = requestedWorkspaceId?.trim();
+        if (explicitWorkspaceId) {
+            return explicitWorkspaceId;
+        }
+        if (callerAgentId) {
+            const callerAgent = resolveCallerAgent();
+            if (!callerAgent?.workspaceId) {
+                throw new Error(`Caller agent ${callerAgentId} has no current workspace`);
+            }
+            return callerAgent.workspaceId;
+        }
+        throw new Error("workspaceId is required outside an agent-scoped session");
+    }
     const buildCallerAgentScheduleConfigExtras = (callerAgent) => {
         return {
             ...(callerAgent.config.thinkingOptionId
@@ -856,7 +870,9 @@ export function createPaseoToolCatalog(options) {
     async function resolveCreateAgentToolArgs(args) {
         if (callerAgentId) {
             const parsed = agentToAgentCreateAgentArgsSchema.parse(args);
-            const { cwd, workspaceId, worktree } = await resolveCreateAgentWorkspace(parsed.workspace);
+            const { cwd, workspaceId, worktree } = await resolveCreateAgentWorkspace(parsed.workspace, {
+                prompt: parsed.initialPrompt,
+            });
             return {
                 kind: "agent-scoped",
                 parsedArgs: parsed,
@@ -870,7 +886,9 @@ export function createPaseoToolCatalog(options) {
         if (parsedArgs.relationship.kind === "subagent") {
             throw new Error("relationship subagent requires an agent-scoped tool session");
         }
-        const { cwd, workspaceId, worktree } = await resolveCreateAgentWorkspace(parsedArgs.workspace);
+        const { cwd, workspaceId, worktree } = await resolveCreateAgentWorkspace(parsedArgs.workspace, {
+            prompt: parsedArgs.initialPrompt,
+        });
         return {
             kind: "top-level",
             parsedArgs,
@@ -952,7 +970,7 @@ export function createPaseoToolCatalog(options) {
         }
         return null;
     }
-    async function resolveCreateAgentWorkspace(workspace) {
+    async function resolveCreateAgentWorkspace(workspace, firstAgentContext) {
         if (workspace.kind === "current") {
             if (!callerAgentId) {
                 throw new Error("workspace current requires an agent-scoped tool session");
@@ -995,7 +1013,7 @@ export function createPaseoToolCatalog(options) {
             }
             return {
                 cwd,
-                workspaceId: await options.ensureWorkspaceForCreate(cwd),
+                workspaceId: await options.ensureWorkspaceForCreate(cwd, firstAgentContext),
                 worktree: undefined,
             };
         }
@@ -1339,6 +1357,57 @@ export function createPaseoToolCatalog(options) {
             structuredContent: ensureValidJson({ success: true }),
         };
     });
+    registerTool("rename_workspace", {
+        title: "Rename workspace",
+        description: "Rename a workspace by setting its user-visible title. Omit workspaceId to rename your current workspace.",
+        inputSchema: {
+            workspaceId: z
+                .string()
+                .trim()
+                .min(1)
+                .optional()
+                .describe("Workspace id to rename. Omit to rename your current workspace."),
+            title: z
+                .string()
+                .trim()
+                .min(1, "title is required")
+                .describe("New user-visible workspace title."),
+        },
+        outputSchema: {
+            success: z.boolean(),
+            workspaceId: z.string(),
+            title: z.string(),
+        },
+    }, async ({ workspaceId: requestedWorkspaceId, title }) => {
+        if (!options.workspaceRegistry) {
+            throw new Error("Workspace registry is required to rename workspaces");
+        }
+        if (!options.emitWorkspaceUpdatesForWorkspaceIds) {
+            throw new Error("Workspace update emitter is required to rename workspaces");
+        }
+        const workspaceId = resolveWorkspaceIdForRename(requestedWorkspaceId);
+        const existing = await options.workspaceRegistry.get(workspaceId);
+        if (!existing) {
+            throw new Error(`Workspace ${workspaceId} not found`);
+        }
+        if (existing.archivedAt) {
+            throw new Error(`Workspace ${workspaceId} is archived`);
+        }
+        await options.workspaceRegistry.upsert({
+            ...existing,
+            title,
+            updatedAt: new Date().toISOString(),
+        });
+        await options.emitWorkspaceUpdatesForWorkspaceIds([workspaceId]);
+        return {
+            content: [],
+            structuredContent: ensureValidJson({
+                success: true,
+                workspaceId,
+                title,
+            }),
+        };
+    });
     registerTool("list_terminals", {
         title: "List terminals",
         description: "List terminals for a working directory or across all working directories.",

package/dist/server/server/bootstrap.js

@@ -116,6 +116,10 @@ import { terminateWithTreeKill } from "../utils/tree-kill.js";
 import { isHostnameAllowed } from "./hostnames.js";
 import { createRequireBearerMiddleware, isAgentMcpRequestAuthorized, } from "./auth.js";
 import { createWebUiMiddleware } from "./web-ui.js";
+import { WorkspaceAutoName } from "./workspace-auto-name.js";
+import { createGitMutationService } from "./session/git-mutation/git-mutation-service.js";
+import { workspaceIdsOnCheckout } from "./workspace-directory.js";
+import { resolveFirstAgentPromptTitle } from "./agent/create-agent-title.js";
 const MAX_MCP_DEBUG_BATCH_ITEMS = 10;
 const REDACTED_LOG_VALUE = "[redacted]";
 const DOWNLOAD_OPEN_FLAGS = process.platform === "win32" ? constants.O_RDONLY : constants.O_RDONLY | constants.O_NOFOLLOW;
@@ -596,8 +600,15 @@ export async function createPaseoDaemon(config, rootLogger) {
     const findWorkspaceIdForCwdExternal = async (cwd) => {
         return resolveWorkspaceIdForPath(cwd, await workspaceRegistry.list());
     };
-    const ensureWorkspaceForCreateExternal = async (cwd) => {
-        const workspace = await createLocalCheckoutWorkspace({ cwd }, { projectRegistry, workspaceRegistry, workspaceGitService });
+    const ensureWorkspaceForCreateExternal = async (cwd, firstAgentContext) => {
+        const workspace = await createLocalCheckoutWorkspace({ cwd, title: resolveFirstAgentPromptTitle(firstAgentContext) }, { projectRegistry, workspaceRegistry, workspaceGitService });
+        if (firstAgentContext) {
+            workspaceAutoName.scheduleForDirectory({
+                workspaceId: workspace.workspaceId,
+                cwd: workspace.cwd,
+                firstAgentContext,
+            });
+        }
         return workspace.workspaceId;
     };
     const listActiveWorkspacesExternal = async () => {
@@ -626,9 +637,30 @@ export async function createPaseoDaemon(config, rootLogger) {
         const workspaceIdList = Array.from(workspaceIds);
         await Promise.all((wsServer?.listActiveSessions() ?? []).map((session) => session.emitWorkspaceUpdatesForExternalWorkspaceIds(workspaceIdList)));
     };
+    const emitWorkspaceUpdateForCwdExternal = async (cwd) => {
+        const workspaceIds = workspaceIdsOnCheckout(await workspaceRegistry.list(), cwd);
+        await emitWorkspaceUpdatesExternal(workspaceIds);
+    };
     const emitExternalSessionMessage = (message) => {
         wsServer?.broadcast(wrapSessionMessage(message));
     };
+    const workspaceAutoName = new WorkspaceAutoName({
+        agentManager,
+        workspaceRegistry,
+        workspaceGitService,
+        providerSnapshotManager,
+        readDaemonConfig: () => ({ metadataGeneration: daemonConfigStore.get().metadataGeneration }),
+        gitMutation: createGitMutationService({
+            workspaceGitService,
+            github,
+            logger,
+        }),
+        emitWorkspaceUpdateForCwd: emitWorkspaceUpdateForCwdExternal,
+        emitWorkspaceUpdateForWorkspaceId: async (workspaceId) => {
+            await emitWorkspaceUpdatesExternal([workspaceId]);
+        },
+        logger,
+    });
     setupAutoArchiveOnMerge({
         paseoHome: config.paseoHome,
         paseoWorktreesBaseRoot: config.worktreesRoot,
@@ -668,6 +700,7 @@ export async function createPaseoDaemon(config, rootLogger) {
                     ?.listActiveSessions()
                     .map((session) => session.warmWorkspaceGitDataForWorkspace(workspace)) ?? []);
             },
+            autoNameWorkspaceBranchForFirstAgent: (autoNameInput) => workspaceAutoName.scheduleForWorktree(autoNameInput),
             emitWorkspaceUpdateForWorkspaceId: async (workspaceId) => {
                 await emitWorkspaceUpdatesExternal([workspaceId]);
             },
@@ -697,6 +730,7 @@ export async function createPaseoDaemon(config, rootLogger) {
         listActiveWorkspaces: listActiveWorkspacesExternal,
         archiveWorkspaceRecord: archiveWorkspaceRecordExternal,
         emitWorkspaceUpdatesForWorkspaceIds: emitWorkspaceUpdatesExternal,
+        workspaceRegistry,
         markWorkspaceArchiving: markWorkspaceArchivingExternal,
         clearWorkspaceArchiving: clearWorkspaceArchivingExternal,
         ensureWorkspaceForCreate: ensureWorkspaceForCreateExternal,
@@ -883,7 +917,7 @@ export async function createPaseoDaemon(config, rootLogger) {
                         if (config.auth?.password) {
                             logger.info("Daemon password authentication enabled");
                         }
-                        wsServer = new VoiceAssistantWebSocketServer(httpServer, logger, serverId, agentManager, agentStorage, downloadTokenStore, config.paseoHome, daemonConfigStore, mcpBaseUrl, { allowedOrigins, hostnames: configuredHostnames }, config.auth, speechService, terminalManager, {
+                        wsServer = new VoiceAssistantWebSocketServer(httpServer, logger, serverId, agentManager, agentStorage, downloadTokenStore, config.paseoHome, daemonConfigStore, mcpBaseUrl, { allowedOrigins, hostnames: configuredHostnames }, workspaceAutoName, config.auth, speechService, terminalManager, {
                             finalTimeoutMs: config.dictationFinalTimeoutMs,
                         }, daemonVersion, (intent) => {
                             try {

package/dist/server/server/browser-tools/broker.d.ts

@@ -1,8 +1,10 @@
-import { type BrowserAutomationCommand, type BrowserAutomationExecuteRequest, type BrowserAutomationExecuteResponse } from "@getpaseo/protocol/browser-automation/rpc-schemas";
+import { type BrowserAutomationCommand, type BrowserAutomationCommandName, type BrowserAutomationExecuteRequest, type BrowserAutomationExecuteResponse } from "@getpaseo/protocol/browser-automation/rpc-schemas";
 import { type BrowserToolsResponsePayload } from "./errors.js";
 import type { BrowserToolsPolicy } from "./policy.js";
-export interface BrowserToolsDesktopClient {
+export interface BrowserHostClient {
     id: string;
+    hostKind: string;
+    supportedCommands: readonly BrowserAutomationCommandName[];
     sendBrowserAutomationRequest(request: BrowserAutomationExecuteRequest): void | Promise<void>;
 }
 export interface BrowserToolsExecuteInput {
@@ -24,14 +26,23 @@ export declare class BrowserToolsBroker {
     private readonly createRequestId;
     private readonly clients;
     private readonly pending;
+    private readonly browserHostByBrowserId;
+    private readonly strandedBrowserHostByBrowserId;
+    private registrationSequence;
     constructor(options: BrowserToolsBrokerOptions);
-    registerClient(client: BrowserToolsDesktopClient): () => void;
-    unregisterClient(clientId: string): void;
+    registerClient(client: BrowserHostClient): () => void;
+    unregisterClient(clientId: string, registeredAt?: number): void;
     getPendingRequestCount(): number;
     getRegisteredClientCount(): number;
     execute(input: BrowserToolsExecuteInput): Promise<BrowserToolsResponsePayload>;
     receiveResponse(response: BrowserAutomationExecuteResponse): boolean;
-    private selectClient;
+    private executeListTabs;
+    private selectHostForCommand;
+    private selectMostRecentlyRegisteredHost;
+    private unsupportedCommandFailure;
+    private noBrowserHostFailure;
+    private strandedBrowserTabFailure;
+    private rememberBrowserHostForPayload;
     private sendRequest;
 }
 //# sourceMappingURL=broker.d.ts.map

package/dist/server/server/browser-tools/broker.js

@@ -6,19 +6,36 @@ export class BrowserToolsBroker {
     constructor(options) {
         this.clients = new Map();
         this.pending = new Map();
+        this.browserHostByBrowserId = new Map();
+        this.strandedBrowserHostByBrowserId = new Map();
+        this.registrationSequence = 0;
         this.policy = options.policy;
         this.defaultTimeoutMs = options.defaultTimeoutMs ?? DEFAULT_BROWSER_TOOLS_TIMEOUT_MS;
         this.createRequestId = options.createRequestId ?? (() => `browser_${randomUUID()}`);
     }
     registerClient(client) {
-        this.clients.set(client.id, client);
-        return () => this.unregisterClient(client.id);
+        this.unregisterClient(client.id);
+        const registeredAt = ++this.registrationSequence;
+        this.clients.set(client.id, {
+            client,
+            registeredAt,
+            supportedCommands: new Set(client.supportedCommands),
+        });
+        return () => this.unregisterClient(client.id, registeredAt);
     }
-    unregisterClient(clientId) {
-        const deleted = this.clients.delete(clientId);
-        if (!deleted) {
+    unregisterClient(clientId, registeredAt) {
+        const current = this.clients.get(clientId);
+        if (!current || (registeredAt !== undefined && current.registeredAt !== registeredAt)) {
             return;
         }
+        this.clients.delete(clientId);
+        for (const [browserId, ownerClientId] of this.browserHostByBrowserId) {
+            if (ownerClientId !== clientId) {
+                continue;
+            }
+            this.browserHostByBrowserId.delete(browserId);
+            this.strandedBrowserHostByBrowserId.set(browserId, clientId);
+        }
         for (const [requestId, pending] of this.pending) {
             if (pending.clientId !== clientId) {
                 continue;
@@ -27,8 +44,8 @@ export class BrowserToolsBroker {
             clearTimeout(pending.timeout);
             pending.resolve(browserToolsFailure({
                 requestId,
-                code: "browser_no_desktop",
-                message: "The desktop browser automation client disconnected before responding.",
+                code: "browser_no_host",
+                message: "The browser automation host disconnected before responding.",
                 retryable: true,
             }));
         }
@@ -48,15 +65,6 @@ export class BrowserToolsBroker {
                 message: "Browser tools are disabled. Enable daemon.browserTools.enabled to use them.",
             });
         }
-        const client = this.selectClient();
-        if (!client) {
-            return browserToolsFailure({
-                requestId,
-                code: "browser_no_desktop",
-                message: "No desktop browser automation client is connected.",
-                retryable: true,
-            });
-        }
         const request = BrowserAutomationExecuteRequestSchema.safeParse({
             type: "browser.automation.execute.request",
             requestId,
@@ -72,8 +80,26 @@ export class BrowserToolsBroker {
                 message: formatBrowserAutomationValidationError(request.error.issues[0]?.message),
             });
         }
+        if (request.data.command.command === "list_tabs") {
+            return this.executeListTabs({
+                request: request.data,
+                timeoutMs: input.timeoutMs ?? this.defaultTimeoutMs,
+            });
+        }
+        const host = this.selectHostForCommand(request.data.command, requestId);
+        if (!host.ok) {
+            return host.payload;
+        }
+        const unsupported = this.unsupportedCommandFailure({
+            host: host.value,
+            commandName: request.data.command.command,
+            requestId,
+        });
+        if (unsupported) {
+            return unsupported;
+        }
         return this.sendRequest({
-            client,
+            host: host.value,
             request: request.data,
             timeoutMs: input.timeoutMs ?? this.defaultTimeoutMs,
         });
@@ -104,17 +130,175 @@ export class BrowserToolsBroker {
         }
         this.pending.delete(parsed.data.payload.requestId);
         clearTimeout(pending.timeout);
+        if (pending.rememberAffinity) {
+            this.rememberBrowserHostForPayload(pending.clientId, parsed.data.payload);
+        }
         pending.resolve(parsed.data.payload);
         return true;
     }
-    selectClient() {
-        for (const client of this.clients.values()) {
-            return client;
+    async executeListTabs(params) {
+        const hosts = Array.from(this.clients.values());
+        if (hosts.length === 0) {
+            return this.noBrowserHostFailure(params.request.requestId);
+        }
+        for (const host of hosts) {
+            const unsupported = this.unsupportedCommandFailure({
+                host,
+                commandName: "list_tabs",
+                requestId: params.request.requestId,
+            });
+            if (unsupported) {
+                return unsupported;
+            }
+        }
+        if (hosts.length === 1) {
+            return this.sendRequest({
+                host: hosts[0],
+                request: params.request,
+                timeoutMs: params.timeoutMs,
+            });
+        }
+        const hostResponses = await Promise.all(hosts.map(async (host) => ({
+            host,
+            payload: await this.sendRequest({
+                host,
+                request: {
+                    ...params.request,
+                    requestId: `${params.request.requestId}:${host.client.id}`,
+                },
+                rememberAffinity: false,
+                timeoutMs: params.timeoutMs,
+            }),
+        })));
+        const failed = hostResponses.find(({ payload }) => !payload.ok);
+        if (failed) {
+            return withBrowserToolsRequestId(failed.payload, params.request.requestId);
+        }
+        for (const { host, payload } of hostResponses) {
+            this.rememberBrowserHostForPayload(host.client.id, payload);
+        }
+        return {
+            requestId: params.request.requestId,
+            ok: true,
+            result: {
+                command: "list_tabs",
+                tabs: hostResponses.flatMap(({ payload }) => payload.ok && payload.result.command === "list_tabs" ? payload.result.tabs : []),
+            },
+        };
+    }
+    selectHostForCommand(command, requestId) {
+        if (command.command === "new_tab") {
+            const host = this.selectMostRecentlyRegisteredHost();
+            return host
+                ? { ok: true, value: host }
+                : { ok: false, payload: this.noBrowserHostFailure(requestId) };
+        }
+        const browserId = getBrowserIdForCommand(command);
+        if (!browserId) {
+            const host = this.selectMostRecentlyRegisteredHost();
+            return host
+                ? { ok: true, value: host }
+                : { ok: false, payload: this.noBrowserHostFailure(requestId) };
+        }
+        const ownerClientId = this.browserHostByBrowserId.get(browserId);
+        if (ownerClientId) {
+            const host = this.clients.get(ownerClientId);
+            if (host) {
+                return { ok: true, value: host };
+            }
+            return {
+                ok: false,
+                payload: this.strandedBrowserTabFailure({ requestId, browserId }),
+            };
+        }
+        const strandedOwnerClientId = this.strandedBrowserHostByBrowserId.get(browserId);
+        if (strandedOwnerClientId) {
+            const reconnectedHost = this.clients.get(strandedOwnerClientId);
+            if (reconnectedHost) {
+                this.strandedBrowserHostByBrowserId.delete(browserId);
+                this.browserHostByBrowserId.set(browserId, strandedOwnerClientId);
+                return { ok: true, value: reconnectedHost };
+            }
+            return {
+                ok: false,
+                payload: this.strandedBrowserTabFailure({ requestId, browserId }),
+            };
+        }
+        if (this.clients.size === 1) {
+            const host = this.selectMostRecentlyRegisteredHost();
+            if (host) {
+                return { ok: true, value: host };
+            }
+        }
+        if (this.clients.size === 0) {
+            return { ok: false, payload: this.noBrowserHostFailure(requestId) };
+        }
+        return {
+            ok: false,
+            payload: browserToolsFailure({
+                requestId,
+                code: "browser_tab_not_found",
+                message: `Browser tab ${browserId} is not associated with a connected browser automation host. Call browser_list_tabs and use one of the returned browserId values.`,
+            }),
+        };
+    }
+    selectMostRecentlyRegisteredHost() {
+        let selected = null;
+        for (const host of this.clients.values()) {
+            selected = host;
+        }
+        return selected;
+    }
+    unsupportedCommandFailure(params) {
+        if (params.host.supportedCommands.has(params.commandName)) {
+            return null;
+        }
+        return browserToolsFailure({
+            requestId: params.requestId,
+            code: "browser_unsupported",
+            message: `Browser automation command "${params.commandName}" is not supported by the ${describeBrowserHost(params.host)}.`,
+        });
+    }
+    noBrowserHostFailure(requestId) {
+        return browserToolsFailure({
+            requestId,
+            code: "browser_no_host",
+            message: "No browser automation host is connected.",
+            retryable: true,
+        });
+    }
+    strandedBrowserTabFailure(params) {
+        return browserToolsFailure({
+            requestId: params.requestId,
+            code: "browser_no_host",
+            message: `The app hosting browser tab ${params.browserId} disconnected.`,
+            retryable: true,
+        });
+    }
+    rememberBrowserHostForPayload(clientId, payload) {
+        if (!payload.ok) {
+            return;
+        }
+        if (payload.result.command === "list_tabs") {
+            for (const tab of payload.result.tabs) {
+                this.browserHostByBrowserId.set(tab.browserId, clientId);
+                this.strandedBrowserHostByBrowserId.delete(tab.browserId);
+            }
+            return;
+        }
+        if (payload.result.command === "close_tab") {
+            this.browserHostByBrowserId.delete(payload.result.browserId);
+            this.strandedBrowserHostByBrowserId.delete(payload.result.browserId);
+            return;
+        }
+        if ("browserId" in payload.result) {
+            this.browserHostByBrowserId.set(payload.result.browserId, clientId);
+            this.strandedBrowserHostByBrowserId.delete(payload.result.browserId);
         }
-        return null;
     }
     sendRequest(params) {
-        const { client, request, timeoutMs } = params;
+        const { host, request, timeoutMs } = params;
+        const client = host.client;
         return new Promise((resolve) => {
             const timeout = setTimeout(() => {
                 if (!this.pending.delete(request.requestId)) {
@@ -129,6 +313,7 @@ export class BrowserToolsBroker {
             }, timeoutMs);
             this.pending.set(request.requestId, {
                 clientId: client.id,
+                rememberAffinity: params.rememberAffinity ?? true,
                 timeout,
                 resolve,
             });
@@ -155,6 +340,19 @@ export class BrowserToolsBroker {
         });
     }
 }
+function getBrowserIdForCommand(command) {
+    if (command.command === "list_tabs" || command.command === "new_tab") {
+        return null;
+    }
+    return command.args.browserId;
+}
+function describeBrowserHost(host) {
+    const hostKind = host.client.hostKind.trim();
+    return hostKind || "browser host";
+}
+function withBrowserToolsRequestId(payload, requestId) {
+    return { ...payload, requestId };
+}
 function resolveSendFailure(params) {
     if (!params.pending.delete(params.requestId)) {
         return;