@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/session/files/workspace-files-session.js

@@ -0,0 +1,359 @@
+import { getErrorMessage } from "@camerontaylor/paseo-protocol/error-utils";
+import { encodeFileTransferFrame, FileTransferOpcode, } from "@camerontaylor/paseo-protocol/binary-frames/index";
+import { FileUploadStore } from "../../file-upload/index.js";
+import { createExplorerEntry, deleteExplorerEntry, duplicateExplorerEntry, getDownloadableFileInfo, listDirectoryEntries, readExplorerFile, renameExplorerEntry, streamExplorerFile, writeExplorerFile, } from "../../file-explorer/service.js";
+import { workspaceFileObserver } from "../../file-explorer/observer.js";
+import { getProjectIcon } from "../../../utils/project-icon.js";
+/**
+ * A client's workspace file-access surface: browsing directories, reading file
+ * contents (inline JSON or binary frames), receiving uploads, issuing download
+ * tokens, and reading project icons. It owns the upload store and reaches no
+ * workspace-git, registry, or subscription state — file I/O scoped to a cwd is
+ * the whole concern.
+ */
+export class WorkspaceFilesSession {
+    constructor(options) {
+        this.fileSubscriptions = new Map();
+        this.host = options.host;
+        this.downloadTokenStore = options.downloadTokenStore;
+        this.logger = options.logger;
+        this.fileUploads = new FileUploadStore({ paseoHome: options.paseoHome });
+        this.fileObserver = options.fileObserver ?? workspaceFileObserver;
+    }
+    async handleFileSubscribeRequest(request) {
+        this.fileSubscriptions.get(request.subscriptionId)?.();
+        try {
+            const subscription = await this.fileObserver.subscribe({ cwd: request.cwd, path: request.path }, (version) => {
+                this.host.emit({
+                    type: "fs.file.update",
+                    payload: { subscriptionId: request.subscriptionId, version },
+                });
+            });
+            this.fileSubscriptions.set(request.subscriptionId, subscription.unsubscribe);
+            this.host.emit({
+                type: "fs.file.subscribe.response",
+                payload: {
+                    subscriptionId: request.subscriptionId,
+                    initial: subscription.initial,
+                    requestId: request.requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "fs.file.subscribe.response",
+                payload: {
+                    subscriptionId: request.subscriptionId,
+                    initial: {
+                        status: "error",
+                        cwd: request.cwd,
+                        path: request.path,
+                        error: getErrorMessage(error),
+                    },
+                    requestId: request.requestId,
+                },
+            });
+        }
+    }
+    handleFileUnsubscribeRequest(request) {
+        this.fileSubscriptions.get(request.subscriptionId)?.();
+        this.fileSubscriptions.delete(request.subscriptionId);
+        this.host.emit({
+            type: "fs.file.unsubscribe.response",
+            payload: { subscriptionId: request.subscriptionId, requestId: request.requestId },
+        });
+    }
+    async handleFileWriteRequest(request) {
+        const result = await writeExplorerFile({
+            root: request.cwd,
+            relativePath: request.path,
+            content: request.content,
+            expectedModifiedAt: request.expectedModifiedAt,
+            expectedRevision: request.expectedRevision,
+        });
+        this.host.emit({
+            type: "fs.file.write.response",
+            payload: { result, requestId: request.requestId },
+        });
+    }
+    async handleFileEntryCreateRequest(request) {
+        const result = await createExplorerEntry({
+            root: request.cwd,
+            parentPath: request.parentPath,
+            name: request.name,
+            kind: request.kind,
+        });
+        this.host.emit({
+            type: "fs.entry.create.response",
+            payload: {
+                cwd: request.cwd,
+                parentPath: request.parentPath,
+                path: result.status === "ok" ? result.path : null,
+                success: result.status === "ok",
+                error: result.status === "ok" ? null : result.error,
+                requestId: request.requestId,
+            },
+        });
+    }
+    async handleFileEntryRenameRequest(request) {
+        const result = await renameExplorerEntry({
+            root: request.cwd,
+            relativePath: request.path,
+            name: request.name,
+        });
+        this.host.emit({
+            type: "fs.entry.rename.response",
+            payload: {
+                cwd: request.cwd,
+                path: request.path,
+                renamedPath: result.status === "ok" ? result.path : null,
+                success: result.status === "ok",
+                error: result.status === "ok" ? null : result.error,
+                requestId: request.requestId,
+            },
+        });
+    }
+    async handleFileEntryDuplicateRequest(request) {
+        const result = await duplicateExplorerEntry({
+            root: request.cwd,
+            relativePath: request.path,
+        });
+        this.host.emit({
+            type: "fs.entry.duplicate.response",
+            payload: {
+                cwd: request.cwd,
+                path: request.path,
+                duplicatedPath: result.status === "ok" ? result.path : null,
+                success: result.status === "ok",
+                error: result.status === "ok" ? null : result.error,
+                requestId: request.requestId,
+            },
+        });
+    }
+    async handleFileEntryDeleteRequest(request) {
+        const result = await deleteExplorerEntry({
+            root: request.cwd,
+            relativePath: request.path,
+        });
+        this.host.emit({
+            type: "fs.entry.delete.response",
+            payload: {
+                cwd: request.cwd,
+                path: request.path,
+                success: result.status === "ok",
+                error: result.status === "ok" ? null : result.error,
+                requestId: request.requestId,
+            },
+        });
+    }
+    dispose() {
+        for (const unsubscribe of this.fileSubscriptions.values())
+            unsubscribe();
+        this.fileSubscriptions.clear();
+    }
+    async handleFileExplorerRequest(request, source) {
+        const { cwd: workspaceCwd, path: requestedPath = ".", mode, requestId } = request;
+        const cwd = workspaceCwd.trim();
+        if (!cwd) {
+            this.host.emit({
+                type: "file_explorer_response",
+                payload: {
+                    cwd: workspaceCwd,
+                    path: requestedPath,
+                    mode,
+                    directory: null,
+                    file: null,
+                    error: "cwd is required",
+                    requestId,
+                },
+            }, source);
+            return;
+        }
+        try {
+            if (mode === "list") {
+                const directory = await listDirectoryEntries({
+                    root: cwd,
+                    relativePath: requestedPath,
+                });
+                this.host.emit({
+                    type: "file_explorer_response",
+                    payload: {
+                        cwd,
+                        path: directory.path,
+                        mode,
+                        directory,
+                        file: null,
+                        error: null,
+                        requestId,
+                    },
+                }, source);
+            }
+            else {
+                if (request.maxBytes) {
+                    const file = await getDownloadableFileInfo({ root: cwd, relativePath: requestedPath });
+                    if (file.size > request.maxBytes) {
+                        throw new Error("File is too large to display");
+                    }
+                }
+                if (request.acceptBinary && this.host.hasBinaryChannel()) {
+                    await streamExplorerFile({ root: cwd, relativePath: requestedPath }, async (file) => {
+                        await this.host.emitBinary(encodeFileTransferFrame({
+                            opcode: FileTransferOpcode.FileBegin,
+                            requestId,
+                            metadata: {
+                                mime: file.mimeType,
+                                size: file.size,
+                                encoding: file.encoding,
+                                modifiedAt: file.modifiedAt,
+                                revision: file.revision,
+                            },
+                        }), source);
+                        for await (const chunk of file.chunks) {
+                            await this.host.emitBinary(encodeFileTransferFrame({
+                                opcode: FileTransferOpcode.FileChunk,
+                                requestId,
+                                payload: chunk,
+                            }), source);
+                        }
+                        await this.host.emitBinary(encodeFileTransferFrame({
+                            opcode: FileTransferOpcode.FileEnd,
+                            requestId,
+                        }), source);
+                    });
+                }
+                else {
+                    const file = await readExplorerFile({
+                        root: cwd,
+                        relativePath: requestedPath,
+                    });
+                    this.host.emit({
+                        type: "file_explorer_response",
+                        payload: {
+                            cwd,
+                            path: file.path,
+                            mode,
+                            directory: null,
+                            file,
+                            error: null,
+                            requestId,
+                        },
+                    }, source);
+                }
+            }
+        }
+        catch (error) {
+            this.logger.error({ err: error, cwd, path: requestedPath }, `Failed to fulfill file explorer request for workspace ${cwd}`);
+            this.host.emit({
+                type: "file_explorer_response",
+                payload: {
+                    cwd,
+                    path: requestedPath,
+                    mode,
+                    directory: null,
+                    file: null,
+                    error: getErrorMessage(error),
+                    requestId,
+                },
+            }, source);
+        }
+    }
+    handleFileUploadRequest(request) {
+        this.fileUploads.beginUpload(request);
+    }
+    async handleFileTransferFrame(frame) {
+        const response = await this.fileUploads.receiveFrame(frame);
+        if (response) {
+            this.host.emit(response);
+        }
+    }
+    async handleProjectIconRequest(request) {
+        const { cwd, requestId } = request;
+        try {
+            const icon = await getProjectIcon(cwd);
+            this.host.emit({
+                type: "project_icon_response",
+                payload: {
+                    cwd,
+                    icon,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "project_icon_response",
+                payload: {
+                    cwd,
+                    icon: null,
+                    error: getErrorMessage(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async handleFileDownloadTokenRequest(request) {
+        const { cwd: workspaceCwd, path: requestedPath, requestId } = request;
+        const cwd = workspaceCwd.trim();
+        if (!cwd) {
+            this.host.emit({
+                type: "file_download_token_response",
+                payload: {
+                    cwd: workspaceCwd,
+                    path: requestedPath,
+                    token: null,
+                    fileName: null,
+                    mimeType: null,
+                    size: null,
+                    error: "cwd is required",
+                    requestId,
+                },
+            });
+            return;
+        }
+        this.logger.debug({ cwd, path: requestedPath }, `Handling file download token request for workspace ${cwd} (${requestedPath})`);
+        try {
+            const info = await getDownloadableFileInfo({
+                root: cwd,
+                relativePath: requestedPath,
+            });
+            const entry = this.downloadTokenStore.issueToken({
+                path: info.path,
+                absolutePath: info.absolutePath,
+                fileName: info.fileName,
+                mimeType: info.mimeType,
+                size: info.size,
+            });
+            this.host.emit({
+                type: "file_download_token_response",
+                payload: {
+                    cwd,
+                    path: info.path,
+                    token: entry.token,
+                    fileName: entry.fileName,
+                    mimeType: entry.mimeType,
+                    size: entry.size,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error, cwd, path: requestedPath }, `Failed to issue download token for workspace ${cwd}`);
+            this.host.emit({
+                type: "file_download_token_response",
+                payload: {
+                    cwd,
+                    path: requestedPath,
+                    token: null,
+                    fileName: null,
+                    mimeType: null,
+                    size: null,
+                    error: getErrorMessage(error),
+                    requestId,
+                },
+            });
+        }
+    }
+}
+//# sourceMappingURL=workspace-files-session.js.map

package/dist/server/server/session/git-mutation/git-mutation-service.d.ts

@@ -0,0 +1,32 @@
+import type pino from "pino";
+import { type CheckoutExistingBranchResult, type GitMutationRefreshReason } from "../../../utils/checkout-git.js";
+import type { WorkspaceGitService } from "../../workspace-git-service.js";
+/**
+ * The git branch / working-tree mutation primitives a client session performs on a
+ * workspace: switch to an existing branch, create a branch from a base, and force a
+ * snapshot refresh (plus optional forge cache invalidation) after any mutation.
+ *
+ * CheckoutSession (the branch/commit/merge commands), the worktree session-config
+ * builder, and the auto-naming + worktree-creation paths all funnel their git
+ * mutations through this one module, so the validate-ref → clean-tree → execute →
+ * refresh sequence lives in a single place instead of being smeared across the
+ * session as loose callbacks.
+ */
+export interface GitMutationService {
+    checkoutExistingBranch(cwd: string, branch: string): Promise<CheckoutExistingBranchResult>;
+    createBranchFromBase(params: {
+        cwd: string;
+        baseBranch: string;
+        newBranchName: string;
+    }): Promise<void>;
+    notifyGitMutation(cwd: string, reason: GitMutationRefreshReason, options?: {
+        invalidateForge?: boolean;
+    }): Promise<void>;
+}
+type GitMutationGitSource = Pick<WorkspaceGitService, "validateBranchRef" | "getSnapshot" | "hasLocalBranch" | "invalidateForge">;
+export declare function createGitMutationService(deps: {
+    workspaceGitService: GitMutationGitSource;
+    logger: pino.Logger;
+}): GitMutationService;
+export {};
+//# sourceMappingURL=git-mutation-service.d.ts.map

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

@@ -0,0 +1,74 @@
+import { getErrorMessage } from "@camerontaylor/paseo-protocol/error-utils";
+import { checkoutResolvedBranch, } from "../../../utils/checkout-git.js";
+import { runGitCommand } from "../../../utils/run-git-command.js";
+import { assertSafeGitRef as assertWorktreeSafeGitRef } from "../../worktree-session.js";
+export function createGitMutationService(deps) {
+    const { workspaceGitService, 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?.invalidateForge) {
+            workspaceGitService.invalidateForge(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", { invalidateForge: 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 runGitCommand(["checkout", "-b", newBranchName, baseBranch], {
+                cwd,
+                timeout: 120000,
+            });
+            await notifyGitMutation(cwd, "create-branch");
+        },
+        notifyGitMutation,
+    };
+}
+//# sourceMappingURL=git-mutation-service.js.map

package/dist/server/server/session/project-config/project-config-session.d.ts

@@ -0,0 +1,35 @@
+import type pino from "pino";
+import type { SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import type { ProjectRegistry } from "../../workspace-registry.js";
+export interface ProjectConfigSessionHost {
+    emit(msg: SessionOutboundMessage): void;
+}
+export interface ProjectConfigSessionOptions {
+    host: ProjectConfigSessionHost;
+    projectRegistry: Pick<ProjectRegistry, "list">;
+    logger: pino.Logger;
+}
+/**
+ * A client's read/write surface for a project's on-disk paseo.json. Resolves the
+ * request's repoRoot against the known (non-archived) project roots — accepting a
+ * trailing slash or a symlink via realpath — then reads or writes the config
+ * substrate and emits the matching response. Reaches no state beyond the injected
+ * project registry and the outbound channel.
+ */
+export declare class ProjectConfigSession {
+    private readonly host;
+    private readonly projectRegistry;
+    private readonly logger;
+    constructor(options: ProjectConfigSessionOptions);
+    handleReadProjectConfigRequest(msg: Extract<SessionInboundMessage, {
+        type: "read_project_config_request";
+    }>): Promise<void>;
+    handleWriteProjectConfigRequest(msg: Extract<SessionInboundMessage, {
+        type: "write_project_config_request";
+    }>): Promise<void>;
+    private readSetupCommitStatus;
+    private emitProjectConfigReadFailure;
+    private emitProjectConfigWriteFailure;
+    private resolveKnownProjectRoot;
+}
+//# sourceMappingURL=project-config-session.d.ts.map

package/dist/server/server/session/project-config/project-config-session.js

@@ -0,0 +1,143 @@
+import { realpathSync } from "node:fs";
+import { resolve, sep } from "path";
+import { readPaseoConfigForEdit, writePaseoConfigForEdit, } from "../../../utils/paseo-config-file.js";
+import { hasUncommittedWorktreeSetupChanges } from "./worktree-setup-commit-status.js";
+/**
+ * A client's read/write surface for a project's on-disk paseo.json. Resolves the
+ * request's repoRoot against the known (non-archived) project roots — accepting a
+ * trailing slash or a symlink via realpath — then reads or writes the config
+ * substrate and emits the matching response. Reaches no state beyond the injected
+ * project registry and the outbound channel.
+ */
+export class ProjectConfigSession {
+    constructor(options) {
+        this.host = options.host;
+        this.projectRegistry = options.projectRegistry;
+        this.logger = options.logger;
+    }
+    async handleReadProjectConfigRequest(msg) {
+        const repoRoot = await this.resolveKnownProjectRoot(msg.repoRoot);
+        if (!repoRoot) {
+            this.emitProjectConfigReadFailure(msg, { code: "project_not_found" });
+            return;
+        }
+        const result = readPaseoConfigForEdit(repoRoot);
+        if (!result.ok) {
+            this.logger.warn({ repoRoot, requestId: msg.requestId, outcome: result.error.code }, "Failed to read project config");
+            this.emitProjectConfigReadFailure(msg, result.error, repoRoot);
+            return;
+        }
+        if (result.config === null) {
+            this.logger.debug({ repoRoot, requestId: msg.requestId, outcome: "missing_project_config" }, "Project config missing");
+        }
+        const setupCommitStatus = await this.readSetupCommitStatus(repoRoot, result.config);
+        this.host.emit({
+            type: "read_project_config_response",
+            payload: {
+                requestId: msg.requestId,
+                repoRoot,
+                ok: true,
+                config: result.config,
+                revision: result.revision,
+                ...(setupCommitStatus === null
+                    ? {}
+                    : { hasUncommittedWorktreeSetupChanges: setupCommitStatus }),
+            },
+        });
+    }
+    async handleWriteProjectConfigRequest(msg) {
+        const repoRoot = await this.resolveKnownProjectRoot(msg.repoRoot);
+        if (!repoRoot) {
+            this.emitProjectConfigWriteFailure(msg, { code: "project_not_found" });
+            return;
+        }
+        this.logger.debug({ repoRoot, requestId: msg.requestId, outcome: "write_attempt" }, "Writing project config");
+        const result = writePaseoConfigForEdit({
+            repoRoot,
+            config: msg.config,
+            expectedRevision: msg.expectedRevision,
+        });
+        if (!result.ok) {
+            this.logger.debug({ repoRoot, requestId: msg.requestId, outcome: result.error.code }, "Project config write did not complete");
+            this.emitProjectConfigWriteFailure(msg, result.error, repoRoot);
+            return;
+        }
+        this.logger.debug({ repoRoot, requestId: msg.requestId, outcome: "written" }, "Project config written");
+        const setupCommitStatus = await this.readSetupCommitStatus(repoRoot, result.config);
+        this.host.emit({
+            type: "write_project_config_response",
+            payload: {
+                requestId: msg.requestId,
+                repoRoot,
+                ok: true,
+                config: result.config,
+                revision: result.revision,
+                ...(setupCommitStatus === null
+                    ? {}
+                    : { hasUncommittedWorktreeSetupChanges: setupCommitStatus }),
+            },
+        });
+    }
+    async readSetupCommitStatus(repoRoot, config) {
+        try {
+            return await hasUncommittedWorktreeSetupChanges({ repoRoot, currentConfig: config });
+        }
+        catch (error) {
+            this.logger.debug({ repoRoot, error }, "Could not inspect committed worktree setup");
+            return null;
+        }
+    }
+    emitProjectConfigReadFailure(msg, error, repoRoot = msg.repoRoot) {
+        this.host.emit({
+            type: "read_project_config_response",
+            payload: {
+                requestId: msg.requestId,
+                repoRoot,
+                ok: false,
+                error,
+            },
+        });
+    }
+    emitProjectConfigWriteFailure(msg, error, repoRoot = msg.repoRoot) {
+        this.host.emit({
+            type: "write_project_config_response",
+            payload: {
+                requestId: msg.requestId,
+                repoRoot,
+                ok: false,
+                error,
+            },
+        });
+    }
+    async resolveKnownProjectRoot(repoRoot) {
+        const requestedRoot = canonicalizeConfigRoot(repoRoot);
+        const projects = await this.projectRegistry.list();
+        for (const project of projects) {
+            if (project.archivedAt !== null) {
+                continue;
+            }
+            const projectRoot = canonicalizeConfigRoot(project.rootPath);
+            if (requestedRoot === projectRoot) {
+                return projectRoot;
+            }
+        }
+        return null;
+    }
+}
+function canonicalizeConfigRoot(repoRoot) {
+    const resolved = resolve(repoRoot);
+    try {
+        return stripTrailingPathSeparators(realpathSync(resolved));
+    }
+    catch {
+        return stripTrailingPathSeparators(resolved);
+    }
+}
+function stripTrailingPathSeparators(path) {
+    let normalized = path;
+    while (normalized.length > 1 && normalized.endsWith(sep)) {
+        normalized = normalized.slice(0, -1);
+    }
+    return normalized;
+}
+//# sourceMappingURL=project-config-session.js.map

package/dist/server/server/session/project-config/worktree-setup-commit-status.d.ts

@@ -0,0 +1,6 @@
+import { type PaseoConfigRaw } from "@camerontaylor/paseo-protocol/paseo-config-schema";
+export declare function hasUncommittedWorktreeSetupChanges(input: {
+    repoRoot: string;
+    currentConfig: PaseoConfigRaw | null;
+}): Promise<boolean>;
+//# sourceMappingURL=worktree-setup-commit-status.d.ts.map

package/dist/server/server/session/project-config/worktree-setup-commit-status.js

@@ -0,0 +1,38 @@
+import { PaseoConfigRawSchema, normalizeLifecycleCommands, } from "@camerontaylor/paseo-protocol/paseo-config-schema";
+import { READ_ONLY_GIT_ENV } from "../../checkout-git-utils.js";
+import { runGitCommand } from "../../../utils/run-git-command.js";
+export async function hasUncommittedWorktreeSetupChanges(input) {
+    const gitPath = await resolveConfigGitPath(input.repoRoot);
+    const committedConfig = await readCommittedConfig(input.repoRoot, gitPath);
+    const currentSetup = normalizeLifecycleCommands(input.currentConfig?.worktree?.setup);
+    const committedSetup = normalizeLifecycleCommands(committedConfig?.worktree?.setup);
+    return !stringArraysEqual(currentSetup, committedSetup);
+}
+async function resolveConfigGitPath(repoRoot) {
+    const { stdout } = await runGitCommand(["rev-parse", "--show-prefix"], {
+        cwd: repoRoot,
+        envOverlay: READ_ONLY_GIT_ENV,
+    });
+    return `${stdout.trim()}paseo.json`;
+}
+async function readCommittedConfig(repoRoot, gitPath) {
+    await runGitCommand(["rev-parse", "--verify", "HEAD"], {
+        cwd: repoRoot,
+        envOverlay: READ_ONLY_GIT_ENV,
+    });
+    const { stdout: trackedPath } = await runGitCommand(["ls-tree", "--name-only", "HEAD", "--", gitPath], {
+        cwd: repoRoot,
+        envOverlay: READ_ONLY_GIT_ENV,
+    });
+    if (trackedPath.trim().length === 0)
+        return null;
+    const { stdout } = await runGitCommand(["show", `HEAD:${gitPath}`], {
+        cwd: repoRoot,
+        envOverlay: READ_ONLY_GIT_ENV,
+    });
+    return PaseoConfigRawSchema.parse(JSON.parse(stdout));
+}
+function stringArraysEqual(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+//# sourceMappingURL=worktree-setup-commit-status.js.map