@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/checkout/status-projection.d.ts

@@ -0,0 +1,19 @@
+import type { CheckoutPrStatusResponse, CheckoutStatusResponse, SessionOutboundMessage } from "@camerontaylor/paseo-protocol/messages";
+import type { WorkspaceGitRuntimeSnapshot } from "../workspace-git-service.js";
+type CheckoutPrStatusPayload = Extract<SessionOutboundMessage, {
+    type: "checkout_pr_status_response";
+}>["payload"];
+type CheckoutPrStatusPayloadStatus = NonNullable<CheckoutPrStatusPayload["status"]>;
+export declare function buildCheckoutStatusPayloadFromSnapshot({ cwd, requestId, snapshot, }: {
+    cwd: string;
+    requestId: string;
+    snapshot: WorkspaceGitRuntimeSnapshot;
+}): CheckoutStatusResponse["payload"];
+export declare function buildCheckoutPrStatusPayloadFromSnapshot({ cwd, requestId, snapshot, }: {
+    cwd: string;
+    requestId: string;
+    snapshot: WorkspaceGitRuntimeSnapshot;
+}): CheckoutPrStatusResponse["payload"];
+export declare function normalizeCheckoutPrStatusPayload(status: WorkspaceGitRuntimeSnapshot["forge"]["pullRequest"], forge?: string): CheckoutPrStatusPayloadStatus | null;
+export {};
+//# sourceMappingURL=status-projection.d.ts.map

package/dist/server/server/checkout/status-projection.js

@@ -0,0 +1,127 @@
+import { isGitHubPullRequestStatusFacts } from "../../services/github-facts.js";
+export function buildCheckoutStatusPayloadFromSnapshot({ cwd, requestId, snapshot, }) {
+    if (!snapshot.git.isGit) {
+        return {
+            cwd,
+            isGit: false,
+            repoRoot: null,
+            currentBranch: null,
+            isDirty: null,
+            baseRef: null,
+            aheadBehind: null,
+            upstreamRef: null,
+            aheadOfOrigin: null,
+            behindOfOrigin: null,
+            hasRemote: false,
+            remoteUrl: null,
+            isPaseoOwnedWorktree: false,
+            error: null,
+            requestId,
+        };
+    }
+    if (snapshot.git.repoRoot === null || snapshot.git.isDirty === null) {
+        throw new Error("Workspace git snapshot is missing required checkout status fields");
+    }
+    if (snapshot.git.isPaseoOwnedWorktree) {
+        if (snapshot.git.mainRepoRoot === null || snapshot.git.baseRef === null) {
+            throw new Error("Workspace git snapshot is missing required worktree status fields");
+        }
+        return {
+            cwd,
+            isGit: true,
+            repoRoot: snapshot.git.repoRoot,
+            mainRepoRoot: snapshot.git.mainRepoRoot,
+            currentBranch: snapshot.git.currentBranch ?? null,
+            isDirty: snapshot.git.isDirty,
+            baseRef: snapshot.git.baseRef,
+            aheadBehind: snapshot.git.aheadBehind ?? null,
+            upstreamRef: snapshot.git.upstreamRef ?? null,
+            aheadOfOrigin: snapshot.git.aheadOfOrigin ?? null,
+            behindOfOrigin: snapshot.git.behindOfOrigin ?? null,
+            hasRemote: snapshot.git.hasRemote,
+            remoteUrl: snapshot.git.remoteUrl,
+            isPaseoOwnedWorktree: true,
+            error: null,
+            requestId,
+        };
+    }
+    return {
+        cwd,
+        isGit: true,
+        repoRoot: snapshot.git.repoRoot,
+        mainRepoRoot: snapshot.git.mainRepoRoot,
+        currentBranch: snapshot.git.currentBranch ?? null,
+        isDirty: snapshot.git.isDirty,
+        baseRef: snapshot.git.baseRef ?? null,
+        aheadBehind: snapshot.git.aheadBehind ?? null,
+        upstreamRef: snapshot.git.upstreamRef ?? null,
+        aheadOfOrigin: snapshot.git.aheadOfOrigin ?? null,
+        behindOfOrigin: snapshot.git.behindOfOrigin ?? null,
+        hasRemote: snapshot.git.hasRemote,
+        remoteUrl: snapshot.git.remoteUrl,
+        isPaseoOwnedWorktree: false,
+        error: null,
+        requestId,
+    };
+}
+export function buildCheckoutPrStatusPayloadFromSnapshot({ cwd, requestId, snapshot, }) {
+    // Prefer the forge resolved during snapshot refresh (probe-aware, so
+    // self-managed GitLab hosts are correct). forgeSpecific.forge is only a facts
+    // family tag, not a brand id, so unresolved snapshots stay unlabeled.
+    const forge = snapshot.forge.forge;
+    return {
+        cwd,
+        status: normalizeCheckoutPrStatusPayload(snapshot.forge.pullRequest, forge),
+        githubFeaturesEnabled: snapshot.forge.featuresEnabled,
+        authState: snapshot.forge.authState,
+        ...(forge ? { forge } : {}),
+        error: snapshot.forge.error
+            ? {
+                code: "UNKNOWN",
+                message: snapshot.forge.error.message,
+            }
+            : null,
+        requestId,
+    };
+}
+export function normalizeCheckoutPrStatusPayload(status, forge) {
+    if (!status) {
+        return null;
+    }
+    const payload = {
+        ...(forge ? { forge } : {}),
+        number: status.number,
+        url: status.url,
+        title: status.title,
+        state: status.state,
+        repoOwner: status.repoOwner,
+        repoName: status.repoName,
+        baseRefName: status.baseRefName,
+        headRefName: status.headRefName,
+        isMerged: status.isMerged,
+        isDraft: status.isDraft ?? false,
+        mergeable: status.mergeable ?? "UNKNOWN",
+        checks: status.checks ?? [],
+        checksStatus: status.checksStatus,
+        reviewDecision: status.reviewDecision,
+    };
+    if (status.projectPath) {
+        payload.projectPath = status.projectPath;
+    }
+    else if (status.repoOwner && status.repoName) {
+        payload.projectPath = `${status.repoOwner}/${status.repoName}`;
+    }
+    if (status.forgeSpecific) {
+        payload.forgeSpecific = status.forgeSpecific;
+        // COMPAT(forgeSpecific): forgeSpecific shipped in v0.2.0-beta.1. Keep
+        // mirroring GitHub facts onto `github` for clients that predate it. Stop
+        // emitting the mirror after 2027-01-17 once the supported client floor
+        // is >= v0.2.0.
+        if (isGitHubPullRequestStatusFacts(status.forgeSpecific)) {
+            const { forge: _forge, ...githubFacts } = status.forgeSpecific;
+            payload.github = githubFacts;
+        }
+    }
+    return payload;
+}
+//# sourceMappingURL=status-projection.js.map

package/dist/server/server/checkout-diff-manager.d.ts

@@ -0,0 +1,48 @@
+import type pino from "pino";
+import type { SubscribeCheckoutDiffRequest, SessionOutboundMessage } from "./messages.js";
+import type { WorkspaceGitService } from "./workspace-git-service.js";
+type CheckoutDiffWorkspace = Pick<WorkspaceGitService, "getCheckoutDiff" | "getSnapshot" | "peekSnapshot" | "registerWorkspace" | "requestWorkingTreeWatch">;
+export type CheckoutDiffCompareInput = SubscribeCheckoutDiffRequest["compare"];
+export type CheckoutDiffSnapshotPayload = Omit<Extract<SessionOutboundMessage, {
+    type: "checkout_diff_update";
+}>["payload"], "subscriptionId">;
+export interface CheckoutDiffMetrics {
+    checkoutDiffTargetCount: number;
+    checkoutDiffSubscriptionCount: number;
+    checkoutDiffWatcherCount: number;
+    checkoutDiffFallbackRefreshTargetCount: number;
+}
+export interface CheckoutDiffSubscriptionRequest {
+    cwd: string;
+    compare: CheckoutDiffCompareInput;
+    signal?: AbortSignal;
+}
+export interface CheckoutDiffSubscription {
+    initial: CheckoutDiffSnapshotPayload;
+    unsubscribe: () => void;
+}
+export declare class CheckoutDiffManager {
+    private readonly workspaceGitService;
+    private readonly targets;
+    constructor(options: {
+        logger: pino.Logger;
+        paseoHome: string;
+        workspaceGitService: CheckoutDiffWorkspace;
+    });
+    subscribe(params: CheckoutDiffSubscriptionRequest, listener: (snapshot: CheckoutDiffSnapshotPayload) => void): Promise<CheckoutDiffSubscription>;
+    scheduleRefreshForCwd(cwd: string): void;
+    getMetrics(): CheckoutDiffMetrics;
+    dispose(): void;
+    private normalizeCompare;
+    private buildTargetKey;
+    private closeTarget;
+    private rememberWorkspaceSnapshot;
+    private removeListener;
+    private scheduleTargetRefresh;
+    private computeCheckoutDiffSnapshot;
+    private refreshTarget;
+    private ensureTarget;
+    private openTarget;
+}
+export {};
+//# sourceMappingURL=checkout-diff-manager.d.ts.map

package/dist/server/server/checkout-diff-manager.js

@@ -0,0 +1,284 @@
+import { expandTilde } from "../utils/path.js";
+import { toCheckoutError } from "./checkout-git-utils.js";
+const CHECKOUT_DIFF_WATCH_DEBOUNCE_MS = 150;
+export class CheckoutDiffManager {
+    constructor(options) {
+        this.targets = new Map();
+        this.workspaceGitService = options.workspaceGitService;
+    }
+    async subscribe(params, listener) {
+        const cwd = params.cwd;
+        const compare = this.normalizeCompare(params.compare);
+        const target = this.ensureTarget(cwd, compare);
+        target.listeners.add(listener);
+        target.openPromise ?? (target.openPromise = this.openTarget(target));
+        let isSubscribed = true;
+        const unsubscribe = () => {
+            if (!isSubscribed) {
+                return;
+            }
+            isSubscribed = false;
+            params.signal?.removeEventListener("abort", unsubscribe);
+            this.removeListener(target, listener);
+        };
+        params.signal?.addEventListener("abort", unsubscribe, { once: true });
+        if (params.signal?.aborted) {
+            unsubscribe();
+        }
+        try {
+            await target.openPromise;
+            const initial = target.latestPayload ??
+                (await this.computeCheckoutDiffSnapshot(target.cwd, target.compare, {
+                    diffCwd: target.diffCwd,
+                }));
+            target.latestPayload = initial;
+            target.latestFingerprint = JSON.stringify(initial);
+            return { initial, unsubscribe };
+        }
+        catch (error) {
+            unsubscribe();
+            throw error;
+        }
+    }
+    scheduleRefreshForCwd(cwd) {
+        const resolvedCwd = expandTilde(cwd);
+        for (const target of this.targets.values()) {
+            if (target.cwd !== resolvedCwd && target.diffCwd !== resolvedCwd) {
+                continue;
+            }
+            this.scheduleTargetRefresh(target);
+        }
+    }
+    getMetrics() {
+        let checkoutDiffSubscriptionCount = 0;
+        for (const target of this.targets.values()) {
+            checkoutDiffSubscriptionCount += target.listeners.size;
+        }
+        return {
+            checkoutDiffTargetCount: this.targets.size,
+            checkoutDiffSubscriptionCount,
+            checkoutDiffWatcherCount: 0,
+            checkoutDiffFallbackRefreshTargetCount: 0,
+        };
+    }
+    dispose() {
+        for (const target of this.targets.values()) {
+            this.closeTarget(target);
+        }
+        this.targets.clear();
+    }
+    normalizeCompare(compare) {
+        const ignoreWhitespace = compare.ignoreWhitespace === true;
+        if (compare.mode === "uncommitted") {
+            return { mode: "uncommitted", ignoreWhitespace };
+        }
+        const trimmedBaseRef = compare.baseRef?.trim();
+        return trimmedBaseRef
+            ? { mode: "base", baseRef: trimmedBaseRef, ignoreWhitespace }
+            : { mode: "base", ignoreWhitespace };
+    }
+    buildTargetKey(cwd, compare) {
+        return JSON.stringify([
+            cwd,
+            compare.mode,
+            compare.mode === "base" ? (compare.baseRef ?? "") : "",
+            compare.ignoreWhitespace === true,
+        ]);
+    }
+    closeTarget(target) {
+        if (target.debounceTimer) {
+            clearTimeout(target.debounceTimer);
+            target.debounceTimer = null;
+        }
+        target.workingTreeWatchUnsubscribe?.();
+        target.workingTreeWatchUnsubscribe = null;
+        target.workspaceGitUnsubscribe?.();
+        target.workspaceGitUnsubscribe = null;
+        target.listeners.clear();
+    }
+    rememberWorkspaceSnapshot(target, snapshot) {
+        const structureFingerprint = JSON.stringify({
+            isGit: snapshot.git.isGit,
+            repoRoot: snapshot.git.repoRoot,
+            mainRepoRoot: snapshot.git.mainRepoRoot,
+            currentBranch: snapshot.git.currentBranch,
+            remoteUrl: snapshot.git.remoteUrl,
+            isPaseoOwnedWorktree: snapshot.git.isPaseoOwnedWorktree,
+            baseRef: snapshot.git.baseRef,
+            aheadBehind: snapshot.git.aheadBehind,
+            aheadOfOrigin: snapshot.git.aheadOfOrigin,
+            behindOfOrigin: snapshot.git.behindOfOrigin,
+            hasRemote: snapshot.git.hasRemote,
+        });
+        const worktreeFingerprint = JSON.stringify({
+            isDirty: snapshot.git.isDirty,
+            diffStat: snapshot.git.diffStat,
+        });
+        const forgeFingerprint = JSON.stringify(snapshot.forge);
+        const previousStructureFingerprint = target.latestWorkspaceStructureFingerprint;
+        const previousWorktreeFingerprint = target.latestWorkspaceWorktreeFingerprint;
+        const previousForgeFingerprint = target.latestWorkspaceForgeFingerprint;
+        target.latestWorkspaceStructureFingerprint = structureFingerprint;
+        target.latestWorkspaceWorktreeFingerprint = worktreeFingerprint;
+        target.latestWorkspaceForgeFingerprint = forgeFingerprint;
+        if (previousStructureFingerprint === null) {
+            return;
+        }
+        const structureChanged = structureFingerprint !== previousStructureFingerprint;
+        const worktreeChanged = worktreeFingerprint !== previousWorktreeFingerprint;
+        const forgeChanged = forgeFingerprint !== previousForgeFingerprint;
+        if (structureChanged || (!worktreeChanged && !forgeChanged)) {
+            this.scheduleTargetRefresh(target, false);
+        }
+    }
+    removeListener(target, listener) {
+        target.listeners.delete(listener);
+        if (target.listeners.size > 0) {
+            return;
+        }
+        this.closeTarget(target);
+        if (this.targets.get(target.key) === target) {
+            this.targets.delete(target.key);
+        }
+    }
+    scheduleTargetRefresh(target, force = true) {
+        target.pendingDebounceForce || (target.pendingDebounceForce = force);
+        if (target.debounceTimer) {
+            clearTimeout(target.debounceTimer);
+        }
+        target.debounceTimer = setTimeout(() => {
+            target.debounceTimer = null;
+            const pendingForce = target.pendingDebounceForce;
+            target.pendingDebounceForce = false;
+            void this.refreshTarget(target, pendingForce);
+        }, CHECKOUT_DIFF_WATCH_DEBOUNCE_MS);
+    }
+    async computeCheckoutDiffSnapshot(cwd, compare, options) {
+        const diffCwd = options?.diffCwd ?? cwd;
+        try {
+            const diffResult = await this.workspaceGitService.getCheckoutDiff(diffCwd, {
+                mode: compare.mode,
+                baseRef: compare.baseRef,
+                ignoreWhitespace: compare.ignoreWhitespace,
+                includeStructured: true,
+            }, options?.force
+                ? { force: true, reason: options.reason ?? "checkout-diff-refresh" }
+                : undefined);
+            if (diffResult.diffTooLarge) {
+                return {
+                    cwd,
+                    files: [],
+                    diffTooLarge: true,
+                    error: toCheckoutError(new Error("Diff too large to display")),
+                };
+            }
+            const files = [...(diffResult.structured ?? [])];
+            files.sort((a, b) => {
+                if (a.path === b.path)
+                    return 0;
+                return a.path < b.path ? -1 : 1;
+            });
+            return {
+                cwd,
+                files,
+                error: null,
+            };
+        }
+        catch (error) {
+            return {
+                cwd,
+                files: [],
+                error: toCheckoutError(error),
+            };
+        }
+    }
+    async refreshTarget(target, force) {
+        if (target.refreshPromise) {
+            target.refreshQueued = true;
+            target.refreshQueuedForce || (target.refreshQueuedForce = force);
+            return;
+        }
+        target.refreshPromise = (async () => {
+            let currentForce = force;
+            do {
+                target.refreshQueued = false;
+                target.refreshQueuedForce = false;
+                const snapshot = await this.computeCheckoutDiffSnapshot(target.cwd, target.compare, {
+                    diffCwd: target.diffCwd,
+                    force: currentForce,
+                    ...(currentForce ? { reason: "working-tree-watch" } : {}),
+                });
+                target.latestPayload = snapshot;
+                const fingerprint = JSON.stringify(snapshot);
+                if (fingerprint !== target.latestFingerprint) {
+                    target.latestFingerprint = fingerprint;
+                    for (const listener of target.listeners) {
+                        listener(snapshot);
+                    }
+                }
+                currentForce = target.refreshQueuedForce;
+            } while (target.refreshQueued);
+        })();
+        try {
+            await target.refreshPromise;
+        }
+        finally {
+            target.refreshPromise = null;
+        }
+    }
+    ensureTarget(cwd, compare) {
+        const targetKey = this.buildTargetKey(cwd, compare);
+        const existing = this.targets.get(targetKey);
+        if (existing) {
+            return existing;
+        }
+        const target = {
+            key: targetKey,
+            cwd,
+            diffCwd: cwd,
+            compare,
+            listeners: new Set(),
+            workingTreeWatchUnsubscribe: null,
+            workspaceGitUnsubscribe: null,
+            latestWorkspaceStructureFingerprint: null,
+            latestWorkspaceWorktreeFingerprint: null,
+            latestWorkspaceForgeFingerprint: null,
+            debounceTimer: null,
+            pendingDebounceForce: false,
+            refreshPromise: null,
+            refreshQueued: false,
+            refreshQueuedForce: false,
+            latestPayload: null,
+            latestFingerprint: null,
+            openPromise: null,
+        };
+        this.targets.set(targetKey, target);
+        return target;
+    }
+    async openTarget(target) {
+        if (target.compare.mode === "base") {
+            const snapshot = this.workspaceGitService.peekSnapshot(target.cwd) ??
+                (await this.workspaceGitService.getSnapshot(target.cwd, { includeForge: false }));
+            target.diffCwd = snapshot.git.repoRoot ?? target.cwd;
+            if (this.targets.get(target.key) !== target || target.listeners.size === 0) {
+                return;
+            }
+            this.rememberWorkspaceSnapshot(target, snapshot);
+            const workspaceSubscription = this.workspaceGitService.registerWorkspace({ cwd: target.cwd }, (nextSnapshot) => this.rememberWorkspaceSnapshot(target, nextSnapshot));
+            if (this.targets.get(target.key) !== target || target.listeners.size === 0) {
+                workspaceSubscription.unsubscribe();
+                return;
+            }
+            target.workspaceGitUnsubscribe = workspaceSubscription.unsubscribe;
+            return;
+        }
+        const { repoRoot, unsubscribe } = await this.workspaceGitService.requestWorkingTreeWatch(target.cwd, () => this.scheduleTargetRefresh(target));
+        target.diffCwd = repoRoot ?? target.cwd;
+        if (this.targets.get(target.key) !== target || target.listeners.size === 0) {
+            unsubscribe();
+            return;
+        }
+        target.workingTreeWatchUnsubscribe = unsubscribe;
+    }
+}
+//# sourceMappingURL=checkout-diff-manager.js.map

package/dist/server/server/checkout-git-utils.d.ts

@@ -0,0 +1,11 @@
+export declare const READ_ONLY_GIT_ENV: {
+    readonly GIT_OPTIONAL_LOCKS: "0";
+};
+export type CheckoutErrorCode = "NOT_GIT_REPO" | "NOT_ALLOWED" | "MERGE_CONFLICT" | "UNKNOWN";
+export interface CheckoutErrorPayload {
+    code: CheckoutErrorCode;
+    message: string;
+}
+export declare function resolveCheckoutGitDir(cwd: string): Promise<string | null>;
+export declare function toCheckoutError(error: unknown): CheckoutErrorPayload;
+//# sourceMappingURL=checkout-git-utils.d.ts.map

package/dist/server/server/checkout-git-utils.js

@@ -0,0 +1,34 @@
+import { MergeConflictError, MergeFromBaseConflictError, NotGitRepoError, } from "../utils/checkout-git.js";
+import { runGitCommand } from "../utils/run-git-command.js";
+export const READ_ONLY_GIT_ENV = {
+    GIT_OPTIONAL_LOCKS: "0",
+};
+export async function resolveCheckoutGitDir(cwd) {
+    try {
+        const { stdout } = await runGitCommand(["rev-parse", "--absolute-git-dir"], {
+            cwd,
+            envOverlay: READ_ONLY_GIT_ENV,
+        });
+        const gitDir = stdout.trim();
+        return gitDir.length > 0 ? gitDir : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function toCheckoutError(error) {
+    if (error instanceof NotGitRepoError) {
+        return { code: "NOT_GIT_REPO", message: error.message };
+    }
+    if (error instanceof MergeConflictError) {
+        return { code: "MERGE_CONFLICT", message: error.message };
+    }
+    if (error instanceof MergeFromBaseConflictError) {
+        return { code: "MERGE_CONFLICT", message: error.message };
+    }
+    if (error instanceof Error) {
+        return { code: "UNKNOWN", message: error.message };
+    }
+    return { code: "UNKNOWN", message: String(error) };
+}
+//# sourceMappingURL=checkout-git-utils.js.map

package/dist/server/server/client-message-id.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeClientMessageId(clientMessageId: string | undefined): string | undefined;
+export declare function resolveClientMessageId(clientMessageId: string | undefined, generateId?: () => string): string;
+//# sourceMappingURL=client-message-id.d.ts.map

package/dist/server/server/client-message-id.js

@@ -0,0 +1,12 @@
+import { v4 as uuidv4 } from "uuid";
+export function normalizeClientMessageId(clientMessageId) {
+    if (typeof clientMessageId !== "string") {
+        return undefined;
+    }
+    const trimmed = clientMessageId.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+export function resolveClientMessageId(clientMessageId, generateId = uuidv4) {
+    return normalizeClientMessageId(clientMessageId) ?? generateId();
+}
+//# sourceMappingURL=client-message-id.js.map

package/dist/server/server/config.d.ts

@@ -0,0 +1,26 @@
+import type { PaseoDaemonConfig } from "./bootstrap.js";
+import { type PersistedConfig } from "./persisted-config.js";
+import { type HostnamesConfig } from "./hostnames.js";
+interface ResolveBundledWebUiDistDirInput {
+    moduleUrl?: string | URL;
+    resourcesPath?: string;
+}
+export declare function resolveBundledWebUiDistDir(input?: ResolveBundledWebUiDistDirInput): string;
+export type CliConfigOverrides = Partial<{
+    listen: string;
+    relayEnabled: boolean;
+    relayUseTls: boolean;
+    mcpEnabled: boolean;
+    mcpInjectIntoAgents: boolean;
+    webUiEnabled: boolean;
+    hostnames: HostnamesConfig;
+}>;
+interface ResolveConfigFromPersistedOptions {
+    env?: NodeJS.ProcessEnv;
+    cli?: CliConfigOverrides;
+    relayEnabledFallback?: boolean;
+}
+export declare function resolveConfigFromPersisted(paseoHome: string, persisted: PersistedConfig, options?: ResolveConfigFromPersistedOptions): PaseoDaemonConfig;
+export declare function loadConfig(paseoHome: string, options?: Omit<ResolveConfigFromPersistedOptions, "relayEnabledFallback">): PaseoDaemonConfig;
+export {};
+//# sourceMappingURL=config.d.ts.map