@getpaseo/server 0.1.82 → 0.1.84

package/dist/server/server/websocket-server.js

@@ -1,18 +1,15 @@
 import { WebSocketServer } from "ws";
 import { basename, join } from "path";
 import { hostname as getHostname } from "node:os";
-import { applyMutableProviderConfigToOverrides } from "./daemon-config-store.js";
 import { WSInboundMessageSchema, wrapSessionMessage, } from "./messages.js";
-import { asUint8Array, decodeTerminalStreamFrame } from "../shared/binary-frames/index.js";
+import { asUint8Array, decodeTerminalStreamFrame } from "@getpaseo/protocol/binary-frames/index";
 import { isHostnameAllowed } from "./hostnames.js";
 import { Session } from "./session.js";
-import { ProviderSnapshotManager } from "./agent/provider-snapshot-manager.js";
-import { buildProviderRegistry, createClientsFromRegistry } from "./agent/provider-registry.js";
 import { buildWorkspaceGitMetadataFromSnapshot } from "./workspace-git-metadata.js";
 import { PushTokenStore } from "./push/token-store.js";
 import { createPushNotificationSender } from "./push/notifications.js";
 import { computeNotificationPlan } from "./agent-attention-policy.js";
-import { buildAgentAttentionNotificationPayload, findLatestPermissionRequest, } from "../shared/agent-attention-notification.js";
+import { buildAgentAttentionNotificationPayload, findLatestPermissionRequest, } from "@getpaseo/protocol/agent-attention-notification";
 import { createGitHubService } from "../services/github-service.js";
 import { extractWsBearerProtocol, extractWsBearerToken, isBearerTokenValid, } from "./auth.js";
 import { WebSocketRuntimeMetricsWindow, } from "./websocket/runtime-metrics.js";
@@ -205,7 +202,7 @@ function requireWebSocketServices(params) {
  * WebSocket server that only accepts sockets + parses/forwards messages to the session layer.
  */
 export class VoiceAssistantWebSocketServer {
-    constructor(server, logger, serverId, agentManager, agentStorage, downloadTokenStore, paseoHome, daemonConfigStore, mcpBaseUrl, wsConfig, auth, speech, terminalManager, dictation, agentProviderRuntimeSettings, providerOverrides, isDev, daemonVersion, onLifecycleIntent, projectRegistry, workspaceRegistry, chatService, loopService, scheduleService, checkoutDiffManager, scriptRouteStore, scriptRuntimeStore, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, resolveScriptHealth, workspaceGitService, github, pushNotificationSender, daemonRuntimeConfig) {
+    constructor(server, logger, serverId, agentManager, agentStorage, downloadTokenStore, paseoHome, daemonConfigStore, mcpBaseUrl, wsConfig, auth, speech, terminalManager, dictation, daemonVersion, onLifecycleIntent, projectRegistry, workspaceRegistry, chatService, loopService, scheduleService, checkoutDiffManager, scriptRouteStore, scriptRuntimeStore, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, resolveScriptHealth, workspaceGitService, github, pushNotificationSender, providerSnapshotManager, daemonRuntimeConfig) {
         this.pendingConnections = new Map();
         this.sessions = new Map();
         this.externalSessionsByKey = new Map();
@@ -247,9 +244,6 @@ export class VoiceAssistantWebSocketServer {
             speech,
             terminalManager,
             dictation,
-            agentProviderRuntimeSettings,
-            providerOverrides,
-            isDev,
             onLifecycleIntent,
             scriptRouteStore,
             scriptRuntimeStore,
@@ -258,12 +252,10 @@ export class VoiceAssistantWebSocketServer {
             getDaemonTcpHost,
             resolveScriptHealth,
         });
-        const providerSnapshotLogger = this.logger.child({ module: "provider-snapshot-manager" });
-        this.providerSnapshotManager = new ProviderSnapshotManager(buildProviderRegistry(providerSnapshotLogger, {
-            runtimeSettings: this.agentProviderRuntimeSettings,
-            providerOverrides: this.providerOverrides,
-            isDev: this.isDev,
-        }), providerSnapshotLogger);
+        if (!providerSnapshotManager) {
+            throw new Error("providerSnapshotManager is required");
+        }
+        this.providerSnapshotManager = providerSnapshotManager;
         this.serverCapabilities = buildServerCapabilities({
             readiness: this.speech?.getReadiness() ?? null,
         });
@@ -272,15 +264,8 @@ export class VoiceAssistantWebSocketServer {
                 this.publishSpeechReadiness(snapshot);
             }) ?? null;
         this.unsubscribeDaemonConfigChange = this.daemonConfigStore.onChange((config) => {
-            this.providerOverrides = applyMutableProviderConfigToOverrides(this.providerOverrides, config.providers);
-            const registry = buildProviderRegistry(providerSnapshotLogger, {
-                runtimeSettings: this.agentProviderRuntimeSettings,
-                providerOverrides: this.providerOverrides,
-                isDev: this.isDev,
-            });
-            const clients = createClientsFromRegistry(registry, providerSnapshotLogger);
-            this.providerSnapshotManager.replaceRegistry(registry);
-            this.agentManager.updateProviderRegistry({ providerDefinitions: registry, clients });
+            const nextAgentManagerState = this.providerSnapshotManager.applyMutableProviderConfig(config.providers);
+            this.agentManager.updateProviderRegistry(nextAgentManagerState);
             this.broadcastDaemonConfigChanged(config);
         });
         const pushLogger = this.logger.child({ module: "push" });
@@ -300,9 +285,6 @@ export class VoiceAssistantWebSocketServer {
         this.speech = params.speech ?? null;
         this.terminalManager = params.terminalManager ?? null;
         this.dictation = params.dictation ?? null;
-        this.agentProviderRuntimeSettings = params.agentProviderRuntimeSettings;
-        this.providerOverrides = params.providerOverrides;
-        this.isDev = params.isDev === true;
         this.onLifecycleIntent = params.onLifecycleIntent ?? null;
         this.scriptRouteStore = params.scriptRouteStore ?? null;
         this.scriptRuntimeStore = params.scriptRuntimeStore ?? null;
@@ -617,9 +599,6 @@ export class VoiceAssistantWebSocketServer {
                     getSpeechReadiness: () => this.speech.getReadiness(),
                 }
                 : undefined,
-            agentProviderRuntimeSettings: this.agentProviderRuntimeSettings,
-            providerOverrides: this.providerOverrides,
-            isDev: this.isDev,
             serverId: this.serverId,
             daemonVersion: this.daemonVersion,
             daemonRuntimeConfig: this.daemonRuntimeConfig,

package/dist/server/server/workspace-directory.js

@@ -1,6 +1,6 @@
 import { homedir } from "node:os";
 import { sep } from "node:path";
-import { deriveAgentStateBucket, getWorkspaceStateBucketPriority, } from "../shared/agent-state-bucket.js";
+import { deriveAgentStateBucket, getWorkspaceStateBucketPriority, } from "@getpaseo/protocol/agent-state-bucket";
 import { SortablePager } from "./pagination/sortable-pager.js";
 import { normalizeWorkspaceId } from "./workspace-registry-model.js";
 const FETCH_WORKSPACES_SORT_KEYS = [

package/dist/server/server/workspace-git-service.d.ts

@@ -1,8 +1,8 @@
 import { watch } from "node:fs";
 import { readdir } from "node:fs/promises";
 import type pino from "pino";
-import type { ProjectCheckoutLitePayload } from "../shared/messages.js";
-import { type BranchCheckoutResolution, type BranchSuggestion, type CheckoutDiffCompare, type CheckoutDiffResult, getCheckoutDiff, getCheckoutShortstat, getCheckoutStatus, getPullRequestStatus, listBranchSuggestions, resolveRepositoryDefaultBranch, resolveBranchCheckout } from "../utils/checkout-git.js";
+import type { ProjectCheckoutLitePayload } from "@getpaseo/protocol/messages";
+import { type BranchCheckoutResolution, type BranchSuggestion, type CheckoutDiffCompare, type CheckoutDiffResult, getCheckoutDiff, getCheckoutSnapshotFacts, getCheckoutShortstat, getCheckoutStatus, getPullRequestStatus, listBranchSuggestions, resolveRepositoryDefaultBranch, resolveBranchCheckout } from "../utils/checkout-git.js";
 import { type GitHubPullRequestStatusFacts, type GitHubService, type PullRequestMergeable } from "../services/github-service.js";
 import { runGitCommand } from "../utils/run-git-command.js";
 import { listPaseoWorktrees, type PaseoWorktreeInfo } from "../utils/worktree.js";
@@ -131,6 +131,7 @@ export type WorkspaceGitSnapshotOptions = {
 interface WorkspaceGitServiceDependencies {
     watch: typeof watch;
     readdir: typeof readdir;
+    getCheckoutSnapshotFacts: typeof getCheckoutSnapshotFacts;
     getCheckoutStatus: typeof getCheckoutStatus;
     getCheckoutShortstat: typeof getCheckoutShortstat;
     getCheckoutDiff: typeof getCheckoutDiff;
@@ -207,6 +208,8 @@ export declare class WorkspaceGitServiceImpl implements WorkspaceGitService {
     private scheduleInitialWorkspaceRefresh;
     private scheduleWorkspaceObservationSetup;
     private setupWorkspaceObservation;
+    private getFactsForObservation;
+    private loadCheckoutFacts;
     private isActiveObservedWorkspaceTarget;
     private createWorkingTreeWatchTarget;
     private resolveCheckoutWatchRoot;

package/dist/server/server/workspace-git-service.js

@@ -1,8 +1,9 @@
 import { watch } from "node:fs";
 import { readFile, readdir } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import { LRUCache } from "lru-cache";
 import pLimit from "p-limit";
-import { getCheckoutDiff, getCheckoutShortstat, getCheckoutStatus, getPullRequestStatus, hasOriginRemote, listBranchSuggestions, resolveRepositoryDefaultBranch, resolveBranchCheckout, resolveAbsoluteGitDir, } from "../utils/checkout-git.js";
+import { getCheckoutDiff, getCheckoutSnapshotFacts, getCheckoutShortstat, getCheckoutStatus, getPullRequestStatus, hasOriginRemote, listBranchSuggestions, resolveRepositoryDefaultBranch, resolveBranchCheckout, resolveAbsoluteGitDir, } from "../utils/checkout-git.js";
 import { createGitHubService, } from "../services/github-service.js";
 import { parseGitRevParsePath } from "../utils/git-rev-parse-path.js";
 import { runGitCommand } from "../utils/run-git-command.js";
@@ -19,6 +20,11 @@ const WORKING_TREE_WATCH_FALLBACK_REFRESH_MS = 5000;
 const WORKSPACE_GIT_AUXILIARY_READ_TTL_MS = 15000;
 // Non-forced refresh triggers share this minimum gap to absorb watcher/self-heal bursts; force bypasses it.
 const WORKSPACE_GIT_INTERNAL_MIN_GAP_MS = 2000;
+// Heavy values (multi-MB highlighted diffs); cap aggressively. Ephemeral worktree cwds would otherwise pile up forever.
+const WORKSPACE_GIT_CHECKOUT_DIFF_CACHE_MAX = 64;
+// Small values (booleans, short strings, small arrays); generous cap.
+const WORKSPACE_GIT_AUXILIARY_CACHE_MAX = 256;
+const WORKSPACE_GIT_FACTS_REUSE_TTL_MS = 1000;
 const LINUX_WATCH_MAX_DIRS = 5000;
 const LINUX_WATCH_REFRESH_COOLDOWN_MS = 2000;
 const LINUX_WATCH_IGNORE_TTL_MS = 5 * 60 * 1000;
@@ -28,6 +34,7 @@ function buildDefaultWorkspaceGitServiceDeps() {
     return {
         watch,
         readdir,
+        getCheckoutSnapshotFacts,
         getCheckoutStatus,
         getCheckoutShortstat,
         getCheckoutDiff,
@@ -55,13 +62,13 @@ export class WorkspaceGitServiceImpl {
         this.workingTreeWatchTargets = new Map();
         this.workingTreeWatchSetups = new Map();
         this.linuxIgnoredDirsCache = new Map();
-        this.branchValidationCache = new Map();
-        this.localBranchCache = new Map();
-        this.branchSuggestionsCache = new Map();
-        this.stashListCache = new Map();
-        this.worktreeListCache = new Map();
-        this.defaultBranchCache = new Map();
-        this.checkoutDiffCache = new Map();
+        this.branchValidationCache = new LRUCache({ max: WORKSPACE_GIT_AUXILIARY_CACHE_MAX });
+        this.localBranchCache = new LRUCache({ max: WORKSPACE_GIT_AUXILIARY_CACHE_MAX });
+        this.branchSuggestionsCache = new LRUCache({ max: WORKSPACE_GIT_AUXILIARY_CACHE_MAX });
+        this.stashListCache = new LRUCache({ max: WORKSPACE_GIT_AUXILIARY_CACHE_MAX });
+        this.worktreeListCache = new LRUCache({ max: WORKSPACE_GIT_AUXILIARY_CACHE_MAX });
+        this.defaultBranchCache = new LRUCache({ max: WORKSPACE_GIT_AUXILIARY_CACHE_MAX });
+        this.checkoutDiffCache = new LRUCache({ max: WORKSPACE_GIT_CHECKOUT_DIFF_CACHE_MAX });
         this.logger = options.logger.child({ module: "workspace-git-service" });
         this.paseoHome = options.paseoHome;
         this.deps = resolveWorkspaceGitServiceDeps(options.deps);
@@ -381,6 +388,9 @@ export class WorkspaceGitServiceImpl {
             latestGithubLoadedAtMs: null,
             latestSnapshot: null,
             latestSnapshotLoadedAtMs: null,
+            latestFacts: null,
+            latestFactsLoadedAtMs: null,
+            factsPromise: null,
             latestFingerprint: null,
             lastShellOutAtMs: null,
             repoGitRoot: null,
@@ -421,7 +431,8 @@ export class WorkspaceGitServiceImpl {
         });
     }
     async setupWorkspaceObservation(target) {
-        const gitDir = await this.deps.resolveAbsoluteGitDir(target.cwd);
+        const facts = await this.getFactsForObservation(target);
+        const gitDir = facts?.isGit ? facts.absoluteGitDir : null;
         if (!this.isActiveObservedWorkspaceTarget(target)) {
             return;
         }
@@ -429,7 +440,9 @@ export class WorkspaceGitServiceImpl {
             target.observationSetupComplete = true;
             return;
         }
-        const repoGitRoot = await this.resolveWorkspaceGitRefsRoot(gitDir);
+        const repoGitRoot = facts?.isGit && facts.gitCommonDir
+            ? facts.gitCommonDir
+            : await this.resolveWorkspaceGitRefsRoot(gitDir);
         if (!this.isActiveObservedWorkspaceTarget(target)) {
             return;
         }
@@ -440,6 +453,39 @@ export class WorkspaceGitServiceImpl {
             target.observationSetupComplete = true;
         }
     }
+    async getFactsForObservation(target) {
+        return this.loadCheckoutFacts(target, {
+            paseoHome: this.paseoHome,
+            logger: this.logger,
+            allowRecent: true,
+        });
+    }
+    loadCheckoutFacts(target, options) {
+        if (options.allowRecent && target.latestFacts && target.latestFactsLoadedAtMs !== null) {
+            const ageMs = this.deps.now().getTime() - target.latestFactsLoadedAtMs;
+            if (ageMs < WORKSPACE_GIT_FACTS_REUSE_TTL_MS) {
+                return Promise.resolve(target.latestFacts);
+            }
+        }
+        if (target.factsPromise) {
+            return target.factsPromise;
+        }
+        const { allowRecent: _allowRecent, ...context } = options;
+        const promise = this.deps
+            .getCheckoutSnapshotFacts(target.cwd, context)
+            .then((facts) => {
+            target.latestFacts = facts;
+            target.latestFactsLoadedAtMs = this.deps.now().getTime();
+            return facts;
+        })
+            .finally(() => {
+            if (target.factsPromise === promise) {
+                target.factsPromise = null;
+            }
+        });
+        target.factsPromise = promise;
+        return promise;
+    }
     isActiveObservedWorkspaceTarget(target) {
         return (!target.closed &&
             target.listeners.size > 0 &&
@@ -554,7 +600,10 @@ export class WorkspaceGitServiceImpl {
             existingTarget.workspaceKeys.add(workspaceTarget.cwd);
             return;
         }
-        const hasOrigin = await this.deps.hasOriginRemote(workspaceTarget.cwd);
+        const facts = workspaceTarget.latestFacts;
+        const hasOrigin = facts?.isGit === true
+            ? facts.remoteUrl !== null
+            : await this.deps.hasOriginRemote(workspaceTarget.cwd);
         if (!this.isActiveObservedWorkspaceTarget(workspaceTarget)) {
             return;
         }
@@ -936,9 +985,9 @@ export class WorkspaceGitServiceImpl {
         return snapshot;
     }
     async refreshSnapshot(target, request) {
-        await this.refreshGitSnapshot(target, request);
+        const facts = await this.refreshGitSnapshot(target, request);
         if (request.includeGitHub) {
-            await this.refreshGitHubSnapshot(target, request);
+            await this.refreshGitHubSnapshot(target, request, facts);
         }
         const snapshot = this.combineSnapshot(target);
         target.latestSnapshotLoadedAtMs = this.deps.now().getTime();
@@ -949,7 +998,12 @@ export class WorkspaceGitServiceImpl {
         target.lastShellOutAtMs = now.getTime();
         const cwd = target.cwd;
         const previousGitHubPollKey = this.getGitHubPollKey(target);
-        const context = { paseoHome: this.paseoHome, logger: this.logger };
+        const baseContext = { paseoHome: this.paseoHome, logger: this.logger };
+        const facts = await this.loadCheckoutFacts(target, {
+            ...baseContext,
+            allowRecent: !request.force,
+        });
+        const context = { ...baseContext, facts };
         const checkoutStatus = await this.deps.getCheckoutStatus(cwd, context);
         if (!checkoutStatus.isGit) {
             target.latestGit = buildNotGitSnapshot(cwd).git;
@@ -957,7 +1011,7 @@ export class WorkspaceGitServiceImpl {
             target.cachedGitHubRemote = null;
             target.latestGithub = buildGitHubUnavailableSnapshot();
             target.latestGithubLoadedAtMs = target.latestGitLoadedAtMs;
-            return;
+            return facts;
         }
         await this.resolveGitHubRemoteForTarget(target, checkoutStatus.remoteUrl);
         const diffStat = await this.deps
@@ -983,8 +1037,9 @@ export class WorkspaceGitServiceImpl {
             target.latestGithub = buildGitHubUnavailableSnapshot();
             target.latestGithubLoadedAtMs = target.latestGitLoadedAtMs;
         }
+        return facts;
     }
-    async refreshGitHubSnapshot(target, request) {
+    async refreshGitHubSnapshot(target, request, facts) {
         const githubRemote = target.cachedGitHubRemote?.identity ?? null;
         const forceGitHub = request.force && request.includeGitHub;
         if (forceGitHub) {
@@ -997,6 +1052,7 @@ export class WorkspaceGitServiceImpl {
             deps: this.deps,
             force: forceGitHub,
             reason: request.reason,
+            facts,
         });
         target.latestGithubLoadedAtMs = this.deps.now().getTime();
     }
@@ -1183,7 +1239,7 @@ async function loadGitHubSnapshot(options) {
         const result = await options.deps.getPullRequestStatus(options.cwd, options.deps.github, {
             force: options.force,
             reason: options.reason,
-        });
+        }, { facts: options.facts });
         return {
             featuresEnabled: true,
             pullRequest: result.status,

package/dist/server/server/workspace-registry-model.d.ts

@@ -1,4 +1,4 @@
-import type { ProjectCheckoutLitePayload, ProjectPlacementPayload } from "../shared/messages.js";
+import type { ProjectCheckoutLitePayload, ProjectPlacementPayload } from "@getpaseo/protocol/messages";
 import type { PersistedWorkspaceRecord } from "./workspace-registry.js";
 export type PersistedProjectKind = "git" | "non_git";
 export type PersistedWorkspaceKind = "local_checkout" | "worktree" | "directory";

package/dist/server/server/workspace-registry.d.ts

@@ -13,17 +13,17 @@ declare const PersistedProjectRecordSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     createdAt: string;
     updatedAt: string;
-    kind: "git" | "non_git";
     archivedAt: string | null;
+    kind: "git" | "non_git";
     projectId: string;
-    customName: string | null;
     rootPath: string;
     displayName: string;
+    customName: string | null;
 }, {
     createdAt: string;
     updatedAt: string;
-    kind: "git" | "non_git";
     archivedAt: string | null;
+    kind: "git" | "non_git";
     projectId: string;
     rootPath: string;
     displayName: string;
@@ -42,20 +42,20 @@ declare const PersistedWorkspaceRecordSchema: z.ZodObject<{
     cwd: string;
     createdAt: string;
     updatedAt: string;
-    kind: "worktree" | "directory" | "local_checkout";
     archivedAt: string | null;
+    kind: "worktree" | "local_checkout" | "directory";
     projectId: string;
-    workspaceId: string;
     displayName: string;
+    workspaceId: string;
 }, {
     cwd: string;
     createdAt: string;
     updatedAt: string;
-    kind: "worktree" | "directory" | "local_checkout";
     archivedAt: string | null;
+    kind: "worktree" | "local_checkout" | "directory";
     projectId: string;
-    workspaceId: string;
     displayName: string;
+    workspaceId: string;
 }>;
 export type PersistedProjectRecord = z.infer<typeof PersistedProjectRecordSchema>;
 export type PersistedWorkspaceRecord = z.infer<typeof PersistedWorkspaceRecordSchema>;

package/dist/server/server/worktree/commands.d.ts

@@ -0,0 +1,51 @@
+import { type ArchivePaseoWorktreeDependencies } from "../paseo-worktree-archive-service.js";
+import type { CreatePaseoWorktreeInput, CreatePaseoWorktreeResult } from "../paseo-worktree-service.js";
+import { type WorktreeWireError } from "../worktree-errors.js";
+import type { WorkspaceGitService, WorkspaceGitWorktreeInfo } from "../workspace-git-service.js";
+export interface ListPaseoWorktreesCommandDependencies {
+    workspaceGitService: Pick<WorkspaceGitService, "listWorktrees">;
+}
+export interface ListPaseoWorktreesCommandInput {
+    cwd: string;
+    reason?: string;
+}
+export declare function listPaseoWorktreesCommand(dependencies: ListPaseoWorktreesCommandDependencies, input: ListPaseoWorktreesCommandInput): Promise<WorkspaceGitWorktreeInfo[]>;
+type CreatePaseoWorktreeWorkflow<Result extends CreatePaseoWorktreeResult> = (input: CreatePaseoWorktreeInput) => Promise<Result>;
+export interface CreatePaseoWorktreeCommandDependencies<Result extends CreatePaseoWorktreeResult = CreatePaseoWorktreeResult> {
+    paseoHome?: string;
+    createPaseoWorktreeWorkflow?: CreatePaseoWorktreeWorkflow<Result>;
+}
+export type CreatePaseoWorktreeCommandInput = Omit<CreatePaseoWorktreeInput, "paseoHome" | "runSetup"> & {
+    paseoHome?: string;
+};
+export type CreatePaseoWorktreeCommandResult<Result extends CreatePaseoWorktreeResult> = {
+    ok: true;
+    createdWorktree: Result;
+} | {
+    ok: false;
+    error: WorktreeWireError;
+    cause: unknown;
+};
+export declare function createPaseoWorktreeCommand<Result extends CreatePaseoWorktreeResult>(dependencies: CreatePaseoWorktreeCommandDependencies<Result>, input: CreatePaseoWorktreeCommandInput): Promise<CreatePaseoWorktreeCommandResult<Result>>;
+export interface ArchivePaseoWorktreeCommandDependencies extends Omit<ArchivePaseoWorktreeDependencies, "workspaceGitService"> {
+    workspaceGitService: Pick<WorkspaceGitService, "getSnapshot" | "listWorktrees">;
+}
+export interface ArchivePaseoWorktreeCommandInput {
+    requestId: string;
+    repoRoot?: string | null;
+    worktreePath?: string;
+    worktreeSlug?: string;
+    branchName?: string;
+}
+export type ArchivePaseoWorktreeCommandResult = {
+    ok: true;
+    removedAgents: string[];
+} | {
+    ok: false;
+    code: "NOT_ALLOWED";
+    message: string;
+    removedAgents: [];
+};
+export declare function archivePaseoWorktreeCommand(dependencies: ArchivePaseoWorktreeCommandDependencies, input: ArchivePaseoWorktreeCommandInput): Promise<ArchivePaseoWorktreeCommandResult>;
+export {};
+//# sourceMappingURL=commands.d.ts.map

package/dist/server/server/worktree/commands.js

@@ -0,0 +1,84 @@
+import { join } from "node:path";
+import { getPaseoWorktreesRoot, isPaseoOwnedWorktreeCwd } from "../../utils/worktree.js";
+import { archivePaseoWorktree, } from "../paseo-worktree-archive-service.js";
+import { toWorktreeWireError } from "../worktree-errors.js";
+export async function listPaseoWorktreesCommand(dependencies, input) {
+    if (input.reason) {
+        return dependencies.workspaceGitService.listWorktrees(input.cwd, { reason: input.reason });
+    }
+    return dependencies.workspaceGitService.listWorktrees(input.cwd);
+}
+export async function createPaseoWorktreeCommand(dependencies, input) {
+    try {
+        if (!dependencies.createPaseoWorktreeWorkflow) {
+            throw new Error("Paseo worktree service is not configured");
+        }
+        const createdWorktree = await dependencies.createPaseoWorktreeWorkflow({
+            ...input,
+            runSetup: false,
+            paseoHome: input.paseoHome ?? dependencies.paseoHome,
+        });
+        return { ok: true, createdWorktree };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: toWorktreeWireError(error),
+            cause: error,
+        };
+    }
+}
+export async function archivePaseoWorktreeCommand(dependencies, input) {
+    const resolvedTarget = await resolveArchiveTarget(dependencies, input);
+    const ownership = await isPaseoOwnedWorktreeCwd(resolvedTarget.targetPath, {
+        paseoHome: dependencies.paseoHome,
+    });
+    if (!ownership.allowed) {
+        return {
+            ok: false,
+            code: "NOT_ALLOWED",
+            message: "Worktree is not a Paseo-owned worktree",
+            removedAgents: [],
+        };
+    }
+    const repoRoot = ownership.repoRoot ?? resolvedTarget.repoRoot ?? null;
+    const removedAgents = await archivePaseoWorktree(dependencies, {
+        targetPath: resolvedTarget.targetPath,
+        repoRoot,
+        worktreesRoot: ownership.worktreeRoot,
+        requestId: input.requestId,
+    });
+    return {
+        ok: true,
+        removedAgents,
+    };
+}
+async function resolveArchiveTarget(dependencies, input) {
+    const repoRoot = input.repoRoot ?? null;
+    if (input.worktreePath) {
+        return { targetPath: input.worktreePath, repoRoot };
+    }
+    if (input.worktreeSlug) {
+        if (!repoRoot) {
+            throw new Error("repoRoot is required when worktreeSlug is supplied");
+        }
+        return {
+            targetPath: await resolveWorktreeSlugPath(dependencies, repoRoot, input.worktreeSlug),
+            repoRoot,
+        };
+    }
+    if (repoRoot && input.branchName) {
+        const worktrees = await dependencies.workspaceGitService.listWorktrees(repoRoot);
+        const match = worktrees.find((entry) => entry.branchName === input.branchName);
+        if (!match) {
+            throw new Error(`Paseo worktree not found for branch ${input.branchName}`);
+        }
+        return { targetPath: match.path, repoRoot };
+    }
+    throw new Error("worktreePath, worktreeSlug, or repoRoot+branchName is required");
+}
+async function resolveWorktreeSlugPath(dependencies, repoRoot, worktreeSlug) {
+    const worktreesRoot = await getPaseoWorktreesRoot(repoRoot, dependencies.paseoHome);
+    return join(worktreesRoot, worktreeSlug);
+}
+//# sourceMappingURL=commands.js.map

package/dist/server/server/worktree-branch-name-generator.d.ts

@@ -1,4 +1,4 @@
-import type { FirstAgentContext } from "../shared/messages.js";
+import type { FirstAgentContext } from "@getpaseo/protocol/messages";
 import type { AgentManager } from "./agent/agent-manager.js";
 import { generateStructuredAgentResponseWithFallback } from "./agent/agent-response-loop.js";
 import type { WorkspaceGitService } from "./workspace-git-service.js";

package/dist/server/server/worktree-core.d.ts

@@ -1,7 +1,7 @@
 import type { GitHubService } from "../services/github-service.js";
 import { type WorktreeConfig } from "../utils/worktree.js";
 import { type WorktreeCreationIntent } from "./resolve-worktree-creation-intent.js";
-import type { FirstAgentContext } from "../shared/messages.js";
+import type { FirstAgentContext } from "@getpaseo/protocol/messages";
 import type { WorkspaceGitService } from "./workspace-git-service.js";
 export interface CreateWorktreeCoreInput {
     cwd: string;

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

@@ -11,7 +11,7 @@ import type { GitHubService } from "../services/github-service.js";
 import type { CheckoutExistingBranchResult } from "../utils/checkout-git.js";
 import { type WorktreeConfig } from "../utils/worktree.js";
 import type { CreatePaseoWorktreeInput, CreatePaseoWorktreeResult } from "./paseo-worktree-service.js";
-import { type ArchivePaseoWorktreeDependencies } from "./paseo-worktree-archive-service.js";
+import type { ArchivePaseoWorktreeDependencies } from "./paseo-worktree-archive-service.js";
 export interface NormalizedGitOptions {
     baseBranch?: string;
     createNewBranch: boolean;