@getpaseo/server 0.1.100 → 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)) {
@@ -735,22 +749,41 @@ async function resolvePullRequestStatusLookupTarget(cwd, currentBranch, context)
     if (context?.facts?.isGit && context.facts.pullRequestLookupTarget) {
         return context.facts.pullRequestLookupTarget;
     }
-    const remoteName = await getGitConfigValue(cwd, `branch.${currentBranch}.remote`);
-    if (!remoteName?.startsWith("paseo-pr-")) {
-        return { headRef: currentBranch };
+    const branchRemoteName = await getGitConfigValue(cwd, `branch.${currentBranch}.remote`, context);
+    let branchMergeRef = null;
+    if (branchRemoteName) {
+        branchMergeRef = await getGitConfigValue(cwd, `branch.${currentBranch}.merge`, context);
     }
-    const mergeRef = await getGitConfigValue(cwd, `branch.${currentBranch}.merge`);
-    const trackedHeadRef = parseBranchMergeHeadRef(mergeRef);
-    if (!trackedHeadRef) {
-        return { headRef: currentBranch };
+    const localBranchTarget = buildPullRequestLookupTargetFromBranchConfig({
+        currentBranch,
+        branchRemoteName,
+        branchMergeRef,
+        branchRemoteUrl: null,
+        originRemoteUrl: null,
+        resolvedBaseRef: null,
+    });
+    if (localBranchTarget.headRef === currentBranch) {
+        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),
+    ]);
+    const branchTarget = buildPullRequestLookupTargetFromBranchConfig({
+        currentBranch,
+        branchRemoteName,
+        branchMergeRef,
+        branchRemoteUrl,
+        originRemoteUrl,
+        resolvedBaseRef,
+    });
+    if (branchTarget.headRef !== currentBranch || branchTarget.headRepositoryOwner) {
+        return branchTarget;
     }
-    const remoteUrl = await getGitConfigValue(cwd, `remote.${remoteName}.url`);
-    const remoteRepo = remoteUrl ? parseGitHubRepoFromRemote(remoteUrl) : null;
-    const headRepositoryOwner = remoteRepo?.split("/")[0];
-    return {
-        headRef: trackedHeadRef,
-        ...(headRepositoryOwner ? { headRepositoryOwner } : {}),
-    };
+    const pushTarget = await resolvePullRequestLookupTargetFromPushConfig(cwd, currentBranch, originRemoteUrl, resolvedBaseRef, context);
+    return pushTarget ?? branchTarget;
 }
 export async function resolveAbsoluteGitDir(cwd) {
     try {
@@ -1015,22 +1048,74 @@ async function inspectCheckoutContext(cwd, context) {
     }
 }
 function buildPullRequestLookupTargetFromBranchConfig(input) {
-    if (!input.branchRemoteName?.startsWith("paseo-pr-")) {
-        return { headRef: input.currentBranch };
-    }
     const trackedHeadRef = parseBranchMergeHeadRef(input.branchMergeRef);
-    if (!trackedHeadRef) {
+    if (!input.branchRemoteName || !trackedHeadRef || trackedHeadRef === input.currentBranch) {
         return { headRef: input.currentBranch };
     }
     const remoteRepo = input.branchRemoteUrl
         ? parseGitHubRepoFromRemote(input.branchRemoteUrl)
         : null;
-    const headRepositoryOwner = remoteRepo?.split("/")[0];
+    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 (trackedHeadRef === normalizedBaseRef && !headRepositoryOwner) {
+        return { headRef: input.currentBranch };
+    }
+    if (isSameRepo) {
+        return { headRef: trackedHeadRef };
+    }
     return {
         headRef: trackedHeadRef,
         ...(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;
@@ -1053,23 +1138,31 @@ export async function getCheckoutSnapshotFacts(cwd, context) {
     let branchRemoteName = null;
     let branchMergeRef = null;
     let branchRemoteUrl = null;
-    if (inspected.remoteUrl && inspected.currentBranch) {
+    if (inspected.currentBranch) {
         branchRemoteName = await getGitConfigValue(cwd, `branch.${inspected.currentBranch}.remote`, context);
         if (branchRemoteName) {
-            branchMergeRef = await getGitConfigValue(cwd, `branch.${inspected.currentBranch}.merge`, context);
-            if (branchRemoteName.startsWith("paseo-pr-")) {
-                branchRemoteUrl = await getGitConfigValue(cwd, `remote.${branchRemoteName}.url`, context);
-            }
+            [branchMergeRef, branchRemoteUrl] = await Promise.all([
+                getGitConfigValue(cwd, `branch.${inspected.currentBranch}.merge`, context),
+                getGitConfigValue(cwd, `remote.${branchRemoteName}.url`, context),
+            ]);
         }
     }
-    const pullRequestLookupTarget = inspected.currentBranch
+    let pullRequestLookupTarget = inspected.currentBranch
         ? buildPullRequestLookupTargetFromBranchConfig({
             currentBranch: inspected.currentBranch,
             branchRemoteName,
             branchMergeRef,
             branchRemoteUrl,
+            originRemoteUrl: inspected.remoteUrl,
+            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,
@@ -1935,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.");
@@ -1942,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;