@getpaseo/server 0.11.0-beta.1 → 0.11.0-beta.2

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/usage-sources/index.d.ts

@@ -10,7 +10,7 @@ export interface UsageSource {
     } | null>;
     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;

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

@@ -1,5 +1,5 @@
 import { UsageReportSchema, } from "@getpaseo/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) {
         this.now = now;
@@ -33,14 +33,12 @@ export class UsageSourceRegistry {
                 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;
+            return { id: `${source.id}:${account.key}`, label: account.label };
         }
         catch (error) {
             const id = `${source.id}:!error`;
             this.writeCache(id, this.errorEntry(source, id, error));
-            return id;
+            return { id, error: true };
         }
     }
     async listReports(options = {}) {
@@ -55,7 +53,33 @@ export class UsageSourceRegistry {
                 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 = await Promise.all(inputs.map((input) => this.identify(source, input)));
+                // Group in discovery order so an account's logins keep the source's preference.
+                const knownReports = new Map();
+                const ids = [];
+                accounts.forEach((account, index) => {
+                    if (account === null)
+                        return;
+                    ids.push(account.id);
+                    if (account.error)
+                        return;
+                    const known = knownReports.get(account.id);
+                    if (known)
+                        known.inputs.push(inputs[index]);
+                    else
+                        knownReports.set(account.id, {
+                            source,
+                            inputs: [inputs[index]],
+                            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`;
@@ -97,21 +121,29 @@ export class UsageSourceRegistry {
         if (pending)
             return pending;
         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);
+            let 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: { status: "unavailable", windows: [] },
+            };
+            for (const input of known.inputs) {
+                try {
+                    // A harness can switch accounts between discovery and a targeted refresh.
+                    const account = await known.source.identify(input);
+                    if (!account || `${known.source.id}:${account.key}` !== id)
+                        continue;
+                    const report = UsageReportSchema.parse(await known.source.fetch(input));
+                    entry.report = report;
+                    if (report.status === "available")
+                        break;
+                }
+                catch (error) {
+                    entry = this.errorEntry(known.source, id, error, known.label);
+                }
             }
             this.writeCache(id, entry);
             return entry;