@getpaseo/server 0.1.93 → 0.1.94

package/dist/server/services/github-service.js

@@ -4,6 +4,12 @@ import { resolveGitHubRemote } from "../utils/github-remote.js";
 import { runGitCommand } from "../utils/run-git-command.js";
 import { execCommand } from "../utils/spawn.js";
 const DEFAULT_GITHUB_CACHE_TTL_MS = 30000;
+const CHECK_ANNOTATION_PAGE_MAX = 20;
+const CHECK_LOG_TAIL_MAX_LINES = 200;
+const CHECK_LOG_TAIL_MAX_BYTES = 16 * 1024;
+const CHECK_LOG_TAIL_CACHE_MAX_ENTRIES = 128;
+const ACTIONS_JOB_PAGE_MAX = 100;
+const FAILED_CHECK_JOB_LIMIT = 5;
 export const GITHUB_POLL_FAST_INTERVAL_MS = 20000;
 export const GITHUB_POLL_SLOW_INTERVAL_MS = 120000;
 export const GITHUB_POLL_ERROR_BACKOFF_CAP_MS = 300000;
@@ -35,6 +41,7 @@ const GitHubPullRequestSummarySchema = z.object({
 });
 const PullRequestCheckRunNodeSchema = z.object({
     __typename: z.literal("CheckRun"),
+    databaseId: z.number().nullable().optional(),
     name: z.string(),
     workflowName: z.string().nullable().optional(),
     conclusion: z.string().nullable().optional(),
@@ -69,6 +76,54 @@ const PullRequestStatusCheckRollupArraySchema = z.array(z.unknown());
 const LegacyPullRequestStatusCheckRollupSchema = z.object({
     contexts: z.array(z.unknown()),
 });
+const GitHubCheckRunDetailsSchema = z.object({
+    id: z.number(),
+    name: z.string().catch(""),
+    status: z.string().nullable().optional(),
+    conclusion: z.string().nullable().optional(),
+    html_url: z.string().nullable().optional(),
+    details_url: z.string().nullable().optional(),
+    output: z
+        .object({
+        title: z.string().nullable().optional(),
+        summary: z.string().nullable().optional(),
+        text: z.string().nullable().optional(),
+    })
+        .nullable()
+        .optional(),
+    check_suite: z
+        .object({
+        workflow_run: z
+            .object({
+            id: z.number().nullable().optional(),
+        })
+            .nullable()
+            .optional(),
+    })
+        .nullable()
+        .optional(),
+});
+const GitHubCheckAnnotationSchema = z.object({
+    path: z.string().optional(),
+    start_line: z.number().optional(),
+    end_line: z.number().optional(),
+    annotation_level: z.string().optional(),
+    message: z.string().optional(),
+    title: z.string().optional(),
+    raw_details: z.string().optional(),
+});
+const GitHubCheckAnnotationsSchema = z.array(GitHubCheckAnnotationSchema).catch([]);
+const GitHubActionsJobSchema = z.object({
+    id: z.number(),
+    name: z.string().catch(""),
+    status: z.string().nullable().optional(),
+    conclusion: z.string().nullable().optional(),
+    html_url: z.string().nullable().optional(),
+    completed_at: z.string().nullable().optional(),
+});
+const GitHubActionsJobsSchema = z.object({
+    jobs: z.array(GitHubActionsJobSchema).catch([]),
+});
 const PullRequestReviewDecisionSchema = z
     .enum(["APPROVED", "CHANGES_REQUESTED", "REVIEW_REQUIRED"])
     .nullable()
@@ -142,6 +197,7 @@ const TimelineAuthorSchema = z
     .object({
     login: z.string().optional(),
     url: z.string().nullable().optional(),
+    avatarUrl: z.string().nullable().optional(),
 })
     .nullable()
     .optional();
@@ -160,6 +216,27 @@ const PullRequestTimelineCommentNodeSchema = z.object({
     createdAt: z.string().nullable().catch(null),
     author: TimelineAuthorSchema,
 });
+const PullRequestReviewThreadCommentNodeSchema = PullRequestTimelineCommentNodeSchema.extend({
+    pullRequestReview: z
+        .object({ id: z.string().catch("") })
+        .nullable()
+        .optional()
+        .catch(null),
+});
+const PullRequestReviewThreadNodeSchema = z.object({
+    id: z.string().catch(""),
+    path: z.string().catch(""),
+    line: z.number().nullable().optional().catch(null),
+    startLine: z.number().nullable().optional().catch(null),
+    isResolved: z.boolean().catch(false),
+    isOutdated: z.boolean().catch(false),
+    comments: z
+        .object({
+        nodes: z.array(PullRequestReviewThreadCommentNodeSchema).catch([]),
+        pageInfo: z.object({ hasNextPage: z.boolean().catch(false) }).catch({ hasNextPage: false }),
+    })
+        .catch({ nodes: [], pageInfo: { hasNextPage: false } }),
+});
 const PullRequestTimelinePageInfoSchema = z.object({
     hasNextPage: z.boolean().catch(false),
 });
@@ -183,6 +260,12 @@ const PullRequestTimelineGraphqlSchema = z.object({
                     pageInfo: PullRequestTimelinePageInfoSchema.catch({ hasNextPage: false }),
                 })
                     .catch({ nodes: [], pageInfo: { hasNextPage: false } }),
+                reviewThreads: z
+                    .object({
+                    nodes: z.array(PullRequestReviewThreadNodeSchema).catch([]),
+                    pageInfo: PullRequestTimelinePageInfoSchema.catch({ hasNextPage: false }),
+                })
+                    .catch({ nodes: [], pageInfo: { hasNextPage: false } }),
             })
                 .nullable()
                 .optional(),
@@ -301,6 +384,7 @@ query PullRequestTimeline($owner: String!, $name: String!, $number: Int!) {
           author {
             login
             url
+            avatarUrl
           }
         }
         pageInfo {
@@ -316,6 +400,39 @@ query PullRequestTimeline($owner: String!, $name: String!, $number: Int!) {
           author {
             login
             url
+            avatarUrl
+          }
+        }
+        pageInfo {
+          hasNextPage
+        }
+      }
+      reviewThreads(first: 100) {
+        nodes {
+          id
+          path
+          line
+          startLine
+          isResolved
+          isOutdated
+          comments(first: 100) {
+            nodes {
+              id
+              body
+              url
+              createdAt
+              author {
+                login
+                url
+                avatarUrl
+              }
+              pullRequestReview {
+                id
+              }
+            }
+            pageInfo {
+              hasNextPage
+            }
           }
         }
         pageInfo {
@@ -362,6 +479,7 @@ export function createGitHubService(options = {}) {
     const cache = new Map();
     const inFlight = new Map();
     const pollTargets = new Map();
+    const checkLogTailCache = new Map();
     let api;
     async function cached(params) {
         if (params.readOptions?.force && !params.readOptions.reason) {
@@ -651,6 +769,79 @@ export function createGitHubService(options = {}) {
                 },
             });
         },
+        getGitHubCheckDetails(input) {
+            return cached({
+                cwd: input.cwd,
+                method: "getGitHubCheckDetails",
+                args: {
+                    repoOwner: input.repoOwner,
+                    repoName: input.repoName,
+                    checkRunId: input.checkRunId,
+                    workflowRunId: input.workflowRunId,
+                },
+                readOptions: input,
+                load: async () => {
+                    const repoPath = `repos/${input.repoOwner}/${input.repoName}`;
+                    const checkRun = parseGitHubCheckRunDetails(await run(["api", `${repoPath}/check-runs/${input.checkRunId}`], { cwd: input.cwd }));
+                    const annotations = parseGitHubCheckAnnotations(await run([
+                        "api",
+                        `${repoPath}/check-runs/${input.checkRunId}/annotations`,
+                        "-f",
+                        `per_page=${CHECK_ANNOTATION_PAGE_MAX}`,
+                    ], {
+                        cwd: input.cwd,
+                    }));
+                    const workflowRunId = input.workflowRunId ?? checkRun.workflowRunId ?? null;
+                    const failedJobs = [];
+                    let truncated = annotations.length >= CHECK_ANNOTATION_PAGE_MAX;
+                    if (typeof workflowRunId === "number") {
+                        const jobs = parseGitHubActionsJobs(await run([
+                            "api",
+                            `${repoPath}/actions/runs/${workflowRunId}/jobs`,
+                            "-f",
+                            `per_page=${ACTIONS_JOB_PAGE_MAX}`,
+                        ], {
+                            cwd: input.cwd,
+                        }));
+                        const failed = jobs.filter(isFailedActionsJob);
+                        truncated || (truncated = jobs.length >= ACTIONS_JOB_PAGE_MAX);
+                        truncated || (truncated = failed.length > FAILED_CHECK_JOB_LIMIT);
+                        for (const job of failed.slice(0, FAILED_CHECK_JOB_LIMIT)) {
+                            const log = await getCachedCheckLogTail({
+                                cwd: input.cwd,
+                                repoPath,
+                                job,
+                                run,
+                                cache: checkLogTailCache,
+                            });
+                            truncated || (truncated = log.logTruncated);
+                            failedJobs.push({
+                                jobId: job.jobId,
+                                name: job.name,
+                                status: job.status,
+                                conclusion: job.conclusion,
+                                url: job.url,
+                                logTail: log.logTail,
+                                logTruncated: log.logTruncated,
+                            });
+                        }
+                    }
+                    return {
+                        checkRunId: checkRun.checkRunId,
+                        workflowRunId,
+                        name: checkRun.name,
+                        status: checkRun.status,
+                        conclusion: checkRun.conclusion,
+                        url: checkRun.url,
+                        detailsUrl: checkRun.detailsUrl,
+                        output: checkRun.output,
+                        annotations,
+                        failedJobs,
+                        truncated,
+                    };
+                },
+            });
+        },
         async searchIssuesAndPrs(input) {
             if (input.force && !input.reason) {
                 throw new Error("GitHubService forced read requires a reason");
@@ -1356,10 +1547,17 @@ function parseIssueSummaries(stdout) {
 function parsePullRequestTimeline(stdout, identity) {
     const parsed = PullRequestTimelineGraphqlSchema.parse(JSON.parse(stdout || "{}"));
     const pullRequest = parsed.data?.repository?.pullRequest;
+    const reviewThreadItems = pullRequest
+        ? pullRequest.reviewThreads.nodes.flatMap(toPullRequestTimelineReviewThreadItems)
+        : [];
+    const reviewThreadItemIds = new Set(reviewThreadItems.map((item) => item.id).filter((id) => id.length > 0));
     const items = pullRequest
         ? [
             ...pullRequest.reviews.nodes.flatMap(toPullRequestTimelineReviewItem),
-            ...pullRequest.comments.nodes.map(toPullRequestTimelineCommentItem),
+            ...pullRequest.comments.nodes
+                .filter((comment) => !reviewThreadItemIds.has(comment.id))
+                .map(toPullRequestTimelineCommentItem),
+            ...reviewThreadItems,
         ].sort(compareTimelineItems)
         : [];
     return {
@@ -1367,8 +1565,11 @@ function parsePullRequestTimeline(stdout, identity) {
         repoOwner: identity.repoOwner,
         repoName: identity.repoName,
         items,
-        // S3 deliberately caps timeline fetches at the first 100 reviews and first 100 comments.
-        truncated: Boolean(pullRequest?.reviews.pageInfo.hasNextPage || pullRequest?.comments.pageInfo.hasNextPage),
+        // S3 deliberately caps timeline fetches at the first 100 reviews, comments, and review threads.
+        truncated: Boolean(pullRequest?.reviews.pageInfo.hasNextPage ||
+            pullRequest?.comments.pageInfo.hasNextPage ||
+            pullRequest?.reviewThreads.pageInfo.hasNextPage ||
+            pullRequest?.reviewThreads.nodes.some((thread) => thread.comments.pageInfo.hasNextPage)),
         error: pullRequest ? null : { kind: "not_found", message: "Pull request not found" },
     };
 }
@@ -1383,6 +1584,7 @@ function toPullRequestTimelineReviewItem(review) {
             id: review.id,
             author: review.author?.login ?? "unknown",
             authorUrl: review.author?.url ?? null,
+            avatarUrl: review.author?.avatarUrl ?? null,
             body: review.body ?? "",
             createdAt: parseOptionalTime(review.submittedAt ?? null),
             url: review.url,
@@ -1396,11 +1598,129 @@ function toPullRequestTimelineCommentItem(comment) {
         id: comment.id,
         author: comment.author?.login ?? "unknown",
         authorUrl: comment.author?.url ?? null,
+        avatarUrl: comment.author?.avatarUrl ?? null,
         body: comment.body ?? "",
         createdAt: parseOptionalTime(comment.createdAt ?? null),
         url: comment.url,
     };
 }
+function toPullRequestTimelineReviewThreadItems(thread) {
+    return thread.comments.nodes.map((comment) => ({
+        ...toPullRequestTimelineCommentItem(comment),
+        ...(comment.pullRequestReview?.id ? { reviewId: comment.pullRequestReview.id } : {}),
+        location: {
+            path: thread.path,
+            ...(thread.line !== null && thread.line !== undefined ? { line: thread.line } : {}),
+            ...(thread.startLine !== null && thread.startLine !== undefined
+                ? { startLine: thread.startLine }
+                : {}),
+            ...(thread.id ? { threadId: thread.id } : {}),
+            isResolved: thread.isResolved,
+            isOutdated: thread.isOutdated,
+        },
+    }));
+}
+function parseGitHubCheckRunDetails(stdout) {
+    const parsed = GitHubCheckRunDetailsSchema.parse(JSON.parse(stdout || "{}"));
+    return {
+        checkRunId: parsed.id,
+        workflowRunId: parsed.check_suite?.workflow_run?.id ?? null,
+        name: parsed.name,
+        status: parsed.status,
+        conclusion: parsed.conclusion,
+        url: parsed.html_url,
+        detailsUrl: parsed.details_url,
+        output: parsed.output,
+        annotations: [],
+        failedJobs: [],
+        truncated: false,
+    };
+}
+function parseGitHubCheckAnnotations(stdout) {
+    return GitHubCheckAnnotationsSchema.parse(JSON.parse(stdout || "[]")).map((annotation) => {
+        const result = {};
+        if (annotation.path)
+            result.path = annotation.path;
+        if (annotation.start_line !== undefined)
+            result.startLine = annotation.start_line;
+        if (annotation.end_line !== undefined)
+            result.endLine = annotation.end_line;
+        if (annotation.annotation_level)
+            result.annotationLevel = annotation.annotation_level;
+        if (annotation.message)
+            result.message = annotation.message;
+        if (annotation.title)
+            result.title = annotation.title;
+        if (annotation.raw_details)
+            result.rawDetails = annotation.raw_details;
+        return result;
+    });
+}
+function parseGitHubActionsJobs(stdout) {
+    return GitHubActionsJobsSchema.parse(JSON.parse(stdout || "{}")).jobs.map((job) => {
+        const result = {
+            jobId: job.id,
+            name: job.name,
+            status: job.status,
+            conclusion: job.conclusion,
+            url: job.html_url,
+        };
+        if (job.completed_at)
+            result.completedAt = job.completed_at;
+        return result;
+    });
+}
+function isFailedActionsJob(job) {
+    return (job.conclusion === "failure" ||
+        job.conclusion === "cancelled" ||
+        job.conclusion === "timed_out" ||
+        job.conclusion === "action_required");
+}
+async function getCachedCheckLogTail(input) {
+    const key = `${input.job.jobId}:${input.job.completedAt ?? ""}`;
+    const cached = input.cache.get(key);
+    if (cached) {
+        input.cache.delete(key);
+        input.cache.set(key, cached);
+        return cached;
+    }
+    const capped = capCheckLogTail(await input.run(["api", `${input.repoPath}/actions/jobs/${input.job.jobId}/logs`], {
+        cwd: input.cwd,
+    }));
+    input.cache.set(key, capped);
+    while (input.cache.size > CHECK_LOG_TAIL_CACHE_MAX_ENTRIES) {
+        const oldestKey = input.cache.keys().next().value;
+        if (!oldestKey) {
+            break;
+        }
+        input.cache.delete(oldestKey);
+    }
+    return capped;
+}
+function capCheckLogTail(log) {
+    const lines = log.split("\n");
+    let truncated = lines.length > CHECK_LOG_TAIL_MAX_LINES;
+    let tail = lines.slice(-CHECK_LOG_TAIL_MAX_LINES).join("\n");
+    if (Buffer.byteLength(tail, "utf8") > CHECK_LOG_TAIL_MAX_BYTES) {
+        truncated = true;
+        tail = utf8SuffixWithinBytes(tail, CHECK_LOG_TAIL_MAX_BYTES);
+    }
+    return { logTail: tail, logTruncated: truncated };
+}
+function utf8SuffixWithinBytes(value, maxBytes) {
+    let lowerBound = 0;
+    let upperBound = value.length;
+    while (lowerBound < upperBound) {
+        const midpoint = Math.floor((lowerBound + upperBound) / 2);
+        if (Buffer.byteLength(value.slice(midpoint), "utf8") > maxBytes) {
+            lowerBound = midpoint + 1;
+        }
+        else {
+            upperBound = midpoint;
+        }
+    }
+    return value.slice(lowerBound);
+}
 function mapTimelineReviewState(state, body) {
     switch (state) {
         case "APPROVED":
@@ -1541,6 +1861,10 @@ function buildPullRequestCheck(context) {
             ...(typeof context.workflowName === "string" && context.workflowName.trim().length > 0
                 ? { workflow: context.workflowName }
                 : {}),
+            ...(typeof context.databaseId === "number" ? { checkRunId: context.databaseId } : {}),
+            ...(typeof context.checkSuite?.workflowRun?.databaseId === "number"
+                ? { workflowRunId: context.checkSuite.workflowRun.databaseId }
+                : {}),
             ...formatCheckRunDuration(context),
             recency: getCheckRunRecency(context),
         };

package/dist/server/terminal/terminal-session-controller.d.ts

@@ -9,6 +9,7 @@ export interface TerminalSessionControllerOptions {
     hasBinaryChannel: () => boolean;
     isPathWithinRoot: (rootPath: string, candidatePath: string) => boolean;
     sessionLogger: pino.Logger;
+    listTerminalWorkspaceRoots?: () => Promise<readonly string[]>;
     clientSupportsWrapReflow?: () => boolean;
 }
 export interface TerminalSessionControllerMetrics {
@@ -22,6 +23,7 @@ export declare class TerminalSessionController {
     private readonly hasBinaryChannel;
     private readonly isPathWithinRoot;
     private readonly sessionLogger;
+    private readonly listTerminalWorkspaceRoots;
     private readonly clientSupportsWrapReflow;
     private readonly subscribedDirectories;
     private unsubscribeTerminalsChanged;
@@ -50,6 +52,10 @@ export declare class TerminalSessionController {
     private emitTerminalsSnapshotForRoot;
     private handleListTerminalsRequest;
     private getAllTerminalSessions;
+    private getTerminalsForWorkspaceRoot;
+    private terminalBelongsToRoot;
+    private resolveTerminalOwnerRoot;
+    private isSamePath;
     private handleCreateTerminalRequest;
     private handleRenameTerminalRequest;
     private handleSubscribeTerminalRequest;

package/dist/server/terminal/terminal-session-controller.js

@@ -29,6 +29,7 @@ export class TerminalSessionController {
         this.hasBinaryChannel = options.hasBinaryChannel;
         this.isPathWithinRoot = options.isPathWithinRoot;
         this.sessionLogger = options.sessionLogger;
+        this.listTerminalWorkspaceRoots = options.listTerminalWorkspaceRoots ?? (async () => []);
         this.clientSupportsWrapReflow = options.clientSupportsWrapReflow ?? (() => false);
     }
     start() {
@@ -199,7 +200,7 @@ export class TerminalSessionController {
             return;
         }
         try {
-            const terminals = await this.terminalManager.getTerminals(cwd);
+            const terminals = await this.getTerminalsForWorkspaceRoot(cwd);
             for (const terminal of terminals) {
                 this.ensureExitSubscription(terminal);
             }
@@ -229,7 +230,7 @@ export class TerminalSessionController {
         }
         try {
             const terminals = typeof msg.cwd === "string"
-                ? await this.terminalManager.getTerminals(msg.cwd)
+                ? await this.getTerminalsForWorkspaceRoot(msg.cwd)
                 : await this.getAllTerminalSessions();
             for (const terminal of terminals) {
                 this.ensureExitSubscription(terminal);
@@ -264,6 +265,39 @@ export class TerminalSessionController {
         const terminalsByDirectory = await Promise.all(directories.map((cwd) => manager.getTerminals(cwd)));
         return terminalsByDirectory.flat();
     }
+    async getTerminalsForWorkspaceRoot(cwd) {
+        if (!this.terminalManager) {
+            return [];
+        }
+        const terminals = await this.terminalManager.getTerminals(cwd);
+        const workspaceRoots = await this.listTerminalWorkspaceRoots();
+        if (workspaceRoots.length === 0) {
+            return terminals;
+        }
+        return terminals.filter((terminal) => this.terminalBelongsToRoot(cwd, terminal.cwd, workspaceRoots));
+    }
+    terminalBelongsToRoot(rootCwd, terminalCwd, workspaceRoots) {
+        const ownerRoot = this.resolveTerminalOwnerRoot(terminalCwd, workspaceRoots);
+        if (!ownerRoot) {
+            return this.isPathWithinRoot(rootCwd, terminalCwd);
+        }
+        return this.isSamePath(rootCwd, ownerRoot);
+    }
+    resolveTerminalOwnerRoot(terminalCwd, workspaceRoots) {
+        let ownerRoot = null;
+        for (const workspaceRoot of workspaceRoots) {
+            if (!this.isPathWithinRoot(workspaceRoot, terminalCwd)) {
+                continue;
+            }
+            if (!ownerRoot || workspaceRoot.length > ownerRoot.length) {
+                ownerRoot = workspaceRoot;
+            }
+        }
+        return ownerRoot;
+    }
+    isSamePath(firstPath, secondPath) {
+        return (this.isPathWithinRoot(firstPath, secondPath) && this.isPathWithinRoot(secondPath, firstPath));
+    }
     async handleCreateTerminalRequest(msg) {
         if (!this.terminalManager) {
             this.emit({

package/dist/src/server/persisted-config.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { z } from "zod";
 import { AgentProviderRuntimeSettingsMapSchema, migrateProviderSettings, ProviderOverridesSchema, } from "./agent/provider-launch-config.js";
 import { ensurePrivateFile, writePrivateFileAtomicSync } from "./private-files.js";
+import { TerminalProfileSchema } from "@getpaseo/protocol/messages";
 export const LogLevelSchema = z.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
 export const LogFormatSchema = z.enum(["pretty", "json"]);
 const LogConfigSchema = z
@@ -187,6 +188,7 @@ export const PersistedConfigSchema = z
             .optional(),
         autoArchiveAfterMerge: z.boolean().optional(),
         appendSystemPrompt: z.string().optional(),
+        terminalProfiles: z.array(TerminalProfileSchema).optional(),
         cors: z
             .object({
             allowedOrigins: z.array(z.string()).optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/server",
-  "version": "0.1.93",
+  "version": "0.1.94",
   "description": "Paseo backend server",
   "files": [
     "dist/server",
@@ -59,10 +59,10 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.17.1",
     "@anthropic-ai/claude-agent-sdk": "^0.2.133",
-    "@getpaseo/client": "0.1.93",
-    "@getpaseo/highlight": "0.1.93",
-    "@getpaseo/protocol": "0.1.93",
-    "@getpaseo/relay": "0.1.93",
+    "@getpaseo/client": "0.1.94",
+    "@getpaseo/highlight": "0.1.94",
+    "@getpaseo/protocol": "0.1.94",
+    "@getpaseo/relay": "0.1.94",
     "@isaacs/ttlcache": "^2.1.4",
     "@modelcontextprotocol/sdk": "^1.20.1",
     "@opencode-ai/sdk": "1.14.46",