@camerontaylor/paseo-server 0.8.0-fork.1

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

@@ -0,0 +1,108 @@
+import { runGitCommand } from "../utils/run-git-command.js";
+export async function fetchWorkspaceGitRemote(cwd, observer, run = runGitCommand) {
+    let before = null;
+    let after = null;
+    let error = null;
+    try {
+        before = await readWorkspaceGitRefs(cwd, run);
+        observer.onRefSnapshot("before");
+    }
+    catch (caught) {
+        error = caught;
+    }
+    try {
+        await run(["fetch", "origin", "--prune"], {
+            cwd,
+            envOverlay: { GIT_TERMINAL_PROMPT: "0" },
+            timeout: 120000,
+        });
+    }
+    catch (caught) {
+        error ?? (error = caught);
+    }
+    try {
+        after = await readWorkspaceGitRefs(cwd, run);
+    }
+    catch (caught) {
+        error ?? (error = caught);
+    }
+    if (!before || !after) {
+        return { changes: null, error };
+    }
+    const diff = diffWorkspaceGitRefs(before, after);
+    const result = {
+        changes: diff.remoteChanges,
+        nonRemoteRefsChanged: diff.nonRemoteRefsChanged,
+        remoteRefs: collectWorkspaceGitRemoteRefs(after),
+        error,
+    };
+    observer.onRefSnapshot("after");
+    return result;
+}
+function collectWorkspaceGitRemoteRefs(refs) {
+    const remotePrefix = "refs/remotes/";
+    return new Set([...refs.keys()]
+        .filter((ref) => ref.startsWith(remotePrefix))
+        .map((ref) => ref.slice(remotePrefix.length)));
+}
+async function readWorkspaceGitRefs(cwd, run) {
+    const { stdout } = await run(["for-each-ref", "--format=%(refname)%00%(objectname)"], {
+        cwd,
+    });
+    return parseWorkspaceGitRefs(stdout);
+}
+export function parseWorkspaceGitRefs(stdout) {
+    const refs = new Map();
+    for (const line of stdout.split("\n")) {
+        const [ref, objectId] = line.split("\0");
+        if (ref?.startsWith("refs/") && objectId) {
+            refs.set(ref, objectId);
+        }
+    }
+    return refs;
+}
+export function diffWorkspaceGitRefs(before, after) {
+    const remotePrefix = "refs/remotes/";
+    const beforeRemote = new Map();
+    const afterRemote = new Map();
+    let nonRemoteRefsChanged = false;
+    for (const [ref, objectId] of before) {
+        if (ref.startsWith(remotePrefix)) {
+            beforeRemote.set(ref.slice(remotePrefix.length), objectId);
+        }
+        else if (after.get(ref) !== objectId) {
+            nonRemoteRefsChanged = true;
+        }
+    }
+    for (const [ref, objectId] of after) {
+        if (ref.startsWith(remotePrefix)) {
+            afterRemote.set(ref.slice(remotePrefix.length), objectId);
+        }
+        else if (!before.has(ref)) {
+            nonRemoteRefsChanged = true;
+        }
+    }
+    return {
+        remoteChanges: diffWorkspaceGitRemoteRefs(beforeRemote, afterRemote),
+        nonRemoteRefsChanged,
+    };
+}
+export function diffWorkspaceGitRemoteRefs(before, after) {
+    const changes = [];
+    for (const [ref, objectId] of after) {
+        const beforeOid = before.get(ref);
+        if (beforeOid === undefined) {
+            changes.push({ kind: "added", ref, afterOid: objectId });
+        }
+        else if (beforeOid !== objectId) {
+            changes.push({ kind: "moved", ref, beforeOid, afterOid: objectId });
+        }
+    }
+    for (const [ref, beforeOid] of before) {
+        if (!after.has(ref)) {
+            changes.push({ kind: "deleted", ref, beforeOid });
+        }
+    }
+    return changes;
+}
+//# sourceMappingURL=workspace-git-fetch.js.map

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

@@ -0,0 +1,8 @@
+export declare function parseGitHubRepoFromRemote(remoteUrl: string): string | null;
+export declare function parseGitHubRepoNameFromRemote(remoteUrl: string): string | null;
+export declare function deriveProjectSlug(cwd: string, remoteUrl?: string | null): string;
+export declare function deriveProjectServiceSlug(project: {
+    projectId: string;
+    rootPath: string;
+}): string;
+//# sourceMappingURL=workspace-git-metadata.d.ts.map

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

@@ -0,0 +1,24 @@
+import { basename } from "path";
+import { createHash } from "node:crypto";
+import { parseGitHubRemoteUrl } from "@camerontaylor/paseo-protocol/git-remote";
+import { slugify } from "../utils/worktree.js";
+export function parseGitHubRepoFromRemote(remoteUrl) {
+    return parseGitHubRemoteUrl(remoteUrl)?.repo ?? null;
+}
+export function parseGitHubRepoNameFromRemote(remoteUrl) {
+    const githubRepo = parseGitHubRepoFromRemote(remoteUrl);
+    if (!githubRepo) {
+        return null;
+    }
+    return githubRepo.split("/").pop() || null;
+}
+export function deriveProjectSlug(cwd, remoteUrl = null) {
+    const githubRepoName = remoteUrl ? parseGitHubRepoNameFromRemote(remoteUrl) : null;
+    const sourceName = githubRepoName ?? basename(cwd);
+    return slugify(sourceName) || "untitled";
+}
+export function deriveProjectServiceSlug(project) {
+    const identity = createHash("sha256").update(project.projectId).digest("hex").slice(0, 8);
+    return `${deriveProjectSlug(project.rootPath)}-${identity}`;
+}
+//# sourceMappingURL=workspace-git-metadata.js.map

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

@@ -0,0 +1,348 @@
+import type pino from "pino";
+import type { ProjectCheckoutLitePayload } from "@camerontaylor/paseo-protocol/messages";
+import { type BranchCheckoutResolution, type BranchSuggestion, type CheckoutDiffCompare, type CheckoutDiffResult, getCheckoutDiff, getCheckoutRefDerivedState, getCheckoutSnapshotFacts, getCheckoutShortstat, getCheckoutStatus, getCheckoutWorktreeState, getPullRequestStatus, listBranchSuggestions, resolveRepositoryDefaultBranch, resolveBranchCheckout } from "../utils/checkout-git.js";
+import type { ForgeAuthState, ForgeService, ForgeSpecificStatusFacts, PullRequestCheck, PullRequestMergeable } from "../services/forge-service.js";
+import { type ForgeResolution } from "../services/forge-resolver.js";
+import { runGitCommand, type RunGitCommand } from "../utils/run-git-command.js";
+import { listPaseoWorktrees, type PaseoWorktreeInfo } from "../utils/worktree.js";
+import { type WorkspaceGitFetchResult, type WorkspaceGitFetchObserver } from "./workspace-git-fetch.js";
+import { type FileObserverDiagnostics, type FileObserver, type SubscribeToFileChanges } from "./file-observer/index.js";
+import { createWatcherLivenessCanary } from "./watcher-liveness-canary.js";
+export declare const WORKSPACE_GIT_OBSERVATION_REENSURE_INTERVAL_MS = 60000;
+export declare const WORKSPACE_GIT_REFRESH_CONCURRENCY = 4;
+export declare const WORKSPACE_GIT_OBSERVATION_SETUP_CONCURRENCY = 2;
+export declare const WORKSPACE_GIT_WATCHER_SUBSCRIBE_TIMEOUT_MS = 10000;
+export declare function getWorkspaceGitObservationReensurePhaseMs(cwd: string): number;
+export declare const getWorkspaceGitSelfHealPhaseMs: typeof getWorkspaceGitObservationReensurePhaseMs;
+export interface WorkspaceGitRuntimeSnapshot {
+    cwd: string;
+    git: {
+        isGit: boolean;
+        repoRoot: string | null;
+        mainRepoRoot: string | null;
+        currentBranch: string | null;
+        remoteUrl: string | null;
+        isPaseoOwnedWorktree: boolean;
+        isDirty: boolean | null;
+        baseRef: string | null;
+        aheadBehind: {
+            ahead: number;
+            behind: number;
+        } | null;
+        upstreamRef: string | null;
+        aheadOfOrigin: number | null;
+        behindOfOrigin: number | null;
+        hasRemote: boolean;
+        diffStat: {
+            additions: number;
+            deletions: number;
+        } | null;
+    };
+    forge: {
+        featuresEnabled: boolean;
+        authState: ForgeAuthState;
+        /**
+         * Forge resolved for this workspace from its remote — including the per-host
+         * probe, so self-managed GitLab hosts (no "gitlab" in the name) are labeled
+         * correctly. The wire projection prefers this over the bare name heuristic.
+         */
+        forge?: string;
+        pullRequest: {
+            number?: number;
+            repoOwner?: string;
+            repoName?: string;
+            projectPath?: string;
+            url: string;
+            title: string;
+            state: string;
+            baseRefName: string;
+            headRefName: string;
+            isMerged: boolean;
+            isDraft?: boolean;
+            mergeable?: PullRequestMergeable;
+            checks?: PullRequestCheck[];
+            checksStatus?: "none" | "pending" | "success" | "failure";
+            reviewDecision?: "approved" | "changes_requested" | "pending" | null;
+            forgeSpecific?: ForgeSpecificStatusFacts;
+        } | null;
+        error: {
+            message: string;
+        } | null;
+    };
+}
+export interface WorkspaceGitService {
+    registerWorkspace(params: {
+        cwd: string;
+    }, listener: WorkspaceGitListener): WorkspaceGitSubscription;
+    onSnapshotUpdated(listener: WorkspaceGitSnapshotUpdatedListener): WorkspaceGitSubscription;
+    peekSnapshot(cwd: string): WorkspaceGitRuntimeSnapshot | null;
+    getCheckout(cwd: string): Promise<ProjectCheckoutLitePayload>;
+    getSnapshot(cwd: string, options?: WorkspaceGitSnapshotOptions): Promise<WorkspaceGitRuntimeSnapshot>;
+    resolveForge(cwd: string): Promise<ForgeResolution | null>;
+    getCheckoutDiff(cwd: string, options: CheckoutDiffCompare, readOptions?: WorkspaceGitReadOptions): Promise<CheckoutDiffResult>;
+    validateBranchRef(cwd: string, ref: string, options?: WorkspaceGitReadOptions): Promise<WorkspaceGitBranchValidationResult>;
+    hasLocalBranch(cwd: string, branch: string, options?: WorkspaceGitReadOptions): Promise<boolean>;
+    suggestBranchesForCwd(cwd: string, options?: WorkspaceGitBranchSuggestionsOptions, readOptions?: WorkspaceGitReadOptions): Promise<WorkspaceGitBranchSuggestion[]>;
+    listStashes(cwd: string, options?: WorkspaceGitStashListOptions, readOptions?: WorkspaceGitReadOptions): Promise<WorkspaceGitStashEntry[]>;
+    listWorktrees(cwdOrRepoRoot: string, options?: WorkspaceGitReadOptions): Promise<WorkspaceGitWorktreeInfo[]>;
+    getProjectSlug(cwd: string, options?: WorkspaceGitReadOptions): Promise<string>;
+    resolveRepoRoot(cwd: string, options?: WorkspaceGitReadOptions): Promise<string>;
+    resolveDefaultBranch(cwdOrRepoRoot: string, options?: WorkspaceGitReadOptions): Promise<string>;
+    resolveRepoRemoteUrl(cwd: string, options?: WorkspaceGitReadOptions): Promise<string | null>;
+    refresh(cwd: string, options?: {
+        priority?: "normal" | "high";
+    }): Promise<void>;
+    requestWorkingTreeWatch(cwd: string, onChange: () => void): Promise<{
+        repoRoot: string | null;
+        unsubscribe: () => void;
+    }>;
+    scheduleRefreshForCwd(cwd: string): void;
+    onWorkspaceStateMayHaveChanged(cwd: string): void;
+    invalidateForge(cwd: string): void;
+    getMetrics(): WorkspaceGitServiceMetrics;
+    dispose(): Promise<void>;
+}
+export interface WorkspaceGitServiceMetrics {
+    workspaceTargetCount: number;
+    workspaceListenerCount: number;
+    repositoryTargetCount: number;
+    repositoryWorkspaceLinkCount: number;
+    workingTreeWatchTargetCount: number;
+    workingTreeWatchListenerCount: number;
+    workspaceObservationSetupInFlightCount: number;
+    workingTreeWatchSetupInFlightCount: number;
+    workspaceRefreshInFlightCount: number;
+    workspaceRefreshQueuedCount: number;
+    workspaceRefreshAdmissionActiveCount: number;
+    workspaceRefreshAdmissionPendingCount: number;
+    workspaceObservationSetupAdmissionActiveCount: number;
+    workspaceObservationSetupAdmissionPendingCount: number;
+    fetchInFlightCount: number;
+    snapshotUpdatedListenerCount: number;
+    watcherErrorCallbackCount: number;
+    fileObserver: FileObserverDiagnostics;
+}
+export type WorkspaceGitListener = (snapshot: WorkspaceGitRuntimeSnapshot) => void;
+export type WorkspaceGitSnapshotUpdatedListener = (snapshot: WorkspaceGitRuntimeSnapshot) => void;
+export interface WorkspaceGitSubscription {
+    unsubscribe: () => void;
+}
+export type WorkspaceGitReadOptions = {
+    force?: false;
+    reason?: string;
+} | {
+    force: true;
+    reason: string;
+};
+export interface WorkspaceGitBranchSuggestionsOptions {
+    query?: string;
+    limit?: number;
+}
+export interface WorkspaceGitStashListOptions {
+    paseoOnly?: boolean;
+}
+export interface WorkspaceGitStashEntry {
+    index: number;
+    message: string;
+    branch: string | null;
+    isPaseo: boolean;
+}
+export type WorkspaceGitBranchValidationResult = BranchCheckoutResolution;
+export type WorkspaceGitBranchSuggestion = BranchSuggestion;
+export type WorkspaceGitWorktreeInfo = PaseoWorktreeInfo;
+export type WorkspaceGitSnapshotOptions = {
+    force?: false;
+    includeForge?: boolean;
+    reason?: string;
+} | {
+    force: true;
+    includeForge?: boolean;
+    reason: string;
+};
+interface WorkspaceGitServiceDependencies {
+    subscribe: SubscribeToFileChanges;
+    getCheckoutSnapshotFacts: typeof getCheckoutSnapshotFacts;
+    getCheckoutRefDerivedState: typeof getCheckoutRefDerivedState;
+    getCheckoutStatus: typeof getCheckoutStatus;
+    getCheckoutShortstat: typeof getCheckoutShortstat;
+    getCheckoutWorktreeState: typeof getCheckoutWorktreeState;
+    getCheckoutDiff: typeof getCheckoutDiff;
+    getPullRequestStatus: typeof getPullRequestStatus;
+    resolveBranchCheckout: typeof resolveBranchCheckout;
+    resolveRepositoryDefaultBranch: typeof resolveRepositoryDefaultBranch;
+    listBranchSuggestions: typeof listBranchSuggestions;
+    listPaseoWorktrees: typeof listPaseoWorktrees;
+    /**
+     * Adapter instances to bind by forge id instead of building from the registry
+     * — the injection seam for the daemon's shared GitHub adapter and for test
+     * fakes. Any forge not listed here is built (and cached once) by the registry.
+     */
+    forgeOverrides?: Record<string, ForgeService>;
+    resolveAbsoluteGitDir: (cwd: string) => Promise<string | null>;
+    hasOriginRemote: (cwd: string) => Promise<boolean>;
+    runGitFetch: (cwd: string, observer: WorkspaceGitFetchObserver, runGitCommand: RunGitCommand) => Promise<WorkspaceGitFetchResult>;
+    runGitCommand: typeof runGitCommand;
+    getWorkspaceGitSelfHealPhaseMs: typeof getWorkspaceGitObservationReensurePhaseMs;
+    createWatcherLivenessCanary: typeof createWatcherLivenessCanary;
+    now: () => Date;
+}
+interface WorkspaceGitServiceOptions {
+    logger: pino.Logger;
+    paseoHome: string;
+    worktreesRoot?: string;
+    fileObserver?: FileObserver;
+    deps?: Partial<WorkspaceGitServiceDependencies>;
+}
+export declare class WorkspaceGitServiceImpl implements WorkspaceGitService {
+    private readonly logger;
+    private readonly paseoHome;
+    private readonly worktreesRoot;
+    private readonly fileObserver;
+    private readonly deps;
+    private readonly forgeResolver;
+    private readonly workspaceRefreshLimit;
+    private readonly workspaceObservationSetupLimit;
+    private readonly disposeController;
+    private disposed;
+    private disposePromise;
+    private readonly snapshotUpdatedListeners;
+    private readonly workspaceTargets;
+    private readonly repoTargets;
+    private readonly workingTreeWatchTargets;
+    private readonly workingTreeWatchSetups;
+    private readonly workingTreeWatchResolutions;
+    private readonly workingTreeWatchAliases;
+    private readonly branchValidationCache;
+    private readonly localBranchCache;
+    private readonly branchSuggestionsCache;
+    private readonly stashListCache;
+    private readonly worktreeListCache;
+    private readonly defaultBranchCache;
+    private readonly checkoutDiffCache;
+    private watcherErrorCallbackCount;
+    constructor(options: WorkspaceGitServiceOptions);
+    resolveForge(cwd: string): Promise<ForgeResolution | null>;
+    registerWorkspace(params: {
+        cwd: string;
+    }, listener: WorkspaceGitListener): WorkspaceGitSubscription;
+    onSnapshotUpdated(listener: WorkspaceGitSnapshotUpdatedListener): WorkspaceGitSubscription;
+    getMetrics(): WorkspaceGitServiceMetrics;
+    getSnapshot(cwd: string, options?: WorkspaceGitSnapshotOptions): Promise<WorkspaceGitRuntimeSnapshot>;
+    getCheckout(cwd: string): Promise<ProjectCheckoutLitePayload>;
+    peekSnapshot(cwd: string): WorkspaceGitRuntimeSnapshot | null;
+    getCheckoutDiff(cwd: string, options: CheckoutDiffCompare, readOptions?: WorkspaceGitReadOptions): Promise<CheckoutDiffResult>;
+    private normalizeCheckoutDiffOptions;
+    private buildCheckoutDiffCacheKey;
+    private invalidateCheckoutDiffCache;
+    validateBranchRef(cwd: string, ref: string, options?: WorkspaceGitReadOptions): Promise<WorkspaceGitBranchValidationResult>;
+    hasLocalBranch(cwd: string, branch: string, options?: WorkspaceGitReadOptions): Promise<boolean>;
+    suggestBranchesForCwd(cwd: string, options?: WorkspaceGitBranchSuggestionsOptions, readOptions?: WorkspaceGitReadOptions): Promise<WorkspaceGitBranchSuggestion[]>;
+    listStashes(cwd: string, options?: WorkspaceGitStashListOptions, readOptions?: WorkspaceGitReadOptions): Promise<WorkspaceGitStashEntry[]>;
+    listWorktrees(cwdOrRepoRoot: string, options?: WorkspaceGitReadOptions): Promise<WorkspaceGitWorktreeInfo[]>;
+    resolveRepoRoot(cwd: string, options?: WorkspaceGitReadOptions): Promise<string>;
+    resolveDefaultBranch(cwdOrRepoRoot: string, options?: WorkspaceGitReadOptions): Promise<string>;
+    getProjectSlug(cwd: string, options?: WorkspaceGitReadOptions): Promise<string>;
+    resolveRepoRemoteUrl(cwd: string, options?: WorkspaceGitReadOptions): Promise<string | null>;
+    refresh(cwd: string, _options?: {
+        priority?: "normal" | "high";
+    }): Promise<void>;
+    requestWorkingTreeWatch(cwd: string, onChange: () => void): Promise<{
+        repoRoot: string | null;
+        unsubscribe: () => void;
+    }>;
+    scheduleRefreshForCwd(cwd: string): void;
+    onWorkspaceStateMayHaveChanged(cwd: string): void;
+    /**
+     * Drop the resolved forge adapter's cached state for a cwd. Goes through the
+     * resolver so it targets the same adapter instance the poller reads — used by
+     * git mutations to force a fresh forge status on the next refresh.
+     */
+    invalidateForge(cwd: string): void;
+    dispose(): Promise<void>;
+    private assertNotDisposed;
+    private ensureWorkspaceTarget;
+    private readAuxiliaryCache;
+    private ensureAuxiliaryCacheEntry;
+    private ensureWorkingTreeWatchTarget;
+    private resolveWorkingTreeWatchTarget;
+    private rememberWorkingTreeWatchAlias;
+    private createWorkspaceTarget;
+    private scheduleInitialWorkspaceRefresh;
+    private scheduleWorkspaceObservationSetup;
+    private setupWorkspaceObservation;
+    private getFactsForObservation;
+    private loadCheckoutFacts;
+    private isActiveObservedWorkspaceTarget;
+    private createWorkingTreeWatchTarget;
+    private subscribeWithDeadline;
+    private unsubscribeWatcherSubscription;
+    private startWorkingTreeSubscription;
+    private startWorkingTreeWatchFallback;
+    private degradeWorkingTreeWatch;
+    private scheduleWorkingTreeWatchRecovery;
+    private recoverWorkingTreeWatch;
+    private promoteWorkingTreeWatchTarget;
+    private hasRelevantWorkingTreeEvent;
+    private refreshWorkingTreeIgnoredDirectories;
+    private replaceWorkingTreeIgnoredDirectories;
+    private haveSamePaths;
+    private notifyWorkingTreeChanged;
+    private notifyWorkingTreeConsumers;
+    private scheduleWorkingTreeRefreshes;
+    private getWorkingTreeWatchTargetForWorkspace;
+    private resolveCheckoutWatchRoot;
+    private resolveWorkspaceGitRefsRoot;
+    private ensureRepoTarget;
+    private startRepoMetadataObservation;
+    private degradeRepoMetadataWatch;
+    private scheduleRepoMetadataWatchRecovery;
+    private recoverRepoMetadataWatch;
+    private routeRepoMetadataEvents;
+    private refreshWorkingTreeIgnoresFromRepoMetadataEvents;
+    private isFetchRemoteMetadataEvent;
+    private routeRepoMetadataEvent;
+    private routePrivateGitDirEvent;
+    private routeMainCheckoutMetadata;
+    private routeLocalBranchRef;
+    private routeRemoteBranchRef;
+    private addWorkspaceMetadataRefresh;
+    private scheduleRepoMetadataRefresh;
+    private startRepoMetadataFallback;
+    private scheduleWorkspaceRefresh;
+    private startWorkspaceSubscriptionTimers;
+    private updateForgePrStatusPollForTarget;
+    private retainGenericForgePrStatusPoll;
+    private resolveForgePrStatusPollTarget;
+    private stopForgePrStatusPollForTarget;
+    private loadIgnoredDirs;
+    private refreshWorkspaceTarget;
+    private requestWorkspaceSnapshot;
+    private normalizeRefreshRequest;
+    private shouldThrottleNonForcedRefresh;
+    private buildScheduledRefreshRequest;
+    private mergeRefreshRequests;
+    private runWorkspaceRefreshLoop;
+    private refreshSnapshot;
+    private refreshRefDerivedSnapshot;
+    private refreshWorktreeSnapshot;
+    private refreshGitSnapshot;
+    private refreshForgeSnapshot;
+    private combineSnapshot;
+    private getForgePrStatusPollKey;
+    private rememberForgePrStatusSnapshot;
+    private rememberSnapshot;
+    private runRepoFetch;
+    private applyRepoFetchResult;
+    private flushBufferedFetchMetadataEvents;
+    private flushFetchMetadataEvents;
+    private removeWorkspaceListener;
+    private removeWorkspaceTarget;
+    private removeWorkingTreeWatchListener;
+    private removeWorkspaceWorkingTreeLink;
+    private closeWorkingTreeWatchTargetIfUnused;
+    private closeWorkspaceTarget;
+    private closeWorkingTreeWatchTarget;
+    private closeRepoTarget;
+}
+export {};
+//# sourceMappingURL=workspace-git-service.d.ts.map