@getpaseo/server 0.1.93 → 0.1.95

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

@@ -12,7 +12,7 @@ import { listPaseoWorktrees } from "../utils/worktree.js";
 import { READ_ONLY_GIT_ENV } from "./checkout-git-utils.js";
 import { buildWorkspaceGitMetadataFromSnapshot, } from "./workspace-git-metadata.js";
 import { checkoutLiteFromGitSnapshot, normalizeWorkspaceId } from "./workspace-registry-model.js";
-const WORKSPACE_GIT_WATCH_DEBOUNCE_MS = 500;
+const WORKSPACE_GIT_WATCH_DEBOUNCE_MS = 1000;
 const BACKGROUND_GIT_FETCH_INTERVAL_MS = 180000;
 export const WORKSPACE_GIT_SELF_HEAL_INTERVAL_MS = 60000;
 const WORKING_TREE_WATCH_FALLBACK_REFRESH_MS = 5000;
@@ -295,6 +295,19 @@ export class WorkspaceGitServiceImpl {
             this.scheduleWorkspaceRefresh(target);
         }
     }
+    onWorkspaceStateMayHaveChanged(cwd) {
+        const normalizedCwd = normalizeWorkspaceId(cwd);
+        const target = this.workspaceTargets.get(normalizedCwd);
+        if (!target || target.closed) {
+            return;
+        }
+        this.deps.github.invalidate({ cwd: normalizedCwd });
+        this.scheduleWorkspaceRefresh(target, {
+            force: true,
+            includeGitHub: true,
+            reason: "external-state-change",
+        });
+    }
     dispose() {
         for (const target of this.workspaceTargets.values()) {
             this.closeWorkspaceTarget(target);
@@ -384,6 +397,7 @@ export class WorkspaceGitServiceImpl {
             listeners: new Set(),
             watchers: [],
             debounceTimer: null,
+            pendingDebounceRequest: null,
             selfHealTimer: null,
             githubPollSubscription: null,
             githubPollKey: null,
@@ -640,6 +654,8 @@ export class WorkspaceGitServiceImpl {
         if (!target || target.closed || this.workspaceTargets.get(target.cwd) !== target) {
             return;
         }
+        const request = this.buildScheduledRefreshRequest(options);
+        target.pendingDebounceRequest = this.mergeRefreshRequests(target.pendingDebounceRequest, request);
         if (target.debounceTimer) {
             clearTimeout(target.debounceTimer);
         }
@@ -648,12 +664,11 @@ export class WorkspaceGitServiceImpl {
                 return;
             }
             target.debounceTimer = null;
-            void this.refreshWorkspaceTarget(target, {
-                force: options?.force === true,
-                includeGitHub: false,
-                reason: options?.reason ?? "watch",
-                notify: true,
-            });
+            const merged = target.pendingDebounceRequest;
+            target.pendingDebounceRequest = null;
+            if (merged) {
+                void this.refreshWorkspaceTarget(target, merged);
+            }
         }, WORKSPACE_GIT_WATCH_DEBOUNCE_MS);
     }
     startWorkspaceSubscriptionTimers(target) {
@@ -923,7 +938,7 @@ export class WorkspaceGitServiceImpl {
             const needsForcedRefresh = request.force && !target.refreshState.force;
             const needsGitHubRefresh = request.force && request.includeGitHub && !target.refreshState.includeGitHub;
             if (needsForcedRefresh || needsGitHubRefresh) {
-                target.refreshState.queued = this.mergeQueuedRefresh(target.refreshState.queued, request);
+                target.refreshState.queued = this.mergeRefreshRequests(target.refreshState.queued, request);
             }
             return target.refreshState.promise;
         }
@@ -975,23 +990,26 @@ export class WorkspaceGitServiceImpl {
         }
         return this.deps.now().getTime() - target.lastShellOutAtMs < WORKSPACE_GIT_INTERNAL_MIN_GAP_MS;
     }
-    mergeQueuedRefresh(queued, request) {
-        if (!queued) {
-            return {
-                force: request.force,
-                includeGitHub: request.includeGitHub,
-                reason: request.reason,
-                notify: request.notify,
-            };
+    buildScheduledRefreshRequest(options) {
+        return {
+            force: options?.force === true,
+            includeGitHub: options?.includeGitHub ?? false,
+            reason: options?.reason ?? "watch",
+            notify: true,
+        };
+    }
+    mergeRefreshRequests(pending, request) {
+        if (!pending) {
+            return request;
         }
-        const force = queued.force || request.force;
-        const upgradesForce = request.force && !queued.force;
-        const upgradesGitHub = request.includeGitHub && !queued.includeGitHub;
+        const force = pending.force || request.force;
+        const upgradesForce = request.force && !pending.force;
+        const upgradesGitHub = request.includeGitHub && !pending.includeGitHub;
         return {
             force,
-            includeGitHub: queued.includeGitHub || request.includeGitHub,
-            reason: upgradesForce || upgradesGitHub ? request.reason : queued.reason,
-            notify: queued.notify || request.notify,
+            includeGitHub: pending.includeGitHub || request.includeGitHub,
+            reason: upgradesForce || upgradesGitHub ? request.reason : pending.reason,
+            notify: pending.notify || request.notify,
         };
     }
     async runWorkspaceRefreshLoop(target, initialRequest) {

package/dist/server/server/workspace-reconciliation-service.js

@@ -55,10 +55,7 @@ export class WorkspaceReconciliationService {
             return;
         this.running = true;
         try {
-            const result = await this.reconcile();
-            if (result.changesApplied.length > 0) {
-                this.logger.info({ changeCount: result.changesApplied.length, durationMs: result.durationMs }, "Reconciliation pass completed with changes");
-            }
+            await this.reconcile();
         }
         catch (error) {
             this.logger.error({ err: error }, "Reconciliation pass failed");
@@ -130,7 +127,15 @@ export class WorkspaceReconciliationService {
         if (changes.length > 0 && this.onChanges) {
             this.onChanges(changes);
         }
-        return { changesApplied: changes, durationMs: Date.now() - start };
+        const result = { changesApplied: changes, durationMs: Date.now() - start };
+        if (changes.length > 0) {
+            this.logger.info({
+                changeCount: changes.length,
+                durationMs: result.durationMs,
+                changes,
+            }, "Workspace reconciliation applied changes");
+        }
+        return result;
     }
     async mergeDuplicateProjectsByRoot(activeProjects, workspacesByProject, changes) {
         const projectsByRoot = new Map();

package/dist/server/services/github-service.d.ts

@@ -47,6 +47,8 @@ export interface PullRequestCheck {
     url: string | null;
     workflow?: string;
     duration?: string;
+    checkRunId?: number;
+    workflowRunId?: number;
 }
 export type PullRequestChecksStatus = "none" | "pending" | "success" | "failure";
 export type PullRequestReviewDecision = "approved" | "changes_requested" | "pending" | null;
@@ -94,6 +96,7 @@ interface PullRequestTimelineItemBase {
     id: string;
     author: string;
     authorUrl: string | null;
+    avatarUrl: string | null;
     body: string;
     createdAt: number;
     url: string;
@@ -103,7 +106,17 @@ export type PullRequestTimelineItem = (PullRequestTimelineItemBase & {
     reviewState: PullRequestTimelineReviewState;
 }) | (PullRequestTimelineItemBase & {
     kind: "comment";
+    reviewId?: string;
+    location?: PullRequestTimelineCommentLocation;
 });
+export interface PullRequestTimelineCommentLocation {
+    path: string;
+    line?: number;
+    startLine?: number;
+    threadId?: string;
+    isResolved?: boolean;
+    isOutdated?: boolean;
+}
 export type GitHubPullRequestTimelineErrorKind = "not_found" | "forbidden" | "unknown";
 export interface GitHubPullRequestTimelineError {
     kind: GitHubPullRequestTimelineErrorKind;
@@ -176,6 +189,49 @@ export type GetGitHubPullRequestTimelineOptions = {
     repoOwner: string;
     repoName: string;
 } & GitHubReadOptions;
+export type GetGitHubCheckDetailsOptions = {
+    cwd: string;
+    repoOwner: string;
+    repoName: string;
+    checkRunId: number;
+    workflowRunId?: number;
+} & GitHubReadOptions;
+export interface GitHubCheckAnnotation {
+    path?: string;
+    startLine?: number;
+    endLine?: number;
+    annotationLevel?: string;
+    message?: string;
+    title?: string;
+    rawDetails?: string;
+}
+export interface GitHubCheckFailedJob {
+    jobId: number;
+    name: string;
+    status?: string | null;
+    conclusion?: string | null;
+    url?: string | null;
+    completedAt?: string;
+    logTail?: string;
+    logTruncated?: boolean;
+}
+export interface GitHubCheckDetails {
+    checkRunId: number;
+    workflowRunId?: number | null;
+    name: string;
+    status?: string | null;
+    conclusion?: string | null;
+    url?: string | null;
+    detailsUrl?: string | null;
+    output?: {
+        title?: string | null;
+        summary?: string | null;
+        text?: string | null;
+    } | null;
+    annotations: GitHubCheckAnnotation[];
+    failedJobs: GitHubCheckFailedJob[];
+    truncated: boolean;
+}
 export interface GitHubSearchResult {
     items: Array<{
         kind: "issue" | "pr";
@@ -217,6 +273,7 @@ export interface GitHubService {
         headRepositoryOwner?: string;
     } & GitHubReadOptions): Promise<GitHubCurrentPullRequestStatus | null>;
     getPullRequestTimeline(options: GetGitHubPullRequestTimelineOptions): Promise<GitHubPullRequestTimeline>;
+    getGitHubCheckDetails(options: GetGitHubCheckDetailsOptions): Promise<GitHubCheckDetails>;
     searchIssuesAndPrs(options: SearchGitHubIssuesAndPrsOptions): Promise<GitHubSearchResult>;
     createPullRequest(options: CreateGitHubPullRequestOptions): Promise<GitHubPullRequestCreateResult>;
     mergePullRequest(options: MergeGitHubPullRequestOptions): Promise<GitHubPullRequestMergeResult>;