@getpaseo/server 0.1.100 → 0.1.102-beta.2

package/dist/server/server/session/git-mutation/git-mutation-service.js

@@ -0,0 +1,71 @@
+import { getErrorMessage } from "@getpaseo/protocol/error-utils";
+import { checkoutResolvedBranch, } from "../../../utils/checkout-git.js";
+import { execCommand } from "../../../utils/spawn.js";
+import { assertSafeGitRef as assertWorktreeSafeGitRef } from "../../worktree-session.js";
+export function createGitMutationService(deps) {
+    const { workspaceGitService, github, logger } = deps;
+    function assertSafeGitRef(ref, label) {
+        if (!/^[A-Za-z0-9._/-]+$/.test(ref)) {
+            throw new Error(`Invalid ${label}: ${ref}`);
+        }
+        assertWorktreeSafeGitRef(ref, label);
+    }
+    async function isWorkingTreeDirty(cwd) {
+        try {
+            const snapshot = await workspaceGitService.getSnapshot(cwd);
+            return snapshot.git.isDirty === true;
+        }
+        catch (error) {
+            throw new Error(`Unable to inspect git status for ${cwd}: ${getErrorMessage(error)}`, {
+                cause: error,
+            });
+        }
+    }
+    async function ensureCleanWorkingTree(cwd) {
+        const dirty = await isWorkingTreeDirty(cwd);
+        if (dirty) {
+            throw new Error("Working directory has uncommitted changes. Commit or stash before switching branches.");
+        }
+    }
+    async function notifyGitMutation(cwd, reason, options) {
+        if (options?.invalidateGithub) {
+            github.invalidate({ cwd });
+        }
+        try {
+            await workspaceGitService.getSnapshot(cwd, { force: true, reason });
+        }
+        catch (error) {
+            logger.warn({ err: error, cwd, reason }, "Failed to force-refresh workspace git snapshot after mutation");
+        }
+    }
+    return {
+        async checkoutExistingBranch(cwd, branch) {
+            assertSafeGitRef(branch, "branch");
+            const resolution = await workspaceGitService.validateBranchRef(cwd, branch);
+            if (resolution.kind === "not-found") {
+                throw new Error(`Branch not found: ${branch}`);
+            }
+            await ensureCleanWorkingTree(cwd);
+            const result = await checkoutResolvedBranch({ cwd, resolution });
+            await notifyGitMutation(cwd, "switch-branch", { invalidateGithub: true });
+            return result;
+        },
+        async createBranchFromBase({ cwd, baseBranch, newBranchName }) {
+            assertSafeGitRef(baseBranch, "base branch");
+            assertSafeGitRef(newBranchName, "new branch");
+            const baseResolution = await workspaceGitService.validateBranchRef(cwd, baseBranch);
+            if (baseResolution.kind === "not-found") {
+                throw new Error(`Base branch not found: ${baseBranch}`);
+            }
+            const exists = await workspaceGitService.hasLocalBranch(cwd, newBranchName);
+            if (exists) {
+                throw new Error(`Branch already exists: ${newBranchName}`);
+            }
+            await ensureCleanWorkingTree(cwd);
+            await execCommand("git", ["checkout", "-b", newBranchName, baseBranch], { cwd });
+            await notifyGitMutation(cwd, "create-branch");
+        },
+        notifyGitMutation,
+    };
+}
+//# sourceMappingURL=git-mutation-service.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/workspace-git-observer/workspace-git-observer-service.d.ts

@@ -0,0 +1,36 @@
+import type pino from "pino";
+import type { WorkspaceDescriptorPayload } from "../../messages.js";
+import type { WorkspaceGitRuntimeSnapshot, WorkspaceGitService } from "../../workspace-git-service.js";
+import type { PersistedWorkspaceRecord } from "../../workspace-registry.js";
+/**
+ * Observes a workspace's git state on disk (via WorkspaceGitService) and drives the
+ * live update fan-out: branch-change notifications, workspace-card refreshes, and
+ * checkout status updates. It owns the per-cwd watch targets and the WorkspaceGitService
+ * subscription handles, so the registration / dedupe / teardown lifecycle lives in one
+ * module instead of being smeared across the client session.
+ *
+ * Branch changes reach `onBranchChanged` from two paths that share `lastBranchName`: the
+ * on-disk snapshot listener (handleBranchSnapshot) and the workspace-emit loop
+ * (recordDescriptorState). Both stay inside this module so the shared state is coherent.
+ */
+export interface WorkspaceGitObserverService {
+    syncObservers(workspaces: Iterable<WorkspaceDescriptorPayload>): void;
+    syncObserverForWorkspace(workspace: PersistedWorkspaceRecord): Promise<void>;
+    warmGitData(workspace: PersistedWorkspaceRecord): Promise<void>;
+    shouldSkipUpdate(workspaceId: string, workspace: WorkspaceDescriptorPayload | null): boolean;
+    recordDescriptorState(workspaceId: string, workspace: WorkspaceDescriptorPayload | null): void;
+    handleBranchSnapshot(cwd: string, branchName: string | null): void;
+    removeForWorkspaceId(workspaceId: string): void;
+    removeForCwd(cwd: string): void;
+    dispose(): void;
+}
+export declare function createWorkspaceGitObserverService(deps: {
+    workspaceGitService: Pick<WorkspaceGitService, "registerWorkspace">;
+    describeWorkspaceRecordWithGitData: (workspace: PersistedWorkspaceRecord) => Promise<WorkspaceDescriptorPayload>;
+    emitWorkspaceUpdateForCwd: (cwd: string) => Promise<void>;
+    emitWorkspaceUpdateForWorkspaceId: (workspaceId: string) => Promise<void>;
+    emitStatusUpdate: (cwd: string, snapshot: WorkspaceGitRuntimeSnapshot) => void;
+    onBranchChanged?: (workspaceId: string, oldBranch: string | null, newBranch: string | null) => void;
+    logger: pino.Logger;
+}): WorkspaceGitObserverService;
+//# sourceMappingURL=workspace-git-observer-service.d.ts.map

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

@@ -0,0 +1,134 @@
+import { resolve } from "node:path";
+const WORKSPACE_GIT_WATCH_REMOVED_STATE_KEY = "__removed__";
+export function createWorkspaceGitObserverService(deps) {
+    const { workspaceGitService, describeWorkspaceRecordWithGitData, emitWorkspaceUpdateForCwd, emitWorkspaceUpdateForWorkspaceId, emitStatusUpdate, onBranchChanged, logger, } = deps;
+    const watchTargets = new Map();
+    const subscriptions = new Map();
+    function descriptorStateKey(workspace) {
+        if (!workspace) {
+            return WORKSPACE_GIT_WATCH_REMOVED_STATE_KEY;
+        }
+        return JSON.stringify([
+            workspace.name,
+            workspace.diffStat ? [workspace.diffStat.additions, workspace.diffStat.deletions] : null,
+        ]);
+    }
+    function resolveTargetByWorkspaceId(workspaceId) {
+        for (const target of watchTargets.values()) {
+            if (target.workspaceId === workspaceId) {
+                return target;
+            }
+        }
+        return null;
+    }
+    function rememberDescriptorState(workspaceId, workspace) {
+        const target = resolveTargetByWorkspaceId(workspaceId);
+        if (!target) {
+            return;
+        }
+        target.latestDescriptorStateKey = descriptorStateKey(workspace);
+        target.lastBranchName = workspace?.name ?? null;
+    }
+    function removeForCwd(cwd) {
+        const normalizedCwd = resolve(cwd);
+        watchTargets.delete(normalizedCwd);
+        subscriptions.get(normalizedCwd)?.();
+        subscriptions.delete(normalizedCwd);
+    }
+    function handleBranchSnapshot(cwd, branchName) {
+        const target = watchTargets.get(resolve(cwd));
+        if (!target) {
+            return;
+        }
+        const previousBranchName = target.lastBranchName;
+        if (branchName === previousBranchName) {
+            return;
+        }
+        target.lastBranchName = branchName;
+        onBranchChanged?.(target.workspaceId, previousBranchName, branchName);
+    }
+    function syncObserver(cwd, options) {
+        const normalizedCwd = resolve(cwd);
+        if (!options.isGit) {
+            removeForCwd(normalizedCwd);
+            return;
+        }
+        if (subscriptions.has(normalizedCwd)) {
+            return;
+        }
+        const target = {
+            cwd: normalizedCwd,
+            workspaceId: options.workspaceId,
+            latestDescriptorStateKey: null,
+            lastBranchName: null,
+        };
+        watchTargets.set(normalizedCwd, target);
+        const subscription = workspaceGitService.registerWorkspace({ cwd: normalizedCwd }, (snapshot) => {
+            handleBranchSnapshot(normalizedCwd, snapshot.git.currentBranch ?? null);
+            void emitWorkspaceUpdateForCwd(normalizedCwd).catch((error) => {
+                logger.warn({ err: error, cwd: normalizedCwd }, "Failed to emit workspace update after git branch snapshot");
+            });
+            emitStatusUpdate(normalizedCwd, snapshot);
+        });
+        subscriptions.set(normalizedCwd, subscription.unsubscribe);
+    }
+    function syncObservers(workspaces) {
+        for (const workspace of workspaces) {
+            syncObserver(workspace.workspaceDirectory, {
+                isGit: workspace.projectKind === "git",
+                workspaceId: workspace.id,
+            });
+            rememberDescriptorState(workspace.workspaceDirectory, workspace);
+        }
+    }
+    async function syncObserverForWorkspace(workspace) {
+        const descriptor = await describeWorkspaceRecordWithGitData(workspace);
+        syncObservers([descriptor]);
+    }
+    return {
+        syncObservers,
+        syncObserverForWorkspace,
+        async warmGitData(workspace) {
+            await syncObserverForWorkspace(workspace);
+            await emitWorkspaceUpdateForWorkspaceId(workspace.workspaceId);
+        },
+        shouldSkipUpdate(workspaceId, workspace) {
+            const target = resolveTargetByWorkspaceId(workspaceId);
+            if (!target) {
+                return false;
+            }
+            const nextStateKey = descriptorStateKey(workspace);
+            if (target.latestDescriptorStateKey === nextStateKey) {
+                return true;
+            }
+            target.latestDescriptorStateKey = nextStateKey;
+            return false;
+        },
+        recordDescriptorState(workspaceId, nextWorkspace) {
+            const target = resolveTargetByWorkspaceId(workspaceId);
+            if (target && onBranchChanged) {
+                const newBranchName = nextWorkspace?.name ?? null;
+                if (newBranchName !== target.lastBranchName) {
+                    onBranchChanged(workspaceId, target.lastBranchName, newBranchName);
+                }
+            }
+            rememberDescriptorState(workspaceId, nextWorkspace);
+        },
+        handleBranchSnapshot,
+        removeForWorkspaceId(workspaceId) {
+            const target = resolveTargetByWorkspaceId(workspaceId);
+            if (target) {
+                removeForCwd(target.cwd);
+            }
+        },
+        removeForCwd,
+        dispose() {
+            for (const unsubscribe of subscriptions.values()) {
+                unsubscribe();
+            }
+            subscriptions.clear();
+            watchTargets.clear();
+        },
+    };
+}
+//# sourceMappingURL=workspace-git-observer-service.js.map

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

@@ -0,0 +1,34 @@
+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";
+/**
+ * Resolves which workspace and project records a directory belongs to, creating,
+ * reclassifying, or unarchiving them as needed. Every path that needs a workspace
+ * for a cwd — opening a project, importing an agent, creating an agent, restoring
+ * an archived worktree — funnels through this one module, so the
+ * classify → resolve-project → persist → unarchive sequence (and the
+ * archived-reopen-at-a-different-path and reclassify-vs-unarchive special cases)
+ * lives in a single place instead of being smeared across the session.
+ *
+ * Read-only path resolution (no create/persist) lives in resolve-workspace-id-for-path.ts;
+ * this module owns the create-and-persist side.
+ */
+export interface ResolveOrCreateWorkspaceIdInput {
+    createdWorktree: CreatePaseoWorktreeWorkflowResult | null;
+    requestedWorkspaceId?: string;
+    cwd: string;
+    initialTitle: string | null;
+}
+export interface WorkspaceProvisioningService {
+    findOrCreateWorkspaceForDirectory(cwd: string): Promise<PersistedWorkspaceRecord>;
+    resolveOrCreateWorkspaceIdForCreateAgent(input: ResolveOrCreateWorkspaceIdInput): Promise<string>;
+    createWorkspaceForDirectory(cwd: string, title?: string | null): Promise<PersistedWorkspaceRecord>;
+    findOrCreateProjectForDirectory(cwd: string): Promise<PersistedProjectRecord>;
+    ensureWorkspaceRecordUnarchived(workspace: PersistedWorkspaceRecord): Promise<PersistedWorkspaceRecord>;
+}
+export declare function createWorkspaceProvisioningService(deps: {
+    workspaceRegistry: WorkspaceRegistry;
+    projectRegistry: ProjectRegistry;
+    workspaceGitService: Pick<WorkspaceGitService, "getCheckout" | "peekSnapshot">;
+}): WorkspaceProvisioningService;
+//# sourceMappingURL=workspace-provisioning-service.d.ts.map

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

@@ -0,0 +1,190 @@
+import { resolve } from "node:path";
+import { checkoutLiteFromGitSnapshot, classifyDirectoryForProjectMembership, generateWorkspaceId, } from "../../workspace-registry-model.js";
+import { createPersistedProjectRecord, createPersistedWorkspaceRecord, } from "../../workspace-registry.js";
+export function createWorkspaceProvisioningService(deps) {
+    const { workspaceRegistry, projectRegistry, workspaceGitService } = deps;
+    async function resolveWorkspaceDirectory(cwd, options) {
+        const normalizedCwd = resolve(cwd);
+        if (options?.refreshGit === false) {
+            const snapshot = workspaceGitService.peekSnapshot(normalizedCwd);
+            return resolve(snapshot?.git.repoRoot ?? normalizedCwd);
+        }
+        const checkout = await workspaceGitService.getCheckout(normalizedCwd);
+        return resolve(checkout.worktreeRoot ?? normalizedCwd);
+    }
+    async function findExactWorkspaceByDirectory(cwd, options) {
+        const normalizedCwd = await resolveWorkspaceDirectory(cwd, options);
+        const workspaces = await workspaceRegistry.list();
+        return workspaces.find((workspace) => workspace.cwd === normalizedCwd) ?? null;
+    }
+    async function resolveProjectRecordForPlacement(input) {
+        const rootPath = input.membership.projectRootPath;
+        const kind = input.membership.projectKind;
+        const projects = await projectRegistry.list();
+        const existingProject = projects.find((project) => !project.archivedAt && project.rootPath === rootPath) ??
+            projects.find((project) => project.rootPath === rootPath) ??
+            null;
+        if (!existingProject) {
+            return createPersistedProjectRecord({
+                projectId: input.membership.projectKey,
+                rootPath,
+                kind,
+                displayName: input.membership.projectName,
+                createdAt: input.timestamp,
+                updatedAt: input.timestamp,
+            });
+        }
+        return {
+            ...existingProject,
+            rootPath,
+            kind,
+            archivedAt: null,
+            updatedAt: input.timestamp,
+        };
+    }
+    async function reclassifyOrUnarchiveWorkspaceForDirectory(input) {
+        const checkout = await workspaceGitService.getCheckout(input.cwd);
+        const membership = classifyDirectoryForProjectMembership({ cwd: input.cwd, checkout });
+        const timestamp = new Date().toISOString();
+        const projectRecord = await resolveProjectRecordForPlacement({
+            membership,
+            timestamp,
+        });
+        const projectId = projectRecord.projectId;
+        const kind = membership.workspaceKind;
+        const displayName = membership.workspaceDisplayName;
+        if (input.workspace.projectId === projectId &&
+            input.workspace.kind === kind &&
+            input.workspace.displayName === displayName) {
+            if (!input.project) {
+                await projectRegistry.upsert(projectRecord);
+            }
+            return ensureWorkspaceRecordUnarchived(input.workspace);
+        }
+        await projectRegistry.upsert(projectRecord);
+        const nextWorkspace = {
+            ...input.workspace,
+            projectId,
+            cwd: input.cwd,
+            kind,
+            displayName,
+            archivedAt: null,
+            updatedAt: timestamp,
+        };
+        await workspaceRegistry.upsert(nextWorkspace);
+        return nextWorkspace;
+    }
+    async function findOrCreateWorkspaceForDirectory(cwd) {
+        const inputCwd = resolve(cwd);
+        const normalizedCwd = await resolveWorkspaceDirectory(cwd);
+        const existingWorkspace = await findExactWorkspaceByDirectory(normalizedCwd, {
+            refreshGit: false,
+        });
+        if (existingWorkspace) {
+            if (existingWorkspace.archivedAt && inputCwd !== normalizedCwd) {
+                const timestamp = new Date().toISOString();
+                const checkout = checkoutLiteFromGitSnapshot(inputCwd, {
+                    isGit: false,
+                    currentBranch: null,
+                    remoteUrl: null,
+                    repoRoot: null,
+                    isPaseoOwnedWorktree: false,
+                    mainRepoRoot: null,
+                });
+                const membership = classifyDirectoryForProjectMembership({ cwd: inputCwd, checkout });
+                const projectRecord = await resolveProjectRecordForPlacement({
+                    membership,
+                    timestamp,
+                });
+                await projectRegistry.upsert(projectRecord);
+                const workspaceRecord = createPersistedWorkspaceRecord({
+                    workspaceId: generateWorkspaceId(),
+                    projectId: projectRecord.projectId,
+                    cwd: inputCwd,
+                    kind: membership.workspaceKind,
+                    displayName: membership.workspaceDisplayName,
+                    createdAt: timestamp,
+                    updatedAt: timestamp,
+                });
+                await workspaceRegistry.upsert(workspaceRecord);
+                return workspaceRecord;
+            }
+            return reclassifyOrUnarchiveWorkspaceForDirectory({
+                workspace: existingWorkspace,
+                project: await projectRegistry.get(existingWorkspace.projectId),
+                cwd: normalizedCwd,
+            });
+        }
+        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)).workspaceId;
+    }
+    async function createWorkspaceForDirectory(cwd, title) {
+        const checkout = await workspaceGitService.getCheckout(cwd);
+        const membership = classifyDirectoryForProjectMembership({ cwd, checkout });
+        const timestamp = new Date().toISOString();
+        const projectRecord = await resolveProjectRecordForPlacement({
+            membership,
+            timestamp,
+        });
+        await projectRegistry.upsert(projectRecord);
+        const workspaceRecord = createPersistedWorkspaceRecord({
+            workspaceId: generateWorkspaceId(),
+            projectId: projectRecord.projectId,
+            cwd,
+            kind: membership.workspaceKind,
+            displayName: membership.workspaceDisplayName,
+            title: title ?? null,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        });
+        await workspaceRegistry.upsert(workspaceRecord);
+        return workspaceRecord;
+    }
+    async function findOrCreateProjectForDirectory(cwd) {
+        const normalizedCwd = resolve(cwd);
+        const checkout = await workspaceGitService.getCheckout(normalizedCwd);
+        const membership = classifyDirectoryForProjectMembership({ cwd: normalizedCwd, checkout });
+        const projectRecord = await resolveProjectRecordForPlacement({
+            membership,
+            timestamp: new Date().toISOString(),
+        });
+        await projectRegistry.upsert(projectRecord);
+        return projectRecord;
+    }
+    async function ensureWorkspaceRecordUnarchived(workspace) {
+        const project = await projectRegistry.get(workspace.projectId);
+        if (!workspace.archivedAt && (!project || !project.archivedAt)) {
+            return workspace;
+        }
+        const timestamp = new Date().toISOString();
+        let unarchivedWorkspace = workspace;
+        if (workspace.archivedAt) {
+            unarchivedWorkspace = { ...workspace, archivedAt: null, updatedAt: timestamp };
+            await workspaceRegistry.upsert(unarchivedWorkspace);
+        }
+        if (project?.archivedAt) {
+            await projectRegistry.upsert({
+                ...project,
+                archivedAt: null,
+                updatedAt: timestamp,
+            });
+        }
+        return unarchivedWorkspace;
+    }
+    return {
+        findOrCreateWorkspaceForDirectory,
+        resolveOrCreateWorkspaceIdForCreateAgent,
+        createWorkspaceForDirectory,
+        findOrCreateProjectForDirectory,
+        ensureWorkspaceRecordUnarchived,
+    };
+}
+//# sourceMappingURL=workspace-provisioning-service.js.map

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

@@ -0,0 +1,41 @@
+import type pino from "pino";
+import type { SessionOutboundMessage, StartWorkspaceScriptRequest, WorkspaceDescriptorPayload } 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 { WorkspaceRegistry } from "../../workspace-registry.js";
+import type { SpawnWorkspaceScriptOptions, WorktreeScriptResult } from "../../worktree-bootstrap.js";
+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(workspaceId: string, workspaceDirectory: string): WorkspaceScriptsPayload;
+    emitStatusUpdate(workspaceId: string, workspaceDirectory: string): void;
+    start(request: StartWorkspaceScriptRequest): Promise<void>;
+}
+type WorkspaceScriptsGitSource = Pick<WorkspaceGitService, "peekSnapshot" | "getWorkspaceGitMetadata">;
+export declare function createWorkspaceScriptsService(deps: {
+    serviceProxy: ServiceProxySubsystem | null;
+    scriptRuntimeStore: WorkspaceScriptRuntimeStore | null;
+    terminalManager: TerminalManager | null;
+    workspaceRegistry: Pick<WorkspaceRegistry, "get">;
+    workspaceGitService: WorkspaceScriptsGitSource;
+    getDaemonTcpPort: (() => number | null) | null;
+    getDaemonTcpHost: (() => string | null) | null;
+    serviceProxyPublicBaseUrl: string | null;
+    resolveScriptHealth: ((hostname: string) => ScriptHealthState | null) | null;
+    logger: pino.Logger;
+    emit: (message: SessionOutboundMessage) => void;
+    spawnWorkspaceScript: (options: SpawnWorkspaceScriptOptions) => Promise<WorktreeScriptResult>;
+}): WorkspaceScriptsService;
+export {};
+//# sourceMappingURL=workspace-scripts-service.d.ts.map

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

@@ -0,0 +1,100 @@
+import { buildWorkspaceScriptPayloads, readPaseoConfigForProjection, } from "../../script-status-projection.js";
+import { deriveProjectSlug } from "../../workspace-git-metadata.js";
+export function createWorkspaceScriptsService(deps) {
+    const { serviceProxy, scriptRuntimeStore, terminalManager, workspaceRegistry, workspaceGitService, getDaemonTcpPort, getDaemonTcpHost, serviceProxyPublicBaseUrl, resolveScriptHealth, logger, emit, spawnWorkspaceScript, } = deps;
+    function resolveGitMetadata(workspaceDirectory) {
+        const snapshot = workspaceGitService.peekSnapshot(workspaceDirectory);
+        if (!snapshot) {
+            return undefined;
+        }
+        return {
+            projectSlug: deriveProjectSlug(workspaceDirectory, snapshot.git.isGit ? snapshot.git.remoteUrl : null),
+            currentBranch: snapshot.git.currentBranch,
+        };
+    }
+    function buildSnapshot(workspaceId, workspaceDirectory) {
+        if (!serviceProxy || !scriptRuntimeStore) {
+            return [];
+        }
+        return buildWorkspaceScriptPayloads({
+            workspaceId,
+            workspaceDirectory,
+            paseoConfig: readPaseoConfigForProjection(workspaceDirectory, logger),
+            serviceProxy,
+            runtimeStore: scriptRuntimeStore,
+            daemonPort: getDaemonTcpPort?.() ?? null,
+            serviceProxyPublicBaseUrl,
+            gitMetadata: resolveGitMetadata(workspaceDirectory),
+            resolveHealth: resolveScriptHealth ?? undefined,
+        });
+    }
+    function emitStatusUpdate(workspaceId, workspaceDirectory) {
+        emit({
+            type: "script_status_update",
+            payload: {
+                workspaceId,
+                scripts: buildSnapshot(workspaceId, workspaceDirectory),
+            },
+        });
+    }
+    async function start(request) {
+        try {
+            if (!terminalManager || !serviceProxy || !scriptRuntimeStore) {
+                throw new Error("Workspace scripts are not available on this daemon");
+            }
+            const workspace = await workspaceRegistry.get(request.workspaceId);
+            if (!workspace) {
+                throw new Error(`Workspace not found: ${request.workspaceId}`);
+            }
+            const gitMetadata = await workspaceGitService.getWorkspaceGitMetadata(workspace.cwd);
+            const serviceResult = await spawnWorkspaceScript({
+                repoRoot: workspace.cwd,
+                workspaceId: workspace.workspaceId,
+                projectSlug: gitMetadata.projectSlug,
+                branchName: gitMetadata.currentBranch,
+                scriptName: request.scriptName,
+                daemonPort: getDaemonTcpPort?.() ?? null,
+                daemonListenHost: getDaemonTcpHost?.() ?? null,
+                serviceProxyPublicBaseUrl,
+                serviceProxy,
+                runtimeStore: scriptRuntimeStore,
+                terminalManager,
+                logger,
+                onLifecycleChanged: () => {
+                    emitStatusUpdate(workspace.workspaceId, workspace.cwd);
+                },
+            });
+            emitStatusUpdate(workspace.workspaceId, workspace.cwd);
+            emit({
+                type: "start_workspace_script_response",
+                payload: {
+                    requestId: request.requestId,
+                    workspaceId: request.workspaceId,
+                    scriptName: request.scriptName,
+                    terminalId: serviceResult.terminalId,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Failed to start workspace script";
+            logger.error({
+                err: error,
+                workspaceId: request.workspaceId,
+                scriptName: request.scriptName,
+            }, "Failed to start workspace script");
+            emit({
+                type: "start_workspace_script_response",
+                payload: {
+                    requestId: request.requestId,
+                    workspaceId: request.workspaceId,
+                    scriptName: request.scriptName,
+                    terminalId: null,
+                    error: message,
+                },
+            });
+        }
+    }
+    return { buildSnapshot, emitStatusUpdate, start };
+}
+//# sourceMappingURL=workspace-scripts-service.js.map