@camerontaylor/paseo-server 0.11.0-beta.1.fork.1 → 0.11.0-beta.3.fork.1

package/dist/server/server/orchestration-skills/internal/sync.d.ts

@@ -10,12 +10,24 @@ export interface SkillSyncResult {
     changedFiles: number;
     processedSkills: number;
 }
+interface ManagedFilesManifest {
+    version: 1;
+    files: Record<string, string>;
+}
 export declare function listFilesRecursive(rootDir: string): Promise<string[]>;
+export declare function readManagedFilesManifest(dstDir: string): Promise<ManagedFilesManifest | null>;
 export interface RemoveSkillTargets {
     agentsDir: string;
     claudeDir: string;
     codexDir: string;
 }
 export declare function removeSkill(skillName: string, targets: RemoveSkillTargets): Promise<void>;
+/**
+ * Codex also discovers .agents/skills, so its dedicated copy is a leftover. When
+ * the Codex skill directory resolves to the shared or Claude copy, it is that
+ * copy, and retiring it would delete the install.
+ */
+export declare function isLegacyCodexCopy(skillName: string, targets: RemoveSkillTargets): Promise<boolean>;
 export declare function syncSkills(options: SkillSyncOptions): Promise<SkillSyncResult>;
+export {};
 //# sourceMappingURL=sync.d.ts.map

package/dist/server/server/orchestration-skills/internal/sync.js

@@ -31,7 +31,7 @@ export async function listFilesRecursive(rootDir) {
     await walk(rootDir);
     return out;
 }
-async function readManagedFilesManifest(dstDir) {
+export async function readManagedFilesManifest(dstDir) {
     const raw = await fs
         .readFile(path.join(dstDir, MANAGED_FILES_MANIFEST), "utf-8")
         .catch(() => null);
@@ -152,6 +152,49 @@ export async function removeSkill(skillName, targets) {
         await fs.rm(p, { recursive: true, force: true });
     }
 }
+async function isSameDirectory(a, b) {
+    const [realA, realB] = await Promise.all([a, b].map((p) => fs.realpath(p).catch(() => null)));
+    return realA !== null && realA === realB;
+}
+/**
+ * Codex also discovers .agents/skills, so its dedicated copy is a leftover. When
+ * the Codex skill directory resolves to the shared or Claude copy, it is that
+ * copy, and retiring it would delete the install.
+ */
+export async function isLegacyCodexCopy(skillName, targets) {
+    const codexSkillDir = path.join(targets.codexDir, skillName);
+    for (const root of [targets.agentsDir, targets.claudeDir]) {
+        if (await isSameDirectory(codexSkillDir, path.join(root, skillName)))
+            return false;
+    }
+    return true;
+}
+async function retireManagedSkill(dstDir) {
+    const info = await fs.lstat(dstDir).catch(() => null);
+    if (!info?.isDirectory())
+        return 0;
+    const manifest = await readManagedFilesManifest(dstDir);
+    if (!manifest)
+        return 0;
+    const files = Object.keys(manifest.files);
+    await assertManagedPathsStayInsideSkill(dstDir, [MANAGED_FILES_MANIFEST, ...files]);
+    const removed = [];
+    for (const [rel, previousHash] of Object.entries(manifest.files)) {
+        const filePath = path.join(dstDir, rel);
+        const currentHash = await hashFile(filePath).catch(() => null);
+        if (currentHash !== previousHash)
+            continue;
+        await fs.rm(filePath);
+        removed.push(rel);
+    }
+    await pruneEmptyParentDirs(dstDir, removed);
+    await fs.rm(path.join(dstDir, MANAGED_FILES_MANIFEST));
+    await fs.rmdir(dstDir).catch((error) => {
+        if (error.code !== "ENOTEMPTY" && error.code !== "ENOENT")
+            throw error;
+    });
+    return removed.length + 1;
+}
 export async function syncSkills(options) {
     let changedFiles = 0;
     let processedSkills = 0;
@@ -163,7 +206,10 @@ export async function syncSkills(options) {
         try {
             changedFiles += await syncDirectoryFiles(bundleSkillDir, path.join(options.agentsDir, skillName));
             changedFiles += await syncDirectoryFiles(bundleSkillDir, path.join(options.claudeDir, skillName));
-            changedFiles += await syncDirectoryFiles(bundleSkillDir, path.join(options.codexDir, skillName));
+            // Retain user edits to the old dedicated Codex copy.
+            if (await isLegacyCodexCopy(skillName, options)) {
+                changedFiles += await retireManagedSkill(path.join(options.codexDir, skillName));
+            }
             processedSkills++;
         }
         catch (error) {

package/dist/server/server/plugins/builtin/index.js

@@ -16,6 +16,12 @@ export const builtinPlugins = [
 ];
 export function resolveBuiltinPluginsRoot(moduleUrl = import.meta.url) {
     const moduleDir = path.dirname(fileURLToPath(moduleUrl));
+    const archiveSegment = `${path.sep}app.asar${path.sep}`;
+    const archiveIndex = moduleDir.indexOf(archiveSegment);
+    if (archiveIndex !== -1) {
+        // esbuild runs outside Electron's filesystem shim and cannot read archive entries.
+        return path.join(moduleDir.slice(0, archiveIndex), "builtin-plugins");
+    }
     const candidates = [
         path.resolve(moduleDir, "..", "..", "..", "builtin-plugins"),
         path.resolve(moduleDir, "..", "..", "..", "..", "..", "..", "plugins"),

package/dist/server/server/plugins/compiler.js

@@ -320,6 +320,10 @@ async function compileTarget(entryPath, target) {
         jsx: "automatic",
         platform: target === "server" ? "node" : "neutral",
         target: target === "server" ? "node20" : "es2020",
+        // The neutral platform reads no package.json entry fields, so packages without
+        // `exports` would not resolve. Read the same fields as esbuild's browser platform
+        // minus `browser`, since the bundle also runs in React Native.
+        mainFields: target === "client" ? ["module", "main"] : undefined,
         // Metro lowers async syntax before Hermes sees app code. Plugin client bundles bypass Metro,
         // so apply the same compatibility transform before the app evaluates them from source.
         supported: target === "client" ? { "async-await": false } : undefined,

package/dist/server/server/plugins/index.d.ts

@@ -17,7 +17,6 @@ interface PluginRuntimePort {
     clearLogs(pluginId: string): void;
     getProviderRegistrations?(pluginId: string): readonly PluginProviderMetadata[];
     getUsageSourceRegistrations(pluginId: string): readonly PluginUsageSourceMetadata[];
-    identifyUsage: PluginRuntime["identifyUsage"];
     fetchUsage: PluginRuntime["fetchUsage"];
     discoverUsage: PluginRuntime["discoverUsage"];
     connectProvider: PluginRuntime["connectProvider"];
@@ -76,7 +75,7 @@ export declare class PluginService {
         sourceId: string;
         sourceLabel: string;
         report: {
-            status: "error" | "unavailable" | "available";
+            status: "available";
             windows: {
                 id: string;
                 label: string;
@@ -106,7 +105,23 @@ export declare class PluginService {
                 value: string;
                 tone?: "default" | "warning" | "danger" | "ok" | undefined;
             }[] | undefined;
-            error?: string | undefined;
+        } | {
+            status: "unavailable";
+            problem: {
+                kind: "expired";
+                expiresAt: string;
+                refreshedBy?: string | undefined;
+            } | {
+                kind: "rejected";
+                status: number;
+                refreshedBy?: string | undefined;
+            } | {
+                kind: "no_quota";
+                detail: string;
+            };
+        } | {
+            status: "error";
+            error: string;
         };
         icon?: string | undefined;
     }[]>;

package/dist/server/server/plugins/index.js

@@ -25,7 +25,6 @@ export class PluginService {
         this.errors = new Map();
         this.listeners = new Set();
         this.providers = new Map();
-        this.usageSources = new UsageSourceRegistry();
         this.usageSourceIdsByPlugin = new Map();
         this.providerIdsByPlugin = new Map();
         this.providerListeners = new Set();
@@ -43,6 +42,7 @@ export class PluginService {
             return request;
         };
         this.logger = logger.child({ module: "plugin-service" });
+        this.usageSources = new UsageSourceRegistry(Date.now, 300000, this.logger);
         this.runtime =
             dependencies.runtime ??
                 new PluginRuntime(logger, daemonVersion, {
@@ -484,7 +484,6 @@ export class PluginService {
                             ]
                             : result;
                     },
-                    identify: (input) => this.runtime.identifyUsage(pluginId, source.id, input),
                     fetch: (input) => {
                         return this.runtime.fetchUsage(pluginId, source.id, input);
                     },

package/dist/server/server/plugins/plugin-process-protocol.d.ts

@@ -40,11 +40,6 @@ export type PluginProcessRequest = {
 } | {
     type: "hook.cancel";
     requestId: string;
-} | {
-    type: "usage.identify";
-    requestId: string;
-    sourceId: string;
-    input: unknown;
 } | {
     type: "usage.fetch";
     requestId: string;

package/dist/server/server/plugins/plugin-process-protocol.js

@@ -83,14 +83,6 @@ export const PluginProcessRequestSchema = z.discriminatedUnion("type", [
     })
         .strict(),
     z.object({ type: z.literal("hook.cancel"), requestId: z.string() }).strict(),
-    z
-        .object({
-        type: z.literal("usage.identify"),
-        requestId: z.string(),
-        sourceId: z.string(),
-        input: z.unknown(),
-    })
-        .strict(),
     z
         .object({
         type: z.literal("usage.fetch"),

package/dist/server/server/plugins/plugin-process.js

@@ -296,15 +296,12 @@ export function createPluginWorker(options) {
             if (message.type === "usage.discover")
                 return jsonTransportValue(await source.discover());
             const input = await source.input.parseAsync(message.input);
-            return jsonTransportValue(message.type === "usage.identify"
-                ? await source.identify(input)
-                : await source.fetch(input));
+            return jsonTransportValue(await source.fetch(input));
         })().then((output) => send({ type: "result", requestId: message.requestId, output }), (error) => send({ type: "error", requestId: message.requestId, error: describeError(error) }));
     }
     function rejectWhileStopping(message) {
         if (message.type === "provider.status" ||
             message.type === "provider.catalog_key" ||
-            message.type === "usage.identify" ||
             message.type === "usage.fetch" ||
             message.type === "usage.discover") {
             send({ type: "error", requestId: message.requestId, error: "Plugin is stopping" });
@@ -389,9 +386,7 @@ export function createPluginWorker(options) {
             })().catch((error) => send({ type: "error", requestId: message.requestId, error: describeError(error) }));
             return;
         }
-        if (message.type === "usage.identify" ||
-            message.type === "usage.fetch" ||
-            message.type === "usage.discover") {
+        if (message.type === "usage.fetch" || message.type === "usage.discover") {
             handleUsageRequest(message);
             return;
         }

package/dist/server/server/plugins/runtime.d.ts

@@ -57,7 +57,6 @@ export declare class PluginRuntime {
     }>;
     getProviderRegistrations(pluginId: string): readonly PluginProviderMetadata[];
     getUsageSourceRegistrations(pluginId: string): readonly PluginUsageSourceMetadata[];
-    identifyUsage(pluginId: string, sourceId: string, input: unknown): Promise<unknown>;
     fetchUsage(pluginId: string, sourceId: string, input: unknown): Promise<unknown>;
     discoverUsage(pluginId: string, sourceId: string): Promise<unknown>;
     getProviderStatus(pluginId: string, providerId: string, request: ProviderStatusRequest): Promise<ProviderStatus>;

package/dist/server/server/plugins/runtime.js

@@ -241,17 +241,6 @@ export class PluginRuntime {
     getUsageSourceRegistrations(pluginId) {
         return this.plugins.get(pluginId)?.usageSources ?? [];
     }
-    identifyUsage(pluginId, sourceId, input) {
-        const loaded = this.plugins.get(pluginId);
-        if (!loaded)
-            throw new Error(`Plugin is not available: ${pluginId}`);
-        return this.request(loaded, {
-            type: "usage.identify",
-            requestId: randomUUID(),
-            sourceId,
-            input,
-        });
-    }
     fetchUsage(pluginId, sourceId, input) {
         const loaded = this.plugins.get(pluginId);
         if (!loaded)

package/dist/server/server/plugins/test-fixtures/usage-source/index.server.js

@@ -11,12 +11,21 @@ export default function contribute(server) {
                 { account: "one" },
                 { account: "bad", extra: true },
                 { account: "throws" },
+                { account: "expired" },
             ];
-            return inputs;
+            return inputs.map((input) => ({ key: String(input.account), input }));
         },
-        identify: async (input) => ({ key: input.account }),
         fetch: async (input) => {
             const account = input.account;
+            if (account === "expired")
+                return {
+                    status: "unavailable",
+                    problem: {
+                        kind: "expired",
+                        expiresAt: new Date(Date.now() - 3600000).toISOString(),
+                        refreshedBy: "claude",
+                    },
+                };
             if (account === "throws")
                 throw new Error("fixture failure");
             fetches++;

package/dist/server/server/plugins/test-fixtures/usage-source-directory/index.server.js

@@ -11,12 +11,21 @@ export default function contribute(server) {
                 { account: "one" },
                 { account: "bad", extra: true },
                 { account: "throws" },
+                { account: "expired" },
             ];
-            return inputs;
+            return inputs.map((input) => ({ key: String(input.account), input }));
         },
-        identify: async (input) => ({ key: input.account }),
         fetch: async (input) => {
             const account = input.account;
+            if (account === "expired")
+                return {
+                    status: "unavailable",
+                    problem: {
+                        kind: "expired",
+                        expiresAt: new Date(Date.now() - 3600000).toISOString(),
+                        refreshedBy: "claude",
+                    },
+                };
             if (account === "throws")
                 throw new Error("fixture failure");
             fetches++;

package/dist/server/server/plugins/usage-sources/index.d.ts

@@ -1,29 +1,26 @@
+import type { Logger } from "pino";
 import { type ProviderUsage, type UsageReportEntry } from "@camerontaylor/paseo-protocol/messages";
 export interface UsageSource {
     id: string;
     label: string;
     icon?: string;
-    discover(): Promise<unknown[]>;
-    identify(input: unknown): Promise<{
-        key: string;
-        label?: string;
-    } | null>;
+    discover(): Promise<unknown>;
     fetch(input: unknown): Promise<unknown>;
 }
-/** Owns account identity, the latest input for each report, and the five-minute fetch cache. */
+/** Owns account identity, ordered logins for each account, and the five-minute fetch cache. */
 export declare class UsageSourceRegistry {
     private readonly now;
     private readonly ttlMs;
+    private readonly logger;
     private generation;
     private readonly sources;
     private readonly known;
     private readonly cache;
     private readonly pending;
-    constructor(now?: () => number, ttlMs?: number);
+    constructor(now?: () => number, ttlMs?: number, logger?: Pick<Logger, "warn">);
     register(source: UsageSource): void;
     unregister(id: string): void;
     invalidateReports(predicate: (id: string) => boolean): void;
-    private identify;
     listReports(options?: {
         forceRefresh?: boolean;
         reportIds?: string[];
@@ -35,6 +32,7 @@ export declare class UsageSourceRegistry {
     }>;
     private fetchId;
     private writeCache;
-    private errorEntry;
+    private fetchWithFallback;
+    private fetchLogin;
 }
 //# sourceMappingURL=index.d.ts.map

package/dist/server/server/plugins/usage-sources/index.js

@@ -1,9 +1,11 @@
+import { z } from "zod";
 import { UsageReportSchema, } from "@camerontaylor/paseo-protocol/messages";
-/** Owns account identity, the latest input for each report, and the five-minute fetch cache. */
+/** Owns account identity, ordered logins for each account, and the five-minute fetch cache. */
 export class UsageSourceRegistry {
-    constructor(now = Date.now, ttlMs = 300000) {
+    constructor(now = Date.now, ttlMs = 300000, logger = { warn: console.warn }) {
         this.now = now;
         this.ttlMs = ttlMs;
+        this.logger = logger;
         this.generation = 0;
         this.sources = new Map();
         this.known = new Map();
@@ -27,26 +29,6 @@ export class UsageSourceRegistry {
                     map.delete(id);
         }
     }
-    async identify(source, input) {
-        try {
-            const account = await source.identify(input);
-            if (account === null)
-                return null;
-            if (typeof account !== "object" ||
-                (account.label !== undefined && typeof account.label !== "string"))
-                throw new Error(`Invalid account identity from ${source.id}`);
-            if (typeof account.key !== "string" || !/^[A-Za-z0-9._-]{1,128}$/.test(account.key))
-                throw new Error(`Invalid account key from ${source.id}`);
-            const id = `${source.id}:${account.key}`;
-            this.known.set(id, { source, input, label: account.label });
-            return id;
-        }
-        catch (error) {
-            const id = `${source.id}:!error`;
-            this.writeCache(id, this.errorEntry(source, id, error));
-            return id;
-        }
-    }
     async listReports(options = {}) {
         const generation = this.generation;
         const discovered = !options.reportIds ||
@@ -56,26 +38,68 @@ export class UsageSourceRegistry {
         if (generation !== this.generation)
             return this.listReports(options);
         const ids = options.reportIds ?? discovered;
-        const reports = await Promise.all([...new Set(ids)]
-            .filter((id) => this.known.has(id) || this.cache.has(id))
-            .map((id) => this.fetchId(id, options.forceRefresh)));
+        const reports = await Promise.all([...new Set(ids)].flatMap((id) => {
+            const known = this.known.get(id);
+            return known ? [this.fetchId(id, known, options.forceRefresh)] : [];
+        }));
         return generation === this.generation ? reports : this.listReports(options);
     }
     async discoverReportIds() {
+        const generation = this.generation;
         const discovered = await Promise.all([...this.sources.values()].map(async (source) => {
             try {
-                const inputs = await source.discover();
-                if (!Array.isArray(inputs))
-                    throw new Error("Usage discovery must return an array");
-                return (await Promise.all(inputs.map((input) => this.identify(source, input)))).filter((id) => id !== null);
+                const accounts = z
+                    .array(z.union([
+                    z.object({
+                        key: z.string().regex(/^[A-Za-z0-9._-]{1,128}$/),
+                        label: z.string().optional(),
+                        input: z.json(),
+                    }),
+                    z
+                        .object({
+                        providerId: z.string().regex(/^[A-Za-z0-9._-]{1,119}$/),
+                        label: z.string(),
+                    })
+                        .catchall(z.json()),
+                ]))
+                    .parse(await source.discover());
+                if (generation !== this.generation)
+                    return [];
+                const knownReports = new Map();
+                const ids = [];
+                for (const account of accounts) {
+                    const key = "providerId" in account ? `provider.${account.providerId}` : account.key;
+                    const input = "providerId" in account ? account : account.input;
+                    const id = `${source.id}:${key}`;
+                    ids.push(id);
+                    const known = knownReports.get(id);
+                    if (known)
+                        known.inputs.push(input);
+                    else
+                        knownReports.set(id, { source, inputs: [input], label: account.label });
+                }
+                for (const key of this.known.keys()) {
+                    if (key.startsWith(`${source.id}:`))
+                        this.known.delete(key);
+                }
+                for (const [id, known] of knownReports)
+                    this.known.set(id, known);
+                return ids;
             }
             catch (error) {
-                const id = `${source.id}:!error`;
-                this.writeCache(id, this.errorEntry(source, id, error));
-                return [id];
+                if (generation !== this.generation)
+                    return [];
+                for (const key of this.known.keys()) {
+                    if (key.startsWith(`${source.id}:`))
+                        this.known.delete(key);
+                }
+                this.logger.warn({ sourceId: source.id, err: error }, "Usage source discovery failed");
+                return [];
             }
         }));
         const ids = discovered.flat();
+        if (generation !== this.generation)
+            return [];
         const current = new Set(ids);
         for (const id of this.known.keys())
             if (!current.has(id)) {
@@ -104,11 +128,11 @@ export class UsageSourceRegistry {
                     providerId: custom ? entry.id.slice(prefix.length) : entry.sourceId,
                     displayName,
                     status: entry.report.status,
-                    planLabel: entry.report.planLabel ?? null,
-                    windows: entry.report.windows,
-                    balances: entry.report.balances ?? [],
-                    details: entry.report.details ?? [],
-                    error: entry.report.error ?? null,
+                    planLabel: entry.report.status === "available" ? (entry.report.planLabel ?? null) : null,
+                    windows: entry.report.status === "available" ? entry.report.windows : [],
+                    balances: entry.report.status === "available" ? (entry.report.balances ?? []) : [],
+                    details: entry.report.status === "available" ? (entry.report.details ?? []) : [],
+                    error: legacyError(entry.report, this.now()),
                 };
                 if (custom)
                     provider.baseProviderId = entry.sourceId;
@@ -116,11 +140,8 @@ export class UsageSourceRegistry {
             }),
         };
     }
-    fetchId(id, forceRefresh = false) {
-        const known = this.known.get(id);
+    fetchId(id, known, forceRefresh = false) {
         const cached = this.cache.get(id);
-        if (!known)
-            return Promise.resolve(cached.entry);
         if (!forceRefresh && cached && this.now() - cached.at < this.ttlMs)
             return Promise.resolve(cached.entry);
         const pending = this.pending.get(id);
@@ -128,22 +149,15 @@ export class UsageSourceRegistry {
             return pending;
         const generation = this.generation;
         const request = (async () => {
-            let entry;
-            try {
-                const report = UsageReportSchema.parse(await known.source.fetch(known.input));
-                entry = {
-                    id,
-                    sourceId: known.source.id,
-                    sourceLabel: known.source.label,
-                    icon: known.source.icon,
-                    account: { label: known.label },
-                    fetchedAt: new Date(this.now()).toISOString(),
-                    report,
-                };
-            }
-            catch (error) {
-                entry = this.errorEntry(known.source, id, error, known.label);
-            }
+            const entry = {
+                id,
+                sourceId: known.source.id,
+                sourceLabel: known.source.label,
+                icon: known.source.icon,
+                account: { label: known.label },
+                fetchedAt: new Date(this.now()).toISOString(),
+                report: await this.fetchWithFallback(known),
+            };
             if (generation === this.generation && this.known.get(id) === known)
                 this.writeCache(id, entry);
             return entry;
@@ -163,20 +177,50 @@ export class UsageSourceRegistry {
         }
         this.cache.set(id, { at, entry });
     }
-    errorEntry(source, id, error, label, fetchedAt = new Date(this.now()).toISOString()) {
-        return {
-            id,
-            sourceId: source.id,
-            sourceLabel: source.label,
-            icon: source.icon,
-            account: { label },
-            fetchedAt,
-            report: {
-                status: "error",
-                windows: [],
-                error: error instanceof Error ? error.message : String(error),
-            },
-        };
+    async fetchWithFallback(known) {
+        let report = await this.fetchLogin(known.source, known.inputs[0]);
+        for (const input of known.inputs.slice(1)) {
+            if (report.status === "available")
+                break;
+            report = await this.fetchLogin(known.source, input);
+        }
+        return report;
+    }
+    async fetchLogin(source, input) {
+        try {
+            return UsageReportSchema.parse(await source.fetch(input));
+        }
+        catch (error) {
+            return { status: "error", error: error instanceof Error ? error.message : String(error) };
+        }
     }
 }
+// The legacy RPC has only an error string; the current app owns its own presentation.
+// COMPAT(providerUsageList): added in v0.1.98, remove after 2027-03-26.
+function legacyProblem(problem, now) {
+    if (problem.kind === "no_quota")
+        return problem.detail;
+    const remedy = problem.refreshedBy
+        ? `Run ${problem.refreshedBy} to refresh it.`
+        : "Sign in again.";
+    if (problem.kind === "rejected")
+        return `Login rejected (HTTP ${problem.status}). ${remedy}`;
+    const elapsed = Math.max(0, now - Date.parse(problem.expiresAt));
+    let ago = "just now";
+    if (elapsed >= 86400000)
+        ago = `${Math.floor(elapsed / 86400000)}d ago`;
+    else if (elapsed >= 3600000)
+        ago = `${Math.floor(elapsed / 3600000)}h ago`;
+    else if (elapsed >= 60000)
+        ago = `${Math.floor(elapsed / 60000)}m ago`;
+    return `Login expired ${ago}. ${remedy}`;
+}
+// COMPAT(providerUsageList): added in v0.1.98, remove after 2027-03-26.
+function legacyError(report, now) {
+    if (report.status === "error")
+        return report.error;
+    if (report.status === "unavailable")
+        return legacyProblem(report.problem, now);
+    return null;
+}
 //# sourceMappingURL=index.js.map