@getpaseo/server 0.1.93 → 0.1.95

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();
@@ -149,6 +205,7 @@ const PullRequestTimelineReviewNodeSchema = z.object({
     id: z.string().catch(""),
     state: z.string().catch(""),
     body: z.string().nullable().catch(null),
+    bodyHTML: z.string().nullable().catch(null),
     url: z.string().catch(""),
     submittedAt: z.string().nullable().catch(null),
     author: TimelineAuthorSchema,
@@ -156,10 +213,32 @@ const PullRequestTimelineReviewNodeSchema = z.object({
 const PullRequestTimelineCommentNodeSchema = z.object({
     id: z.string().catch(""),
     body: z.string().nullable().catch(null),
+    bodyHTML: z.string().nullable().catch(null),
     url: z.string().catch(""),
     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 +262,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(),
@@ -296,11 +381,13 @@ query PullRequestTimeline($owner: String!, $name: String!, $number: Int!) {
           id
           state
           body
+          bodyHTML
           url
           submittedAt
           author {
             login
             url
+            avatarUrl
           }
         }
         pageInfo {
@@ -311,11 +398,46 @@ query PullRequestTimeline($owner: String!, $name: String!, $number: Int!) {
         nodes {
           id
           body
+          bodyHTML
           url
           createdAt
           author {
             login
             url
+            avatarUrl
+          }
+        }
+        pageInfo {
+          hasNextPage
+        }
+      }
+      reviewThreads(first: 100) {
+        nodes {
+          id
+          path
+          line
+          startLine
+          isResolved
+          isOutdated
+          comments(first: 100) {
+            nodes {
+              id
+              body
+              bodyHTML
+              url
+              createdAt
+              author {
+                login
+                url
+                avatarUrl
+              }
+              pullRequestReview {
+                id
+              }
+            }
+            pageInfo {
+              hasNextPage
+            }
           }
         }
         pageInfo {
@@ -362,6 +484,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 +774,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 +1552,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 +1570,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,7 +1589,8 @@ function toPullRequestTimelineReviewItem(review) {
             id: review.id,
             author: review.author?.login ?? "unknown",
             authorUrl: review.author?.url ?? null,
-            body: review.body ?? "",
+            avatarUrl: review.author?.avatarUrl ?? null,
+            body: normalizeGitHubTimelineBody(review.body ?? "", review.bodyHTML ?? ""),
             createdAt: parseOptionalTime(review.submittedAt ?? null),
             url: review.url,
             reviewState,
@@ -1396,11 +1603,229 @@ function toPullRequestTimelineCommentItem(comment) {
         id: comment.id,
         author: comment.author?.login ?? "unknown",
         authorUrl: comment.author?.url ?? null,
-        body: comment.body ?? "",
+        avatarUrl: comment.author?.avatarUrl ?? null,
+        body: normalizeGitHubTimelineBody(comment.body ?? "", comment.bodyHTML ?? ""),
         createdAt: parseOptionalTime(comment.createdAt ?? null),
         url: comment.url,
     };
 }
+const RAW_MARKDOWN_IMAGE_RE = /!\[[^\]]*\]\(\s*([^\s)]+)(?:\s+["'][^)]*["'])?\s*\)/g;
+const HTML_IMAGE_RE = /<img\b[^>]*\bsrc\s*=\s*(["'])(.*?)\1[^>]*>/gi;
+const GITHUB_RENDERED_IMAGE_HOSTS = new Set([
+    "camo.githubusercontent.com",
+    "private-user-images.githubusercontent.com",
+]);
+function normalizeGitHubTimelineBody(body, bodyHTML) {
+    const rawImages = extractRawImageSourceReferences(body);
+    if (rawImages.length === 0) {
+        return body;
+    }
+    const renderedSources = extractRenderedImageSources(bodyHTML);
+    if (renderedSources.length !== rawImages.length) {
+        return body;
+    }
+    let cursor = 0;
+    let normalized = "";
+    for (let index = 0; index < rawImages.length; index += 1) {
+        const rawImage = rawImages[index];
+        const renderedSrc = renderedSources[index];
+        if (!rawImage ||
+            !renderedSrc ||
+            !isRawGitHubAttachmentSource(rawImage.src) ||
+            !isGitHubRenderedImageSource(renderedSrc)) {
+            return body;
+        }
+        normalized += body.slice(cursor, rawImage.start);
+        normalized += renderedSrc;
+        cursor = rawImage.end;
+    }
+    normalized += body.slice(cursor);
+    return normalized;
+}
+function extractRawImageSourceReferences(source) {
+    const references = [
+        ...extractHtmlImageSourceReferences(source),
+        ...extractMarkdownImageSourceReferences(source),
+    ];
+    return references.sort((left, right) => left.start - right.start);
+}
+function extractRenderedImageSources(source) {
+    return extractHtmlImageSourceReferences(source).map((reference) => reference.src);
+}
+function extractHtmlImageSourceReferences(source) {
+    const references = [];
+    HTML_IMAGE_RE.lastIndex = 0;
+    let match;
+    while ((match = HTML_IMAGE_RE.exec(source)) !== null) {
+        const src = decodeHtmlAttribute(match[2] ?? "");
+        if (!src) {
+            continue;
+        }
+        const rawAttributeSrc = match[2] ?? "";
+        const start = match.index + match[0].indexOf(rawAttributeSrc);
+        references.push({ src, start, end: start + rawAttributeSrc.length });
+    }
+    return references;
+}
+function extractMarkdownImageSourceReferences(source) {
+    const references = [];
+    RAW_MARKDOWN_IMAGE_RE.lastIndex = 0;
+    let match;
+    while ((match = RAW_MARKDOWN_IMAGE_RE.exec(source)) !== null) {
+        const src = match[1] ?? "";
+        if (!src) {
+            continue;
+        }
+        const start = match.index + match[0].indexOf(src);
+        references.push({ src, start, end: start + src.length });
+    }
+    return references;
+}
+function isRawGitHubAttachmentSource(src) {
+    try {
+        const url = new URL(src);
+        return (url.protocol === "https:" &&
+            url.hostname === "github.com" &&
+            url.pathname.startsWith("/user-attachments/assets/"));
+    }
+    catch {
+        return false;
+    }
+}
+function isGitHubRenderedImageSource(src) {
+    try {
+        const url = new URL(src);
+        return url.protocol === "https:" && GITHUB_RENDERED_IMAGE_HOSTS.has(url.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+function decodeHtmlAttribute(value) {
+    return value
+        .replaceAll("&amp;", "&")
+        .replaceAll("&quot;", '"')
+        .replaceAll("&#39;", "'")
+        .replaceAll("&lt;", "<")
+        .replaceAll("&gt;", ">");
+}
+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 +1966,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(),