@getpaseo/server 0.1.101 → 0.1.102-beta.2

package/dist/server/services/quota-fetcher/providers/minimax.js

@@ -0,0 +1,227 @@
+import { existsSync, promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { ApiNumberSchema, ApiOptionalStringSchema, fetchProviderApi, unavailableUsage, windowFromUsedPct, } from "../usage.js";
+const MINIMAX_GLOBAL_BASE_URL = "https://api.minimax.io";
+const MINIMAX_CN_BASE_URL = "https://api.minimaxi.com";
+const MINIMAX_CREDENTIALS_PATH = join(homedir(), ".mmx", "credentials.json");
+const MINIMAX_CONFIG_PATH = join(homedir(), ".mmx", "config.json");
+const MiniMaxModelRemainSchema = z.object({
+    model_name: ApiOptionalStringSchema,
+    start_time: ApiNumberSchema.optional(),
+    end_time: ApiNumberSchema.optional(),
+    remains_time: ApiNumberSchema.optional(),
+    current_interval_total_count: ApiNumberSchema.optional(),
+    current_interval_usage_count: ApiNumberSchema.optional(),
+    current_interval_remaining_percent: ApiNumberSchema.optional(),
+    current_weekly_total_count: ApiNumberSchema.optional(),
+    current_weekly_usage_count: ApiNumberSchema.optional(),
+    current_weekly_remaining_percent: ApiNumberSchema.optional(),
+    current_interval_status: ApiNumberSchema.optional(),
+    current_weekly_status: ApiNumberSchema.optional(),
+    weekly_start_time: ApiNumberSchema.optional(),
+    weekly_end_time: ApiNumberSchema.optional(),
+    weekly_remains_time: ApiNumberSchema.optional(),
+    weekly_boost_permille: ApiNumberSchema.optional(),
+});
+const MiniMaxQuotaResponseSchema = z.object({
+    model_remains: z.array(MiniMaxModelRemainSchema).optional(),
+});
+const MiniMaxCredentialsSchema = z.object({
+    access_token: z.string().optional(),
+    refresh_token: z.string().optional(),
+    expires_at: ApiOptionalStringSchema,
+    resource_url: ApiOptionalStringSchema,
+});
+const MiniMaxConfigSchema = z.object({
+    api_key: z.string().optional(),
+    region: z.string().optional(),
+    base_url: ApiOptionalStringSchema,
+    oauth: MiniMaxCredentialsSchema.optional(),
+});
+function resolveBaseUrl(input) {
+    const explicit = input.baseUrl;
+    if (explicit && explicit.startsWith("http"))
+        return explicit;
+    if (input.region === "cn")
+        return MINIMAX_CN_BASE_URL;
+    return MINIMAX_GLOBAL_BASE_URL;
+}
+function computeUsedPct(remaining, total) {
+    if (typeof remaining !== "number" || typeof total !== "number")
+        return null;
+    if (!Number.isFinite(total) || total <= 0)
+        return null;
+    if (!Number.isFinite(remaining))
+        return null;
+    const used = total - remaining;
+    return Math.max(0, Math.min(100, (used / total) * 100));
+}
+function epochMsToIso(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+        return null;
+    return new Date(value).toISOString();
+}
+function toneForStatus(status) {
+    if (status === 2)
+        return "danger";
+    if (status === 3)
+        return "default";
+    return "ok";
+}
+function toIntervalWindow(modelName, model) {
+    const total = model.current_interval_total_count ?? null;
+    const used = model.current_interval_usage_count ?? null;
+    const remainingPercent = model.current_interval_remaining_percent ?? null;
+    const usedPct = typeof remainingPercent === "number" && Number.isFinite(remainingPercent)
+        ? Math.max(0, Math.min(100, 100 - remainingPercent))
+        : computeUsedPct(typeof total === "number" && typeof used === "number" ? total - used : null, total);
+    if (usedPct === null)
+        return null;
+    return windowFromUsedPct({
+        id: `interval_${modelName}`,
+        label: `${modelName} · Interval`,
+        utilizationPct: usedPct,
+        resetsAt: epochMsToIso(model.end_time),
+        tone: toneForStatus(model.current_interval_status),
+    });
+}
+function toWeeklyWindow(modelName, model) {
+    const total = model.current_weekly_total_count ?? null;
+    const used = model.current_weekly_usage_count ?? null;
+    const remainingPercent = model.current_weekly_remaining_percent ?? null;
+    let usedPct = null;
+    if (typeof remainingPercent === "number" && Number.isFinite(remainingPercent)) {
+        usedPct = Math.max(0, Math.min(100, 100 - remainingPercent));
+    }
+    else if (typeof total === "number" && typeof used === "number") {
+        usedPct = computeUsedPct(total - used, total);
+    }
+    if (usedPct === null)
+        return null;
+    return windowFromUsedPct({
+        id: `weekly_${modelName}`,
+        label: `${modelName} · Weekly`,
+        utilizationPct: usedPct,
+        resetsAt: epochMsToIso(model.weekly_end_time),
+        tone: toneForStatus(model.current_weekly_status),
+    });
+}
+export class MiniMaxQuotaProvider {
+    constructor(options) {
+        this.providerId = "minimax";
+        this.displayName = "MiniMax";
+        this.logger = options.logger;
+        this.fetchApi = options.fetch ?? fetch;
+        this.configPath = options.configPath ?? MINIMAX_CONFIG_PATH;
+        this.credentialsPath = options.credentialsPath ?? MINIMAX_CREDENTIALS_PATH;
+        this.env = options.env ?? process.env;
+        this.now = options.now ?? Date.now;
+    }
+    async fetchUsage() {
+        const auth = await this.resolveAuth();
+        if (!auth)
+            return unavailableUsage(this);
+        const res = await fetchProviderApi(this.fetchApi, `${auth.baseUrl}/v1/token_plan/remains`, {
+            headers: {
+                Authorization: `Bearer ${auth.token}`,
+                Accept: "application/json",
+            },
+        });
+        if (!res.ok) {
+            this.logger.debug({ status: res.status }, "MiniMax usage fetch failed");
+            return unavailableUsage(this);
+        }
+        const resp = MiniMaxQuotaResponseSchema.parse(await res.json());
+        const models = resp.model_remains ?? [];
+        const windows = [];
+        for (const model of models) {
+            const name = model.model_name ?? "token-plan";
+            const intervalWindow = toIntervalWindow(name, model);
+            if (intervalWindow)
+                windows.push(intervalWindow);
+            const weeklyWindow = toWeeklyWindow(name, model);
+            if (weeklyWindow)
+                windows.push(weeklyWindow);
+        }
+        return {
+            providerId: this.providerId,
+            displayName: this.displayName,
+            status: windows.length > 0 ? "available" : "unavailable",
+            planLabel: null,
+            windows,
+            balances: [],
+            details: [],
+            error: null,
+        };
+    }
+    async resolveAuth() {
+        const envToken = this.env["MINIMAX_API_KEY"];
+        if (envToken) {
+            const envBase = this.env["MINIMAX_BASE_URL"];
+            return {
+                token: envToken,
+                baseUrl: resolveBaseUrl({ baseUrl: envBase }),
+            };
+        }
+        const credentials = await this.readCredentials();
+        if (credentials?.access_token && !this.isExpired(credentials.expires_at)) {
+            return {
+                token: credentials.access_token,
+                baseUrl: resolveBaseUrl({ baseUrl: credentials.resource_url }),
+            };
+        }
+        const config = await this.readConfig();
+        if (config?.api_key) {
+            return {
+                token: config.api_key,
+                baseUrl: resolveBaseUrl({
+                    baseUrl: config.base_url,
+                    region: config.region,
+                }),
+            };
+        }
+        if (config?.oauth?.access_token && !this.isExpired(config.oauth.expires_at)) {
+            return {
+                token: config.oauth.access_token,
+                baseUrl: resolveBaseUrl({
+                    baseUrl: config.oauth.resource_url ?? config.base_url,
+                    region: config.region,
+                }),
+            };
+        }
+        return null;
+    }
+    isExpired(expiresAt) {
+        if (!expiresAt)
+            return false;
+        const parsed = Date.parse(expiresAt);
+        if (!Number.isFinite(parsed))
+            return false;
+        return parsed <= this.now();
+    }
+    async readCredentials() {
+        if (!existsSync(this.credentialsPath))
+            return null;
+        try {
+            const raw = JSON.parse(await fs.readFile(this.credentialsPath, "utf8"));
+            return MiniMaxCredentialsSchema.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    async readConfig() {
+        if (!existsSync(this.configPath))
+            return null;
+        try {
+            const raw = JSON.parse(await fs.readFile(this.configPath, "utf8"));
+            return MiniMaxConfigSchema.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=minimax.js.map

package/dist/server/terminal/agent-hooks/agent-hook-installer.js

@@ -42,11 +42,11 @@ function resolveAgentHookInstallPath(install, options) {
 }
 export function buildAgentHookShellCommand(provider, event) {
     const hookCommand = `"\${PASEO_HOOK_CLI:-paseo}" hooks ${shellToken(provider.id)} ${shellToken(event.event)}`;
-    return `[ -n "$PASEO_TERMINAL_ID" ] && ${hookCommand}`;
+    return `if [ -n "$PASEO_TERMINAL_ID" ]; then ${hookCommand}; fi`;
 }
 export function buildAgentHookWindowsCommand(provider, event) {
     const hookArgs = `hooks ${windowsToken(provider.id)} ${windowsToken(event.event)}`;
-    return `if defined PASEO_TERMINAL_ID (if defined PASEO_HOOK_CLI ("%PASEO_HOOK_CLI%" ${hookArgs}) else (paseo ${hookArgs}))`;
+    return `if defined PASEO_TERMINAL_ID (if defined PASEO_HOOK_CLI ("%PASEO_HOOK_CLI%" ${hookArgs}) else (paseo ${hookArgs})) else (exit /b 0)`;
 }
 function installAgentHookPluginFile(install, options) {
     const configPath = resolveAgentHookInstallPath(install, options);

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

@@ -723,6 +723,20 @@ async function getGitConfigValue(cwd, key, context) {
         return null;
     }
 }
+async function getGitRemotePushUrl(cwd, remoteName, context) {
+    try {
+        const { stdout } = await runGitCommand(["remote", "get-url", "--push", remoteName], {
+            cwd,
+            envOverlay: READ_ONLY_GIT_ENV,
+            logger: context?.logger,
+        });
+        const value = stdout.trim();
+        return value.length > 0 ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
 function parseBranchMergeHeadRef(mergeRef) {
     const prefix = "refs/heads/";
     if (!mergeRef?.startsWith(prefix)) {
@@ -749,14 +763,15 @@ async function resolvePullRequestStatusLookupTarget(cwd, currentBranch, context)
         resolvedBaseRef: null,
     });
     if (localBranchTarget.headRef === currentBranch) {
-        return localBranchTarget;
+        const pushTarget = await resolvePullRequestLookupTargetFromPushConfig(cwd, currentBranch, null, null, context);
+        return pushTarget ?? localBranchTarget;
     }
     const [branchRemoteUrl, originRemoteUrl, resolvedBaseRef] = await Promise.all([
         branchRemoteName ? getGitConfigValue(cwd, `remote.${branchRemoteName}.url`, context) : null,
         getGitConfigValue(cwd, "remote.origin.url", context),
         getResolvedBaseRefForCwd(cwd, context),
     ]);
-    return buildPullRequestLookupTargetFromBranchConfig({
+    const branchTarget = buildPullRequestLookupTargetFromBranchConfig({
         currentBranch,
         branchRemoteName,
         branchMergeRef,
@@ -764,6 +779,11 @@ async function resolvePullRequestStatusLookupTarget(cwd, currentBranch, context)
         originRemoteUrl,
         resolvedBaseRef,
     });
+    if (branchTarget.headRef !== currentBranch || branchTarget.headRepositoryOwner) {
+        return branchTarget;
+    }
+    const pushTarget = await resolvePullRequestLookupTargetFromPushConfig(cwd, currentBranch, originRemoteUrl, resolvedBaseRef, context);
+    return pushTarget ?? branchTarget;
 }
 export async function resolveAbsoluteGitDir(cwd) {
     try {
@@ -1054,6 +1074,48 @@ function buildPullRequestLookupTargetFromBranchConfig(input) {
         ...(headRepositoryOwner ? { headRepositoryOwner } : {}),
     };
 }
+function buildPullRequestLookupTargetFromPushConfig(input) {
+    const pushedHeadRef = parseHeadPushRefspec(input.pushRefspec);
+    if (!input.pushRemoteName || !pushedHeadRef || pushedHeadRef === input.currentBranch) {
+        return null;
+    }
+    const remoteRepo = input.pushRemoteUrl ? parseGitHubRepoFromRemote(input.pushRemoteUrl) : null;
+    const originRepo = input.originRemoteUrl
+        ? parseGitHubRepoFromRemote(input.originRemoteUrl)
+        : null;
+    const isSameRepo = Boolean(remoteRepo && originRepo && remoteRepo === originRepo);
+    const headRepositoryOwner = remoteRepo && !isSameRepo ? remoteRepo.split("/")[0] : null;
+    const normalizedBaseRef = input.resolvedBaseRef
+        ? normalizeLocalBranchRefName(input.resolvedBaseRef)
+        : null;
+    if (pushedHeadRef === normalizedBaseRef && !headRepositoryOwner) {
+        return null;
+    }
+    return {
+        headRef: pushedHeadRef,
+        ...(headRepositoryOwner ? { headRepositoryOwner } : {}),
+    };
+}
+async function resolvePullRequestLookupTargetFromPushConfig(cwd, currentBranch, knownOriginRemoteUrl, knownResolvedBaseRef, context) {
+    const pushRemoteName = await getGitConfigValue(cwd, `branch.${currentBranch}.pushRemote`, context);
+    if (!pushRemoteName) {
+        return null;
+    }
+    const [pushRefspec, pushRemoteUrl, originRemoteUrl, resolvedBaseRef] = await Promise.all([
+        getGitConfigValue(cwd, `remote.${pushRemoteName}.push`, context),
+        getGitConfigValue(cwd, `remote.${pushRemoteName}.url`, context),
+        knownOriginRemoteUrl === null ? getGitConfigValue(cwd, "remote.origin.url", context) : null,
+        knownResolvedBaseRef === null ? getResolvedBaseRefForCwd(cwd, context) : null,
+    ]);
+    return buildPullRequestLookupTargetFromPushConfig({
+        currentBranch,
+        pushRemoteName,
+        pushRefspec,
+        pushRemoteUrl,
+        originRemoteUrl: knownOriginRemoteUrl ?? originRemoteUrl,
+        resolvedBaseRef: knownResolvedBaseRef ?? resolvedBaseRef,
+    });
+}
 export async function getCheckoutSnapshotFacts(cwd, context) {
     if (context?.facts) {
         return context.facts;
@@ -1085,7 +1147,7 @@ export async function getCheckoutSnapshotFacts(cwd, context) {
             ]);
         }
     }
-    const pullRequestLookupTarget = inspected.currentBranch
+    let pullRequestLookupTarget = inspected.currentBranch
         ? buildPullRequestLookupTargetFromBranchConfig({
             currentBranch: inspected.currentBranch,
             branchRemoteName,
@@ -1095,6 +1157,12 @@ export async function getCheckoutSnapshotFacts(cwd, context) {
             resolvedBaseRef,
         })
         : null;
+    if (inspected.currentBranch &&
+        pullRequestLookupTarget?.headRef === inspected.currentBranch &&
+        !pullRequestLookupTarget.headRepositoryOwner) {
+        pullRequestLookupTarget =
+            (await resolvePullRequestLookupTargetFromPushConfig(cwd, inspected.currentBranch, inspected.remoteUrl, resolvedBaseRef, context)) ?? pullRequestLookupTarget;
+    }
     return {
         isGit: true,
         worktreeRoot: inspected.worktreeRoot,
@@ -1960,6 +2028,19 @@ export async function pushCurrentBranch(cwd, github) {
     if (!currentBranch || currentBranch === "HEAD") {
         throw new Error("Unable to determine current branch for push");
     }
+    const configuredPushTarget = await getCurrentBranchConfiguredPushTarget(cwd, currentBranch);
+    if (configuredPushTarget) {
+        await runGitCommand(["push", configuredPushTarget.remoteName, `HEAD:refs/heads/${configuredPushTarget.headRef}`], { cwd, timeout: 120000 });
+        await refreshCurrentBranchTrackedRefAfterPush(cwd, currentBranch, configuredPushTarget);
+        github?.invalidate({ cwd });
+        return;
+    }
+    const upstreamTarget = await getCurrentBranchUpstreamPushTarget(cwd, currentBranch);
+    if (upstreamTarget) {
+        await runGitCommand(["push", "-u", upstreamTarget.remoteName, `HEAD:refs/heads/${upstreamTarget.headRef}`], { cwd, timeout: 120000 });
+        github?.invalidate({ cwd });
+        return;
+    }
     const hasRemote = await hasOriginRemote(cwd);
     if (!hasRemote) {
         throw new Error("Remote 'origin' is not configured.");
@@ -1967,6 +2048,78 @@ export async function pushCurrentBranch(cwd, github) {
     await runGitCommand(["push", "-u", "origin", currentBranch], { cwd, timeout: 120000 });
     github?.invalidate({ cwd });
 }
+async function getCurrentBranchConfiguredPushTarget(cwd, currentBranch) {
+    const remoteName = await getGitConfigValue(cwd, `branch.${currentBranch}.pushRemote`);
+    const pushRefspec = remoteName ? await getGitConfigValue(cwd, `remote.${remoteName}.push`) : null;
+    const headRef = parseHeadPushRefspec(pushRefspec);
+    if (!remoteName || !headRef) {
+        return null;
+    }
+    const remoteUrl = await getGitConfigValue(cwd, `remote.${remoteName}.url`);
+    return remoteUrl ? { remoteName, headRef } : null;
+}
+async function refreshCurrentBranchTrackedRefAfterPush(cwd, currentBranch, pushedTarget) {
+    const trackingRemoteName = await getGitConfigValue(cwd, `branch.${currentBranch}.remote`);
+    const trackingMergeRef = await getGitConfigValue(cwd, `branch.${currentBranch}.merge`);
+    const trackingHeadRef = parseBranchMergeHeadRef(trackingMergeRef);
+    if (!trackingRemoteName && !trackingMergeRef) {
+        const updated = await updateRemoteTrackingRef(cwd, pushedTarget.remoteName, pushedTarget.headRef);
+        if (!updated) {
+            return;
+        }
+        await runGitCommand(["config", `branch.${currentBranch}.remote`, pushedTarget.remoteName], {
+            cwd,
+        });
+        await runGitCommand(["config", `branch.${currentBranch}.merge`, `refs/heads/${pushedTarget.headRef}`], {
+            cwd,
+        });
+        return;
+    }
+    if (!trackingRemoteName || trackingHeadRef !== pushedTarget.headRef) {
+        return;
+    }
+    const [trackingRemotePushUrl, pushedRemotePushUrl] = await Promise.all([
+        getGitRemotePushUrl(cwd, trackingRemoteName),
+        getGitRemotePushUrl(cwd, pushedTarget.remoteName),
+    ]);
+    if (!trackingRemotePushUrl || trackingRemotePushUrl !== pushedRemotePushUrl) {
+        return;
+    }
+    await updateRemoteTrackingRef(cwd, trackingRemoteName, trackingHeadRef);
+}
+async function updateRemoteTrackingRef(cwd, remoteName, headRef) {
+    const trackingRef = `refs/remotes/${remoteName}/${headRef}`;
+    const checkRef = await runGitCommand(["check-ref-format", trackingRef], {
+        cwd,
+        acceptExitCodes: [0, 1],
+    });
+    if (checkRef.exitCode !== 0) {
+        return false;
+    }
+    await runGitCommand(["update-ref", trackingRef, "HEAD"], { cwd, timeout: 120000 });
+    return true;
+}
+async function getCurrentBranchUpstreamPushTarget(cwd, currentBranch) {
+    const remoteName = await getGitConfigValue(cwd, `branch.${currentBranch}.remote`);
+    const mergeRef = remoteName
+        ? await getGitConfigValue(cwd, `branch.${currentBranch}.merge`)
+        : null;
+    const headRef = parseBranchMergeHeadRef(mergeRef);
+    if (!remoteName || !headRef) {
+        return null;
+    }
+    const remoteUrl = await getGitConfigValue(cwd, `remote.${remoteName}.url`);
+    return remoteUrl ? { remoteName, headRef } : null;
+}
+function parseHeadPushRefspec(refspec) {
+    const prefix = "HEAD:refs/heads/";
+    const normalized = refspec?.trim().replace(/^\+/, "");
+    if (!normalized?.startsWith(prefix)) {
+        return null;
+    }
+    const headRef = normalized.slice(prefix.length).trim();
+    return headRef.length > 0 ? headRef : null;
+}
 export async function createPullRequest(cwd, options, github = createGitHubService(), context) {
     await requireGitRepo(cwd);
     const repo = await resolveGitHubRepo(cwd);

package/dist/server/utils/directory-suggestions.js

@@ -1,5 +1,6 @@
 import { readdir, realpath, stat } from "node:fs/promises";
 import path from "node:path";
+import { isPathInsideRoot } from "./path.js";
 const DEFAULT_LIMIT = 30;
 const MAX_LIMIT = 100;
 const DEFAULT_MAX_DEPTH = 12;
@@ -558,10 +559,6 @@ function normalizeRelativePath(homeRoot, absolutePath) {
     }
     return relative.split(path.sep).join("/");
 }
-function isPathInsideRoot(root, target) {
-    const relative = path.relative(root, target);
-    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
-}
 function normalizeQueryParts(query, homeRoot) {
     const typedQuery = query.trim().replace(/\\/g, "/");
     let normalized = typedQuery;

package/dist/server/utils/path.d.ts

@@ -13,4 +13,6 @@ export declare function expandTilde(path: string): string;
 export declare function areEquivalentPaths(left: string, right: string): boolean;
 export declare function createPathEquivalenceMatcher(target: string): (candidate: string) => boolean;
 export declare function createRealpathAwarePathMatcher(target: string): (candidate: string) => boolean;
+export declare function isPathInsideRoot(root: string, candidate: string): boolean;
+export declare function isRealpathInsideRoot(root: string, candidate: string): boolean;
 //# sourceMappingURL=path.d.ts.map

package/dist/server/utils/path.js

@@ -46,6 +46,19 @@ export function createRealpathAwarePathMatcher(target) {
         return candidateVariants.some((variant) => targetMatchers.some((matches) => matches(variant)));
     };
 }
+export function isPathInsideRoot(root, candidate) {
+    const compareAsWindows = shouldCompareAsWindows(root, candidate);
+    const platformPath = compareAsWindows ? nodePath.win32 : nodePath.posix;
+    const normalizedRoot = normalizePathForComparison(root, compareAsWindows);
+    const normalizedCandidate = normalizePathForComparison(candidate, compareAsWindows);
+    const relative = platformPath.relative(normalizedRoot, normalizedCandidate);
+    return relative === "" || (!relative.startsWith("..") && !platformPath.isAbsolute(relative));
+}
+export function isRealpathInsideRoot(root, candidate) {
+    const rootVariants = collectPathVariants(root);
+    const candidateVariants = collectPathVariants(candidate);
+    return rootVariants.some((rootVariant) => candidateVariants.some((candidateVariant) => isPathInsideRoot(rootVariant, candidateVariant)));
+}
 function collectPathVariants(value) {
     const variants = new Set([value]);
     for (const realpath of resolveRealpathVariants(value)) {

package/dist/server/utils/worktree.d.ts

@@ -101,6 +101,7 @@ export type WorktreeSource = {
     baseRefName: string;
     localBranchName?: string;
     pushRemoteUrl?: string;
+    trackOriginHead?: boolean;
 };
 export interface CreateWorktreeOptions {
     cwd: string;

package/dist/server/utils/worktree.js

@@ -860,6 +860,13 @@ export const createWorktree = async ({ cwd, source, worktreeSlug, runSetup, pase
             remote: sourcePlan.pushRemote,
         });
     }
+    if (sourcePlan.trackingRemote) {
+        await configureWorktreeTrackingRemote({
+            cwd,
+            branchName: sourcePlan.branchName,
+            remote: sourcePlan.trackingRemote,
+        });
+    }
     writePaseoWorktreeMetadata(worktreePath, { baseRefName: sourcePlan.metadataBaseRefName });
     // If paseo.json exists in the main repo but wasn't checked into the worktree
     // (e.g. uncommitted on first-time setup), seed the worktree with it so setup
@@ -940,19 +947,42 @@ async function resolveWorktreeSourcePlan({ cwd, source, desiredSlug, }) {
                 cwd,
                 timeout: 120000,
             });
+            const trackingRemote = source.trackOriginHead
+                ? await tryFetchWorktreeTrackingRemote({
+                    cwd,
+                    remoteName: "origin",
+                    headRef: source.headRef,
+                })
+                : undefined;
+            const remotePlan = {};
+            if (source.pushRemoteUrl) {
+                const remoteName = `paseo-pr-${source.githubPrNumber}`;
+                remotePlan.pushRemote = {
+                    name: remoteName,
+                    url: source.pushRemoteUrl,
+                    headRef: source.headRef,
+                    track: true,
+                };
+            }
+            else if (source.trackOriginHead && localBranchName !== source.headRef) {
+                const originUrl = await getWorktreeRemotePushUrl(cwd, "origin");
+                if (originUrl) {
+                    remotePlan.pushRemote = {
+                        name: `paseo-pr-${source.githubPrNumber}`,
+                        url: originUrl,
+                        headRef: source.headRef,
+                        track: false,
+                    };
+                }
+            }
+            if (trackingRemote) {
+                remotePlan.trackingRemote = trackingRemote;
+            }
             return {
                 branchName: localBranchName,
                 metadataBaseRefName: normalizedBaseRefName,
                 addArguments: [localBranchName],
-                ...(source.pushRemoteUrl
-                    ? {
-                        pushRemote: {
-                            name: `paseo-pr-${source.githubPrNumber}`,
-                            url: source.pushRemoteUrl,
-                            headRef: source.headRef,
-                        },
-                    }
-                    : {}),
+                ...remotePlan,
             };
         }
     }
@@ -962,10 +992,61 @@ async function configureWorktreePushRemote(options) {
         cwd: options.cwd,
     });
     await runGitCommand(["config", `remote.${options.remote.name}.push`, `HEAD:refs/heads/${options.remote.headRef}`], { cwd: options.cwd });
-    await runGitCommand(["config", `branch.${options.branchName}.remote`, options.remote.name], {
+    await runGitCommand(["config", `branch.${options.branchName}.pushRemote`, options.remote.name], {
         cwd: options.cwd,
     });
-    await runGitCommand(["config", `branch.${options.branchName}.merge`, `refs/heads/${options.remote.headRef}`], { cwd: options.cwd });
+    if (!options.remote.track) {
+        return;
+    }
+    await runGitCommand([
+        "config",
+        `remote.${options.remote.name}.fetch`,
+        `+refs/heads/${options.remote.headRef}:refs/remotes/${options.remote.name}/${options.remote.headRef}`,
+    ], { cwd: options.cwd });
+    const trackingRemote = await tryFetchWorktreeTrackingRemote({
+        cwd: options.cwd,
+        remoteName: options.remote.name,
+        headRef: options.remote.headRef,
+    });
+    if (trackingRemote) {
+        await configureWorktreeTrackingRemote({
+            cwd: options.cwd,
+            branchName: options.branchName,
+            remote: trackingRemote,
+        });
+    }
+}
+async function tryFetchWorktreeTrackingRemote(options) {
+    const result = await runGitCommand([
+        "fetch",
+        options.remoteName,
+        `+refs/heads/${options.headRef}:refs/remotes/${options.remoteName}/${options.headRef}`,
+    ], {
+        cwd: options.cwd,
+        timeout: 120000,
+        acceptExitCodes: [0, 1, 128],
+    });
+    return result.exitCode === 0 ? { name: options.remoteName, headRef: options.headRef } : undefined;
+}
+async function getWorktreeRemotePushUrl(cwd, remoteName) {
+    try {
+        const { stdout } = await runGitCommand(["remote", "get-url", "--push", remoteName], {
+            cwd,
+        });
+        const url = stdout.trim();
+        return url.length > 0 ? url : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function configureWorktreeTrackingRemote(options) {
+    await runGitCommand([
+        "branch",
+        "--set-upstream-to",
+        `${options.remote.name}/${options.remote.headRef}`,
+        options.branchName,
+    ], { cwd: options.cwd });
 }
 function validateWorktreeBranchName(branchName) {
     const validation = validateBranchSlug(branchName);

package/dist/server/web-ui/_expo/static/css/xterm-3bb1704bf6cb0876640973dc0244b4cb.css

@@ -0,0 +1 @@
+.xterm{cursor:text;user-select:none;position:relative}.xterm.focus,.xterm:focus{outline:none}.xterm .xterm-helpers{z-index:5;position:absolute;top:0}.xterm .xterm-helper-textarea{opacity:0;z-index:-5;white-space:nowrap;resize:none;border:0;width:0;height:0;margin:0;padding:0;position:absolute;top:0;left:-9999em;overflow:hidden}.xterm .composition-view{color:#fff;white-space:nowrap;z-index:1;background:#000;display:none;position:absolute}.xterm .composition-view.active{display:block}.xterm .xterm-viewport{cursor:default;position:absolute;inset:0;overflow-y:scroll}.xterm:not(.allow-transparency) .xterm-viewport{background-color:#000}.xterm .xterm-screen{position:relative}.xterm .xterm-screen canvas{position:absolute;top:0;left:0}.xterm.enable-mouse-events{cursor:default}.xterm.xterm-cursor-pointer,.xterm .xterm-cursor-pointer{cursor:pointer}.xterm.column-select.focus{cursor:crosshair}.xterm .xterm-accessibility:not(.debug),.xterm .xterm-message{z-index:10;color:#0000;pointer-events:none;position:absolute;inset:0}.xterm .xterm-accessibility-tree:not(.debug) ::selection{color:#0000}.xterm .xterm-accessibility-tree{user-select:text;white-space:pre;font-family:monospace}.xterm .xterm-accessibility-tree>div{transform-origin:0;width:fit-content}.xterm .live-region{width:1px;height:1px;position:absolute;left:-9999px;overflow:hidden}.xterm-dim{opacity:1!important}.xterm-underline-1{text-decoration:underline}.xterm-underline-2{text-decoration:underline double}.xterm-underline-3{text-decoration:underline wavy}.xterm-underline-4{text-decoration:underline dotted}.xterm-underline-5{text-decoration:underline dashed}.xterm-overline{text-decoration:overline}.xterm-overline.xterm-underline-1{text-decoration:underline overline}.xterm-overline.xterm-underline-2{text-decoration:overline double underline}.xterm-overline.xterm-underline-3{text-decoration:overline wavy underline}.xterm-overline.xterm-underline-4{text-decoration:overline dotted underline}.xterm-overline.xterm-underline-5{text-decoration:overline dashed underline}.xterm-strikethrough{text-decoration:line-through}.xterm-screen .xterm-decoration-container .xterm-decoration{z-index:6;position:absolute}.xterm-screen .xterm-decoration-container .xterm-decoration.xterm-decoration-top-layer{z-index:7}.xterm-decoration-overview-ruler{z-index:8;pointer-events:none;position:absolute;top:0;right:0}.xterm-decoration-top{z-index:2;position:relative}.xterm .xterm-scrollable-element>.xterm-scrollbar{cursor:default}.xterm .xterm-scrollable-element>.xterm-scrollbar>.xterm-scra{cursor:pointer;background-color:var(--vscode-scrollbarSliderBackground,#64646466);-webkit-mask-image:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 11 11'><path d='M2.5 8.5 L5.5 2.5 L8.5 8.5 Z' fill='black'/></svg>");mask-image:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 11 11'><path d='M2.5 8.5 L5.5 2.5 L8.5 8.5 Z' fill='black'/></svg>");-webkit-mask-position:50%;mask-position:50%;-webkit-mask-size:100% 100%;mask-size:100% 100%;-webkit-mask-repeat:no-repeat;mask-repeat:no-repeat}.xterm .xterm-scrollable-element>.xterm-scrollbar>.xterm-scra.xterm-arrow-down{transform:rotate(180deg)}.xterm .xterm-scrollable-element>.xterm-visible{opacity:1;z-index:11;background:0 0;transition:opacity .1s linear}.xterm .xterm-scrollable-element>.xterm-invisible{opacity:0;pointer-events:none}.xterm .xterm-scrollable-element>.xterm-invisible.xterm-fade{transition:opacity .8s linear}.xterm .xterm-scrollable-element>.xterm-shadow{display:none;position:absolute}.xterm .xterm-scrollable-element>.xterm-shadow.xterm-shadow-top{width:100%;height:3px;box-shadow:var(--vscode-scrollbar-shadow,#000)0 6px 6px -6px inset;display:block;top:0;left:3px}.xterm .xterm-scrollable-element>.xterm-shadow.xterm-shadow-left{width:3px;height:100%;box-shadow:var(--vscode-scrollbar-shadow,#000)6px 0 6px -6px inset;display:block;top:3px;left:0}.xterm .xterm-scrollable-element>.xterm-shadow.xterm-shadow-top-left-corner{width:3px;height:3px;display:block;top:0;left:0}.xterm .xterm-scrollable-element>.xterm-shadow.xterm-shadow-top.xterm-shadow-left{box-shadow:var(--vscode-scrollbar-shadow,#000)6px 0 6px -6px inset}

package/dist/server/web-ui/_expo/static/js/web/desktop-attachment-bridge-b01555c9b42665a03988c0a0032ef528.js

@@ -0,0 +1 @@
+__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentBridge=function(){const l=(0,s.createDesktopPreviewUrlResolver)({reader:(0,s.createDesktopFileReader)(),objectUrls:(0,s.createBrowserObjectUrlMinter)()});return{copyFile:t.copyDesktopAttachmentFile,writeBase64:t.writeDesktopAttachmentBase64,writeBytes:t.writeDesktopAttachmentBytes,deleteFile:t.deleteDesktopAttachmentFile,garbageCollect:t.garbageCollectDesktopAttachmentFiles,readFileBase64:s.readDesktopFileBase64,resolvePreviewUrl:t=>l.resolve(t),releasePreviewUrl:t=>l.release(t)}};var t=r(d[0]),s=r(d[1])},4397,[3924,3925]);