@getpaseo/server 0.1.97 → 0.1.99

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

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { ApiOptionalStringSchema, fetchProviderApi, unavailableUsage } from "../usage.js";
+const ZaiUsageResponseSchema = z.object({
+    data: z
+        .array(z.object({
+        productName: ApiOptionalStringSchema,
+        status: ApiOptionalStringSchema,
+        purchaseTime: ApiOptionalStringSchema,
+        valid: ApiOptionalStringSchema,
+    }))
+        .optional(),
+});
+export class ZaiQuotaProvider {
+    constructor(options) {
+        this.providerId = "zai";
+        this.displayName = "Z.ai";
+        this.logger = options.logger;
+        this.fetchApi = options.fetch ?? fetch;
+    }
+    async fetchUsage() {
+        const token = process.env["ZAI_API_KEY"] || process.env["GLM_API_KEY"];
+        if (!token)
+            return unavailableUsage(this);
+        const res = await fetchProviderApi(this.fetchApi, "https://api.z.ai/api/biz/subscription/list", {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: "application/json",
+            },
+        });
+        if (!res.ok) {
+            this.logger.debug({ status: res.status }, "Z.ai usage fetch failed");
+            return unavailableUsage(this);
+        }
+        const resp = ZaiUsageResponseSchema.parse(await res.json());
+        const sub = resp.data?.[0];
+        if (!sub)
+            return unavailableUsage(this);
+        const details = [];
+        if (sub.status)
+            details.push({ id: "status", label: "Status", value: sub.status });
+        if (sub.valid)
+            details.push({ id: "valid", label: "Valid", value: sub.valid });
+        if (sub.purchaseTime) {
+            details.push({ id: "purchase_time", label: "Purchased", value: sub.purchaseTime });
+        }
+        return {
+            providerId: this.providerId,
+            displayName: this.displayName,
+            status: "available",
+            planLabel: sub.productName || null,
+            windows: [],
+            balances: [],
+            details,
+            error: null,
+        };
+    }
+}
+//# sourceMappingURL=zai.js.map

package/dist/server/services/quota-fetcher/service.d.ts

@@ -0,0 +1,28 @@
+import type { Logger } from "pino";
+import type { ProviderUsage } from "../../server/messages.js";
+import type { ProviderApiFetch, ProviderUsageFetcher } from "./provider.js";
+export interface ProviderUsageServiceOptions {
+    logger: Logger;
+    fetchers?: ProviderUsageFetcher[];
+    fetch?: ProviderApiFetch;
+    cacheTtlMs?: number;
+    now?: () => number;
+}
+export interface ProviderUsageListResult {
+    fetchedAt: string;
+    providers: ProviderUsage[];
+}
+export declare class ProviderUsageService {
+    private readonly logger;
+    private readonly fetchers;
+    private readonly cacheTtlMs;
+    private readonly now;
+    private cached;
+    private inFlight;
+    constructor(options: ProviderUsageServiceOptions);
+    listUsage(options?: {
+        forceRefresh?: boolean;
+    }): Promise<ProviderUsageListResult>;
+    private fetchFreshUsage;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/server/services/quota-fetcher/service.js

@@ -0,0 +1,58 @@
+import { createProviderUsageFetchers } from "./manifest.js";
+import { unavailableUsage } from "./usage.js";
+const DEFAULT_PROVIDER_USAGE_CACHE_TTL_MS = 5 * 60 * 1000;
+export class ProviderUsageService {
+    constructor(options) {
+        this.cached = null;
+        this.inFlight = null;
+        this.logger = options.logger.child({ module: "provider-usage-service" });
+        this.fetchers =
+            options.fetchers ??
+                createProviderUsageFetchers({
+                    logger: this.logger,
+                    fetch: options.fetch,
+                });
+        this.cacheTtlMs = options.cacheTtlMs ?? DEFAULT_PROVIDER_USAGE_CACHE_TTL_MS;
+        this.now = options.now ?? Date.now;
+    }
+    async listUsage(options) {
+        const nowMs = this.now();
+        if (!options?.forceRefresh &&
+            this.cached &&
+            nowMs - this.cached.fetchedAtMs < this.cacheTtlMs) {
+            return this.cached.result;
+        }
+        if (this.inFlight) {
+            return this.inFlight;
+        }
+        const request = this.fetchFreshUsage(nowMs);
+        this.inFlight = request;
+        try {
+            return await request;
+        }
+        finally {
+            if (this.inFlight === request) {
+                this.inFlight = null;
+            }
+        }
+    }
+    async fetchFreshUsage(nowMs) {
+        const settled = await Promise.allSettled(this.fetchers.map((fetcher) => fetcher.fetchUsage()));
+        const providers = settled.map((result, index) => {
+            const fetcher = this.fetchers[index];
+            if (result.status === "fulfilled") {
+                return result.value;
+            }
+            this.logger.debug({ err: result.reason, providerId: fetcher.providerId }, "Provider usage fetch failed");
+            return unavailableUsage({
+                providerId: fetcher.providerId,
+                displayName: fetcher.displayName,
+                error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+            });
+        });
+        const result = { fetchedAt: new Date(nowMs).toISOString(), providers };
+        this.cached = { fetchedAtMs: nowMs, result };
+        return result;
+    }
+}
+//# sourceMappingURL=service.js.map

package/dist/server/services/quota-fetcher/usage.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import type { ProviderUsage, ProviderUsageBalance, ProviderUsageWindow } from "../../server/messages.js";
+import type { ProviderApiFetch } from "./provider.js";
+export declare const ApiNumberSchema: z.ZodCoercedNumber<unknown>;
+export declare const ApiNullableNumberSchema: z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+export declare const ApiOptionalStringSchema: z.ZodPreprocess<z.ZodOptional<z.ZodCoercedString<unknown>>>;
+export declare function fetchProviderApi(fetchApi: ProviderApiFetch, input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+export declare function unavailableUsage(provider: {
+    providerId: string;
+    displayName: string;
+    error?: string | null;
+}): ProviderUsage;
+export declare function windowFromUsedPct(input: {
+    id: string;
+    label: string;
+    utilizationPct: number | null | undefined;
+    resetsAt?: string | null;
+    tone?: ProviderUsageWindow["tone"];
+}): ProviderUsageWindow;
+export declare function balanceToneFromRemaining(remaining: number | null | undefined): ProviderUsageBalance["tone"];
+export declare function toIsoStringOrNull(timestampMs: number): string | null;
+//# sourceMappingURL=usage.d.ts.map

package/dist/server/services/quota-fetcher/usage.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+const PROVIDER_HTTP_TIMEOUT_MS = 15000;
+export const ApiNumberSchema = z.coerce.number().finite();
+export const ApiNullableNumberSchema = z.preprocess((value) => (value == null ? null : value), ApiNumberSchema.nullable());
+export const ApiOptionalStringSchema = z.preprocess((value) => (value == null ? undefined : value), z.coerce.string().optional());
+export function fetchProviderApi(fetchApi, input, init = {}) {
+    return fetchApi(input, {
+        ...init,
+        signal: init.signal ?? AbortSignal.timeout(PROVIDER_HTTP_TIMEOUT_MS),
+    });
+}
+export function unavailableUsage(provider) {
+    return {
+        providerId: provider.providerId,
+        displayName: provider.displayName,
+        status: provider.error ? "error" : "unavailable",
+        planLabel: null,
+        windows: [],
+        balances: [],
+        details: [],
+        error: provider.error ?? null,
+    };
+}
+export function windowFromUsedPct(input) {
+    const usedPct = typeof input.utilizationPct === "number" ? input.utilizationPct : null;
+    const window = {
+        id: input.id,
+        label: input.label,
+        usedPct,
+        remainingPct: usedPct === null ? null : Math.max(0, 100 - usedPct),
+        resetsAt: input.resetsAt ?? null,
+    };
+    if (input.tone) {
+        window.tone = input.tone;
+    }
+    return window;
+}
+export function balanceToneFromRemaining(remaining) {
+    if (typeof remaining !== "number")
+        return "default";
+    if (remaining <= 0)
+        return "danger";
+    return "ok";
+}
+export function toIsoStringOrNull(timestampMs) {
+    const date = new Date(timestampMs);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+}
+//# sourceMappingURL=usage.js.map

package/dist/server/utils/checkout-git.d.ts

@@ -1,6 +1,12 @@
 import type { Logger } from "pino";
 import type { ParsedDiffFile } from "../server/utils/diff-highlighter.js";
 import { type GitHubPullRequestStatusFacts, type GitHubService, type PullRequestMergeable } from "../services/github-service.js";
+/**
+ * Why a git mutation is forcing a workspace snapshot refresh. Shared between the
+ * Session shell (which owns the refresh primitive) and the checkout subsystem
+ * (which triggers most of these reasons after a write).
+ */
+export type GitMutationRefreshReason = "commit-changes" | "pull" | "push" | "merge-to-base" | "merge-from-base" | "merge-pr" | "enable-pr-auto-merge" | "disable-pr-auto-merge" | "create-pr" | "switch-branch" | "rename-branch" | "create-branch" | "stash-push" | "stash-pop" | "create-worktree";
 interface CheckoutReadCacheOptions {
     force?: boolean;
     reason?: string;

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

@@ -24,6 +24,15 @@ const IGNORED_SUGGESTION_DIRECTORY_NAMES = new Set([
     "coverage",
     "vendor",
     "__pycache__",
+    ".git",
+]);
+const TRAVERSABLE_HIDDEN_WORKSPACE_DIRECTORY_NAMES = new Set([
+    ".agents",
+    ".claude",
+    ".codex",
+    ".github",
+    ".paseo",
+    ".vscode",
 ]);
 export async function searchHomeDirectories(options) {
     const query = options.query.trim();
@@ -71,6 +80,17 @@ export async function searchWorkspaceEntries(options) {
         return [];
     }
     const matchMode = options.matchMode ?? "fuzzy";
+    const exactEntry = queryParts.isPathQuery && matchMode === "suffix"
+        ? await resolveWorkspaceExactEntry({
+            workspaceRoot,
+            query: options.query,
+            includeDirectories,
+            includeFiles,
+        })
+        : null;
+    if (exactEntry && limit <= 1) {
+        return [exactEntry];
+    }
     if (queryParts.isPathQuery && matchMode !== "suffix") {
         return searchWorkspaceWithinParentDirectory({
             workspaceRoot,
@@ -84,7 +104,7 @@ export async function searchWorkspaceEntries(options) {
     const searchTerm = matchMode === "suffix"
         ? [queryParts.parentPart, queryParts.searchTerm].filter(Boolean).join("/")
         : queryParts.searchTerm;
-    return searchWorkspaceAcrossTree({
+    const entries = await searchWorkspaceAcrossTree({
         workspaceRoot,
         searchTerm,
         limit,
@@ -94,6 +114,53 @@ export async function searchWorkspaceEntries(options) {
         maxDepth: options.maxDepth ?? DEFAULT_MAX_DEPTH,
         maxEntriesScanned: options.maxEntriesScanned ?? DEFAULT_MAX_DIRECTORIES_SCANNED,
     });
+    return exactEntry ? prependWorkspaceEntry(exactEntry, entries).slice(0, limit) : entries;
+}
+async function resolveWorkspaceExactEntry(input) {
+    const normalized = input.query
+        .trim()
+        .replace(/\\/g, "/")
+        .replace(/^\.\/+/, "")
+        .replace(/\/{2,}/g, "/");
+    if (!normalized) {
+        return null;
+    }
+    const candidatePath = path.isAbsolute(normalized)
+        ? path.resolve(normalized)
+        : path.resolve(input.workspaceRoot, normalized);
+    let resolvedPath;
+    try {
+        resolvedPath = await realpath(candidatePath);
+    }
+    catch {
+        return null;
+    }
+    if (!isPathInsideRoot(input.workspaceRoot, resolvedPath)) {
+        return null;
+    }
+    const stats = await stat(resolvedPath).catch(() => null);
+    if (!stats) {
+        return null;
+    }
+    if (stats.isFile() && input.includeFiles) {
+        return {
+            path: normalizeRelativePath(input.workspaceRoot, resolvedPath),
+            kind: "file",
+        };
+    }
+    if (stats.isDirectory() && input.includeDirectories) {
+        return {
+            path: normalizeRelativePath(input.workspaceRoot, resolvedPath),
+            kind: "directory",
+        };
+    }
+    return null;
+}
+function prependWorkspaceEntry(entry, entries) {
+    return [
+        entry,
+        ...entries.filter((candidate) => candidate.kind !== entry.kind || candidate.path !== entry.path),
+    ];
 }
 function normalizeLimit(limit) {
     const candidate = limit ?? DEFAULT_LIMIT;
@@ -185,6 +252,9 @@ async function searchWorkspaceWithinParentDirectory(input) {
         if (entry.kind === "file" && !input.includeFiles) {
             continue;
         }
+        if (isHiddenWorkspaceSuggestion(entry)) {
+            continue;
+        }
         const rankedEntry = rankWorkspaceEntry({
             absolutePath: entry.absolutePath,
             kind: entry.kind,
@@ -230,6 +300,10 @@ async function searchWorkspaceAcrossTree(input) {
             if (entry.kind === "directory" && !input.includeDirectories) {
                 continue;
             }
+            // Hidden directories are traversed, but not offered as suggestions.
+            if (isHiddenWorkspaceSuggestion(entry)) {
+                continue;
+            }
             if (entry.kind === "file" && !input.includeFiles) {
                 continue;
             }
@@ -618,7 +692,23 @@ async function listWorkspaceChildEntries(input) {
         return cached.entries;
     }
     const dirents = await readdir(input.directory, { withFileTypes: true }).catch(() => []);
-    const candidates = dirents.filter((dirent) => !isHiddenDirectoryName(dirent.name) && !isIgnoredSuggestionDirectoryName(dirent.name));
+    const candidates = dirents.filter((dirent) => {
+        if (isIgnoredSuggestionDirectoryName(dirent.name)) {
+            return false;
+        }
+        if (isHiddenDirectoryName(dirent.name) &&
+            !dirent.isFile() &&
+            !isTraversableHiddenWorkspaceDirectoryName(dirent.name)) {
+            return false;
+        }
+        // Allowlisted hidden directories remain traversable so file links like
+        // `.claude/settings.local.json` can resolve, but hidden files (e.g.
+        // `.DS_Store`) should never be suggested.
+        if (dirent.isFile() && isHiddenDirectoryName(dirent.name)) {
+            return false;
+        }
+        return true;
+    });
     const resolved = await Promise.all(candidates.map(async (dirent) => {
         const candidatePath = path.join(input.directory, dirent.name);
         const entry = await resolveWorkspaceCandidate({
@@ -687,9 +777,15 @@ async function resolveWorkspaceCandidate(input) {
 function isHiddenDirectoryName(name) {
     return name.startsWith(".");
 }
+function isHiddenWorkspaceSuggestion(entry) {
+    return isHiddenDirectoryName(entry.name);
+}
 function isIgnoredSuggestionDirectoryName(name) {
     return IGNORED_SUGGESTION_DIRECTORY_NAMES.has(name);
 }
+function isTraversableHiddenWorkspaceDirectoryName(name) {
+    return TRAVERSABLE_HIDDEN_WORKSPACE_DIRECTORY_NAMES.has(name);
+}
 function setDirectoryListCache(cacheKey, entry) {
     directoryListCache.set(cacheKey, entry);
     pruneDirectoryListCache();

package/package.json

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