@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/session/workspace-provisioning/workspace-provisioning-service.d.ts

@@ -0,0 +1,59 @@
+import type { PluginLifecycle } from "../../plugins/lifecycle/index.js";
+import type { Logger } from "pino";
+import { type PersistedProjectRecord, type PersistedWorkspaceRecord, type ProjectRegistry, type WorkspaceRegistry } from "../../workspace-registry.js";
+import type { WorkspaceGitService } from "../../workspace-git-service.js";
+import type { CreatePaseoWorktreeWorkflowResult } from "../../worktree-session.js";
+import type { UntrustedWorkspaceSource } from "../../workspace-automation-gate.js";
+export interface ResolveOrCreateWorkspaceIdInput {
+    createdWorktree: CreatePaseoWorktreeWorkflowResult | null;
+    requestedWorkspaceId?: string;
+    cwd: string;
+    initialTitle: string | null;
+}
+export interface ImportWorkspaceInput {
+    cwd: string;
+    requestedWorkspaceId?: string;
+}
+export interface ImportWorkspaceResult<T> {
+    value: T;
+    createdWorkspace: PersistedWorkspaceRecord | null;
+}
+export interface CreateWorktreeWorkspaceInput {
+    sourceCwd: string;
+    projectId?: string;
+    workspaceId?: string;
+    repoRoot: string;
+    cwd: string;
+    worktreeRoot: string;
+    branch: string | null;
+    baseBranch: string | null;
+    title: string | null;
+    expectsInitialAgent?: boolean;
+    untrustedSource?: UntrustedWorkspaceSource;
+}
+export interface WorkspaceProvisioningService {
+    runInImportWorkspace<T>(input: ImportWorkspaceInput, operation: (workspace: PersistedWorkspaceRecord) => Promise<T>): Promise<ImportWorkspaceResult<T>>;
+    findOrCreateWorkspaceForDirectory(cwd: string): Promise<PersistedWorkspaceRecord>;
+    resolveOrCreateWorkspaceIdForCreateAgent(input: ResolveOrCreateWorkspaceIdInput): Promise<string>;
+    createWorkspaceForDirectory(cwd: string, title?: string | null, projectId?: string, context?: {
+        expectsInitialAgent?: boolean;
+        workspaceId?: string;
+    }): Promise<PersistedWorkspaceRecord>;
+    createWorkspaceForWorktree(input: CreateWorktreeWorkspaceInput): Promise<PersistedWorkspaceRecord>;
+    findOrCreateProjectForDirectory(cwd: string): Promise<PersistedProjectRecord>;
+    ensureWorkspaceRecordUnarchived(workspace: PersistedWorkspaceRecord): Promise<PersistedWorkspaceRecord>;
+}
+export type WorkspaceProvisioningErrorCode = "unknown_project" | "archived_project";
+export declare class WorkspaceProvisioningError extends Error {
+    readonly code: WorkspaceProvisioningErrorCode;
+    constructor(code: WorkspaceProvisioningErrorCode, projectId: string);
+}
+export declare function createWorkspaceProvisioningService(deps: {
+    serverId?: string;
+    workspaceRegistry: WorkspaceRegistry;
+    projectRegistry: ProjectRegistry;
+    workspaceGitService: Pick<WorkspaceGitService, "getCheckout" | "getSnapshot" | "peekSnapshot">;
+    logger: Logger;
+    lifecycle?: PluginLifecycle;
+}): WorkspaceProvisioningService;
+//# sourceMappingURL=workspace-provisioning-service.d.ts.map

package/dist/server/server/session/workspace-provisioning/workspace-provisioning-service.js

@@ -0,0 +1,326 @@
+import { describeHookWorkspace } from "../../plugins/lifecycle/index.js";
+import { basename, resolve } from "node:path";
+import { generateWorkspaceId, initialWorkspacePlacement, reconcileWorkspacePlacement, } from "../../workspace-registry-model.js";
+import { createPersistedWorkspaceRecord, } from "../../workspace-registry.js";
+import { deriveProjectKey } from "../../project-key.js";
+import { areEquivalentPaths, createRealpathAwarePathMatcher } from "../../../utils/path.js";
+export class WorkspaceProvisioningError extends Error {
+    constructor(code, projectId) {
+        super(code === "unknown_project"
+            ? `Unknown project: ${projectId}`
+            : `Archived project: ${projectId}`);
+        this.code = code;
+        this.name = "WorkspaceProvisioningError";
+    }
+}
+export function createWorkspaceProvisioningService(deps) {
+    const { serverId, workspaceRegistry, projectRegistry, workspaceGitService, logger } = deps;
+    async function runInImportWorkspace(input, operation) {
+        if (input.requestedWorkspaceId) {
+            const workspace = await workspaceRegistry.get(input.requestedWorkspaceId);
+            if (!workspace || workspace.archivedAt) {
+                throw new Error(`Workspace not found: ${input.requestedWorkspaceId}`);
+            }
+            const project = await projectRegistry.get(workspace.projectId);
+            if (!project || project.archivedAt) {
+                throw new Error(`Project not found: ${workspace.projectId}`);
+            }
+            if (!createRealpathAwarePathMatcher(workspace.cwd)(input.cwd)) {
+                throw new Error(`Import cwd does not match workspace: ${workspace.workspaceId}`);
+            }
+            return {
+                value: await operation(workspace),
+                createdWorkspace: null,
+            };
+        }
+        const [projectsBeforeImport, workspacesBeforeImport] = await Promise.all([
+            projectRegistry.list(),
+            workspaceRegistry.list(),
+        ]);
+        const workspace = await findOrCreateWorkspaceForDirectory(input.cwd);
+        const createdWorkspace = workspacesBeforeImport.some((candidate) => candidate.workspaceId === workspace.workspaceId)
+            ? null
+            : workspace;
+        const previousProject = projectsBeforeImport.find((project) => project.projectId === workspace.projectId) ?? null;
+        try {
+            return {
+                value: await operation(workspace),
+                createdWorkspace,
+            };
+        }
+        catch (error) {
+            if (createdWorkspace) {
+                await rollbackFailedImportWorkspace(createdWorkspace, previousProject);
+            }
+            throw error;
+        }
+    }
+    async function rollbackFailedImportWorkspace(workspace, previousProject) {
+        try {
+            await workspaceRegistry.remove(workspace.workspaceId);
+            const projectHasActiveWorkspace = (await workspaceRegistry.list()).some((candidate) => candidate.projectId === workspace.projectId && !candidate.archivedAt);
+            if (projectHasActiveWorkspace) {
+                return;
+            }
+            if (previousProject?.archivedAt) {
+                await projectRegistry.upsert(previousProject);
+            }
+            else if (!previousProject) {
+                await projectRegistry.remove(workspace.projectId);
+            }
+        }
+        catch (error) {
+            logger.error({ err: error, workspaceId: workspace.workspaceId, projectId: workspace.projectId }, "Failed to restore workspace state after provider import failure");
+        }
+    }
+    async function findOrCreateProjectForDirectory(cwd) {
+        const rootPath = resolve(cwd);
+        const checkout = await workspaceGitService.getCheckout(rootPath);
+        const timestamp = new Date().toISOString();
+        return projectRegistry.getOrCreateActiveByRoot({
+            rootPath,
+            kind: checkout.isGit ? "git" : "non_git",
+            displayName: basename(rootPath) || rootPath,
+            projectKey: deriveProjectKey({
+                rootPath,
+                remoteUrl: checkout.remoteUrl,
+                worktreeRoot: checkout.worktreeRoot,
+                mainRepoRoot: checkout.mainRepoRoot,
+                serverId,
+            }),
+            timestamp,
+        });
+    }
+    async function requireActiveProject(projectId) {
+        const project = await projectRegistry.get(projectId);
+        if (!project)
+            throw new WorkspaceProvisioningError("unknown_project", projectId);
+        if (project.archivedAt)
+            throw new WorkspaceProvisioningError("archived_project", projectId);
+        return project;
+    }
+    async function createWorkspaceForDirectory(cwd, title, projectId, context) {
+        const normalizedCwd = resolve(cwd);
+        const checkout = await workspaceGitService.getCheckout(normalizedCwd);
+        const project = projectId
+            ? await refreshProjectKind(await requireActiveProject(projectId), normalizedCwd, checkout)
+            : // COMPAT(workspaceCreateMissingProjectId): added in v0.1.107, remove after 2027-01-15.
+                await findOrCreateProjectForDirectory(normalizedCwd);
+        const timestamp = new Date().toISOString();
+        const workspace = createPersistedWorkspaceRecord({
+            workspaceId: context?.workspaceId ?? generateWorkspaceId(),
+            projectId: project.projectId,
+            ...initialWorkspacePlacement({ source: "checkout", cwd: normalizedCwd, checkout }),
+            title: title?.trim() || null,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        });
+        await workspaceRegistry.upsert(workspace, context);
+        deps.lifecycle?.emit("workspace.created", { workspace: describeHookWorkspace(workspace) });
+        return workspace;
+    }
+    async function createWorkspaceForWorktree(input) {
+        const sourceCwd = resolve(input.sourceCwd);
+        const repoRoot = resolve(input.repoRoot);
+        const cwd = resolve(input.cwd);
+        const worktreeRoot = resolve(input.worktreeRoot);
+        const project = await resolveSourceProjectForWorktree({
+            sourceCwd,
+            projectId: input.projectId,
+            repoRoot,
+        });
+        const timestamp = new Date().toISOString();
+        const workspace = createPersistedWorkspaceRecord({
+            workspaceId: input.workspaceId ?? generateWorkspaceId(),
+            projectId: project.projectId,
+            ...initialWorkspacePlacement({
+                source: "created_worktree",
+                cwd,
+                worktreeRoot,
+                branch: input.branch,
+                baseBranch: input.baseBranch,
+                mainRepoRoot: repoRoot,
+            }),
+            title: input.title,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+            ...(input.untrustedSource ? { untrustedSource: input.untrustedSource } : {}),
+        });
+        await workspaceRegistry.upsert(workspace, {
+            expectsInitialAgent: input.expectsInitialAgent,
+        });
+        deps.lifecycle?.emit("workspace.created", { workspace: describeHookWorkspace(workspace) });
+        return workspace;
+    }
+    async function resolveSourceProjectForWorktree(input) {
+        if (input.projectId) {
+            return refreshProjectKind(await requireActiveProject(input.projectId));
+        }
+        const workspaces = await workspaceRegistry.list();
+        const sourceWorkspace = workspaces.find((workspace) => !workspace.archivedAt && areEquivalentPaths(workspace.cwd, input.sourceCwd)) ??
+            workspaces.find((workspace) => !workspace.archivedAt && areEquivalentPaths(workspace.cwd, input.repoRoot));
+        if (sourceWorkspace) {
+            const project = await projectRegistry.get(sourceWorkspace.projectId);
+            if (project)
+                return refreshProjectKind(project);
+            // COMPAT(worktreeMissingSourceProject): added in v0.1.107, remove after 2027-01-15.
+            // Orphaned legacy workspace FKs fall through to exact-root allocation.
+        }
+        const checkout = await workspaceGitService.getCheckout(input.repoRoot);
+        const project = await projectRegistry.getOrCreateActiveByRoot({
+            rootPath: input.repoRoot,
+            kind: "git",
+            displayName: basename(input.repoRoot) || input.repoRoot,
+            projectKey: deriveProjectKey({
+                rootPath: input.repoRoot,
+                remoteUrl: checkout.remoteUrl,
+                worktreeRoot: checkout.worktreeRoot,
+                mainRepoRoot: checkout.mainRepoRoot,
+                serverId,
+            }),
+            timestamp: new Date().toISOString(),
+        });
+        return refreshProjectKind(project);
+    }
+    async function findOrCreateWorkspaceForDirectory(cwd) {
+        const normalizedCwd = resolve(cwd);
+        const workspaces = await workspaceRegistry.list();
+        const active = workspaces
+            .filter((workspace) => !workspace.archivedAt && areEquivalentPaths(workspace.cwd, normalizedCwd))
+            .sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt) ||
+            left.workspaceId.localeCompare(right.workspaceId))[0];
+        if (active)
+            return refreshWorkspaceRecord(active);
+        const archived = workspaces
+            .filter((workspace) => workspace.archivedAt && areEquivalentPaths(workspace.cwd, normalizedCwd))
+            .sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt) ||
+            left.workspaceId.localeCompare(right.workspaceId))[0];
+        if (archived) {
+            const project = await projectRegistry.get(archived.projectId);
+            if (project && !project.archivedAt)
+                return ensureWorkspaceRecordUnarchived(archived);
+        }
+        return createWorkspaceForDirectory(normalizedCwd);
+    }
+    async function resolveOrCreateWorkspaceIdForCreateAgent(input) {
+        if (input.createdWorktree)
+            return input.createdWorktree.workspace.workspaceId;
+        if (input.requestedWorkspaceId)
+            return input.requestedWorkspaceId;
+        return (await createWorkspaceForDirectory(input.cwd, input.initialTitle, undefined, {
+            expectsInitialAgent: true,
+        })).workspaceId;
+    }
+    async function resolveRestoredAutoArchiveChangeRequestUrl(workspace) {
+        if (!workspace.archivedAt) {
+            return workspace.autoArchivedChangeRequestUrl;
+        }
+        const snapshot = await workspaceGitService.getSnapshot(workspace.cwd, {
+            force: true,
+            includeForge: true,
+            reason: "workspace-restore-auto-archive-latch",
+        });
+        return snapshot.forge.pullRequest?.isMerged
+            ? snapshot.forge.pullRequest.url
+            : workspace.autoArchivedChangeRequestUrl;
+    }
+    async function ensureWorkspaceRecordUnarchived(workspace) {
+        const project = await projectRegistry.get(workspace.projectId);
+        if (!project)
+            throw new Error(`Unknown project: ${workspace.projectId}`);
+        const timestamp = new Date().toISOString();
+        const checkout = workspace.archivedAt || project.archivedAt
+            ? await workspaceGitService.getCheckout(workspace.cwd)
+            : null;
+        const autoArchivedChangeRequestUrl = await resolveRestoredAutoArchiveChangeRequestUrl(workspace);
+        let next = null;
+        if (workspace.archivedAt && checkout) {
+            const placementUpdate = reconcileWorkspacePlacement({
+                workspace,
+                checkout,
+                updatedAt: timestamp,
+            });
+            next = {
+                ...(placementUpdate?.workspace ?? workspace),
+                archivedAt: null,
+                autoArchivedChangeRequestUrl,
+                updatedAt: timestamp,
+            };
+        }
+        if (checkout && (project.archivedAt || workspace.archivedAt)) {
+            const projectCheckout = areEquivalentPaths(project.rootPath, workspace.cwd)
+                ? checkout
+                : await workspaceGitService.getCheckout(project.rootPath);
+            const kind = projectCheckout.isGit ? "git" : "non_git";
+            const projectKey = deriveProjectKey({
+                rootPath: project.rootPath,
+                remoteUrl: projectCheckout.remoteUrl,
+                worktreeRoot: projectCheckout.worktreeRoot,
+                mainRepoRoot: projectCheckout.mainRepoRoot,
+                serverId,
+            });
+            if (project.archivedAt || project.kind !== kind || project.projectKey !== projectKey) {
+                await projectRegistry.upsert({
+                    ...project,
+                    kind,
+                    projectKey,
+                    archivedAt: null,
+                    updatedAt: timestamp,
+                });
+            }
+        }
+        if (!next)
+            return workspace;
+        await workspaceRegistry.upsert(next);
+        return next;
+    }
+    async function refreshWorkspaceRecord(workspace) {
+        const checkout = await workspaceGitService.getCheckout(workspace.cwd);
+        const project = await projectRegistry.get(workspace.projectId);
+        if (project && !project.archivedAt) {
+            await refreshProjectKind(project, workspace.cwd, checkout);
+        }
+        const update = reconcileWorkspacePlacement({
+            workspace,
+            checkout,
+            updatedAt: new Date().toISOString(),
+        });
+        if (!update)
+            return workspace;
+        await workspaceRegistry.upsert(update.workspace);
+        return update.workspace;
+    }
+    async function refreshProjectKind(project, workspaceCwd, workspaceCheckout) {
+        const projectCheckout = workspaceCwd && workspaceCheckout && areEquivalentPaths(project.rootPath, workspaceCwd)
+            ? workspaceCheckout
+            : await workspaceGitService.getCheckout(project.rootPath);
+        const kind = projectCheckout.isGit ? "git" : "non_git";
+        const projectKey = deriveProjectKey({
+            rootPath: project.rootPath,
+            remoteUrl: projectCheckout.remoteUrl,
+            worktreeRoot: projectCheckout.worktreeRoot,
+            mainRepoRoot: projectCheckout.mainRepoRoot,
+            serverId,
+        });
+        if (project.kind === kind && project.projectKey === projectKey)
+            return project;
+        const refreshed = {
+            ...project,
+            kind,
+            projectKey,
+            updatedAt: new Date().toISOString(),
+        };
+        await projectRegistry.upsert(refreshed);
+        return refreshed;
+    }
+    return {
+        runInImportWorkspace,
+        findOrCreateWorkspaceForDirectory,
+        resolveOrCreateWorkspaceIdForCreateAgent,
+        createWorkspaceForDirectory,
+        createWorkspaceForWorktree,
+        findOrCreateProjectForDirectory,
+        ensureWorkspaceRecordUnarchived,
+    };
+}
+//# sourceMappingURL=workspace-provisioning-service.js.map

package/dist/server/server/session/workspace-recovery/workspace-recovery-service.d.ts

@@ -0,0 +1,30 @@
+import { type PersistedProjectRecord, type PersistedWorkspaceRecord } from "../../workspace-registry.js";
+export type WorkspaceRecoveryAction = "unarchive" | "restore";
+export type WorkspaceRecoveryState = {
+    kind: "recoverable";
+    workspaceId: string;
+    workspaceName: string;
+    action: WorkspaceRecoveryAction;
+    branch: string | null;
+} | {
+    kind: "unavailable";
+    workspaceId: string;
+    reason: "workspace_not_found" | "workspace_not_archived" | "project_not_found" | "project_directory_missing" | "workspace_directory_missing" | "worktree_branch_missing";
+    message: string;
+};
+export interface WorkspaceRecoveryService {
+    inspect(workspaceId: string): Promise<WorkspaceRecoveryState>;
+    restore(workspaceId: string): Promise<{
+        workspaceId: string;
+        action: WorkspaceRecoveryAction;
+    }>;
+}
+export declare function createWorkspaceRecoveryService(deps: {
+    paseoHome: string;
+    worktreesRoot?: string;
+    getWorkspace: (workspaceId: string) => Promise<PersistedWorkspaceRecord | null>;
+    getProject: (projectId: string) => Promise<PersistedProjectRecord | null>;
+    isDirectory: (path: string) => Promise<boolean>;
+    unarchiveWorkspace: (workspace: PersistedWorkspaceRecord) => Promise<void>;
+}): WorkspaceRecoveryService;
+//# sourceMappingURL=workspace-recovery-service.d.ts.map

package/dist/server/server/session/workspace-recovery/workspace-recovery-service.js

@@ -0,0 +1,178 @@
+import { basename } from "node:path";
+import { createRealpathAwarePathMatcher } from "../../../utils/path.js";
+import { runGitCommand } from "../../../utils/run-git-command.js";
+import { createWorktree, isPaseoOwnedWorktreeCwd, mapWorkspaceCwdToWorktree, rollbackCreatedPaseoWorktree, } from "../../../utils/worktree.js";
+import { WorktreeRequestError, toWorktreeRequestError } from "../../worktree-errors.js";
+import { resolveWorkspaceDisplayName, } from "../../workspace-registry.js";
+export function createWorkspaceRecoveryService(deps) {
+    async function resolveRecovery(workspaceId) {
+        const workspace = await deps.getWorkspace(workspaceId);
+        if (!workspace) {
+            return {
+                kind: "unavailable",
+                workspaceId,
+                reason: "workspace_not_found",
+                message: "This workspace is no longer known to the host.",
+            };
+        }
+        if (!workspace.archivedAt) {
+            return {
+                kind: "unavailable",
+                workspaceId,
+                reason: "workspace_not_archived",
+                message: "This workspace is not archived, but it is unavailable from the host.",
+            };
+        }
+        const project = await deps.getProject(workspace.projectId);
+        if (!project) {
+            return {
+                kind: "unavailable",
+                workspaceId,
+                reason: "project_not_found",
+                message: "The project for this archived workspace no longer exists.",
+            };
+        }
+        if (await deps.isDirectory(workspace.cwd)) {
+            return createRecoveryPlan({ action: "unarchive", workspace });
+        }
+        if (workspace.kind !== "worktree") {
+            return {
+                kind: "unavailable",
+                workspaceId,
+                reason: "workspace_directory_missing",
+                message: "The archived workspace directory no longer exists and cannot be recreated.",
+            };
+        }
+        if (!workspace.branch) {
+            return {
+                kind: "unavailable",
+                workspaceId,
+                reason: "worktree_branch_missing",
+                message: "The archived worktree has no branch recorded, so it cannot be restored.",
+            };
+        }
+        // COMPAT(worktreeRestoreMissingMainRepoRoot): records created before v0.1.110
+        // lack placement ownership; remove the project-root fallback after 2027-01-17.
+        const sourceRepoRoot = workspace.mainRepoRoot ?? project.rootPath;
+        if (!(await deps.isDirectory(sourceRepoRoot))) {
+            return {
+                kind: "unavailable",
+                workspaceId,
+                reason: "project_directory_missing",
+                message: "The source repository needed to restore this worktree no longer exists.",
+            };
+        }
+        return createRecoveryPlan({ action: "restore", workspace, sourceRepoRoot });
+    }
+    async function inspect(workspaceId) {
+        const resolved = await resolveRecovery(workspaceId);
+        return resolved.kind === "unavailable" ? resolved : resolved.state;
+    }
+    async function restore(workspaceId) {
+        const resolved = await resolveRecovery(workspaceId);
+        if (resolved.kind === "unavailable") {
+            throw new Error(resolved.message);
+        }
+        if (resolved.kind === "restore") {
+            await recreateArchivedWorktree(resolved.workspace, resolved.sourceRepoRoot);
+        }
+        await deps.unarchiveWorkspace(resolved.workspace);
+        return { workspaceId, action: resolved.kind };
+    }
+    async function recreateArchivedWorktree(workspace, sourceRepoRoot) {
+        const branch = workspace.branch;
+        if (!branch) {
+            throw new WorktreeRequestError({
+                code: "unknown",
+                message: `Workspace ${workspace.workspaceId} has no branch to restore`,
+            });
+        }
+        try {
+            await runGitCommand(["worktree", "prune"], { cwd: sourceRepoRoot, timeout: 30000 });
+        }
+        catch {
+            // A stale worktree registration is not guaranteed; creation reports any real conflict.
+        }
+        let previousWorktreePath = workspace.worktreeRoot;
+        if (!previousWorktreePath) {
+            // COMPAT(worktreeRestoreMissingWorktreeRoot): records created before v0.1.110
+            // lack durable backing placement; remove filesystem discovery after 2027-01-17.
+            const ownership = await isPaseoOwnedWorktreeCwd(workspace.cwd, {
+                paseoHome: deps.paseoHome,
+                worktreesRoot: deps.worktreesRoot,
+            });
+            previousWorktreePath = ownership.allowed
+                ? (ownership.worktreePath ?? workspace.cwd)
+                : workspace.cwd;
+        }
+        let recreatedWorktreePath;
+        try {
+            const result = await createWorktree({
+                cwd: sourceRepoRoot,
+                worktreeSlug: basename(previousWorktreePath),
+                source: { kind: "checkout-branch", branchName: branch },
+                runSetup: false,
+                paseoHome: deps.paseoHome,
+                worktreesRoot: deps.worktreesRoot,
+            });
+            recreatedWorktreePath = result.worktreePath;
+        }
+        catch (error) {
+            throw toWorktreeRequestError(error);
+        }
+        try {
+            const recreatedWorkspacePath = mapWorkspaceCwdToWorktree({
+                sourceWorktreePath: previousWorktreePath,
+                workspaceCwd: workspace.cwd,
+                targetWorktreePath: recreatedWorktreePath,
+            });
+            if (!createRealpathAwarePathMatcher(workspace.cwd)(recreatedWorkspacePath)) {
+                throw new WorktreeRequestError({
+                    code: "unknown",
+                    message: `Recreated worktree diverged from ${workspace.cwd}: ${recreatedWorkspacePath}`,
+                });
+            }
+            if (!(await deps.isDirectory(recreatedWorkspacePath))) {
+                throw new WorktreeRequestError({
+                    code: "unknown",
+                    message: `Selected project directory is missing from the restored worktree: ${recreatedWorkspacePath}`,
+                });
+            }
+        }
+        catch (error) {
+            return rollbackCreatedPaseoWorktree({
+                cwd: sourceRepoRoot,
+                worktreePath: recreatedWorktreePath,
+                teardownCwds: [],
+                paseoHome: deps.paseoHome,
+                worktreesBaseRoot: deps.worktreesRoot,
+            }, error);
+        }
+    }
+    return { inspect, restore };
+}
+function createRecoveryPlan(input) {
+    const state = {
+        kind: "recoverable",
+        workspaceId: input.workspace.workspaceId,
+        workspaceName: resolveWorkspaceDisplayName(input.workspace),
+        branch: input.workspace.branch,
+    };
+    if (input.action === "restore") {
+        return {
+            kind: input.action,
+            state: { ...state, action: input.action },
+            workspace: input.workspace,
+            sourceRepoRoot: input.sourceRepoRoot,
+        };
+    }
+    return {
+        kind: input.action,
+        state: {
+            ...state,
+            action: input.action,
+        },
+        workspace: input.workspace,
+    };
+}
+//# sourceMappingURL=workspace-recovery-service.js.map

package/dist/server/server/session/workspace-scripts/workspace-scripts-service.d.ts

@@ -0,0 +1,54 @@
+import type pino from "pino";
+import type { SessionOutboundMessage, StartWorkspaceScriptRequest, WorkspaceDescriptorPayload, WorkspaceScriptPayload } from "../../messages.js";
+import type { TerminalManager } from "../../../terminal/terminal-manager.js";
+import type { ServiceProxySubsystem } from "../../service-proxy.js";
+import type { WorkspaceScriptRuntimeStore } from "../../workspace-script-runtime-store.js";
+import type { ScriptHealthState } from "../../script-health-monitor.js";
+import type { WorkspaceGitService } from "../../workspace-git-service.js";
+import type { PersistedProjectRecord, PersistedWorkspaceRecord, ProjectRegistry, WorkspaceRegistry } from "../../workspace-registry.js";
+import type { SpawnWorkspaceScriptOptions, WorktreeScriptResult } from "../../worktree-bootstrap.js";
+import type { PaseoServicePortAllocation } from "@camerontaylor/paseo-protocol/paseo-config-schema";
+type WorkspaceScriptsPayload = WorkspaceDescriptorPayload["scripts"];
+/**
+ * The service-proxy-backed scripts a workspace exposes: build the scripts payload
+ * snapshot, emit a script_status_update to clients, and start a script.
+ *
+ * The workspace descriptor builder, the script-status emission path, and the
+ * start-script RPC all funnel through one assembly of buildWorkspaceScriptPayloads'
+ * inputs and one "scripts available on this daemon?" guard, instead of duplicating
+ * that assembly and guard across the session.
+ */
+export interface WorkspaceScriptsService {
+    buildSnapshot(workspace: PersistedWorkspaceRecord, project?: PersistedProjectRecord | null): WorkspaceScriptsPayload;
+    emitStatusUpdate(workspaceId: string, workspaceDirectory: string): Promise<void>;
+    list(workspaceId: string): Promise<WorkspaceScriptPayload[]>;
+    launch(input: {
+        workspaceId: string;
+        scriptName: string;
+    }): Promise<WorkspaceScriptPayload>;
+    stop(input: {
+        workspaceId: string;
+        scriptName: string;
+    }): Promise<WorkspaceScriptPayload>;
+    start(request: StartWorkspaceScriptRequest): Promise<void>;
+}
+type WorkspaceScriptsGitSource = Pick<WorkspaceGitService, "peekSnapshot">;
+export declare function createWorkspaceScriptsService(deps: {
+    serviceProxy: ServiceProxySubsystem | null;
+    scriptRuntimeStore: WorkspaceScriptRuntimeStore | null;
+    terminalManager: TerminalManager | null;
+    workspaceRegistry: Pick<WorkspaceRegistry, "get">;
+    projectRegistry: Pick<ProjectRegistry, "get">;
+    workspaceGitService: WorkspaceScriptsGitSource;
+    getDaemonTcpPort: (() => number | null) | null;
+    getDaemonTcpHost: (() => string | null) | null;
+    serviceProxyPublicBaseUrl: string | null;
+    resolveScriptHealth: ((hostname: string) => ScriptHealthState | null) | null;
+    globalServicePorts?: PaseoServicePortAllocation;
+    logger: pino.Logger;
+    emit: (message: SessionOutboundMessage) => void;
+    spawnWorkspaceScript: (options: SpawnWorkspaceScriptOptions) => Promise<WorktreeScriptResult>;
+    assertAutomationAllowed: (workspaceId: string) => Promise<void>;
+}): WorkspaceScriptsService;
+export {};
+//# sourceMappingURL=workspace-scripts-service.d.ts.map