npm - gestalt-mobile - Versions diffs - 0.17.0 → 0.17.2 - Mend

gestalt-mobile 0.17.0 → 0.17.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/README.md +4 -1
package/dist/client/assets/index-DgD-0I3M.js +25 -0
package/dist/client/index.html +1 -1
package/dist/server/server/composition.js +6 -0
package/dist/server/server/features/plans/get-plan/endpoint.js +2 -2
package/dist/server/server/features/skills/model/skill-profile.js +33 -2
package/dist/server/server/platform/git/git-summary-cache.js +15 -9
package/dist/server/server/platform/plans/filesystem-plan-status-source.js +19 -12
package/package.json +1 -1
package/dist/client/assets/index-Cfo4jnPb.js +0 -25

package/dist/client/index.html CHANGED Viewed

@@ -16,7 +16,7 @@ SPDX-License-Identifier: AGPL-3.0-or-later
     <link rel="icon" href="/icons/gestalt-mobile-192.png" />
     <link rel="apple-touch-icon" href="/icons/gestalt-mobile-180.png" />
     <title>Gestalt Mobile</title>
-    <script type="module" crossorigin src="/assets/index-Cfo4jnPb.js"></script>
+    <script type="module" crossorigin src="/assets/index-DgD-0I3M.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-e2lJ5XqL.css">
   </head>
   <body>

package/dist/server/server/composition.js CHANGED Viewed

@@ -346,6 +346,12 @@ export async function composeRelayApp(options) {
             planRoutes: {
                 exists: (id) => sessions.find(id) !== null,
                 find: (id) => supervisedPlans.find(id),
+                refresh: async (id) => {
+                    const refreshed = await planStatusSource.refresh(id);
+                    if (refreshed?.kind === 'updated')
+                        return refreshed.plan;
+                    return refreshed ? null : supervisedPlans.find(id);
+                },
                 removeStatus: (id) => planStatusSource.remove(id, supervisedPlans.identity(id) ?? undefined),
                 clear: (id) => supervisedPlans.clear(id),
                 closed: (id) => {

package/dist/server/server/features/plans/get-plan/endpoint.js CHANGED Viewed

@@ -4,11 +4,11 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 export function registerGetPlan(app, deps) {
-    app.get('/api/sessions/:id/plan', (request, reply) => {
+    app.get('/api/sessions/:id/plan', async (request, reply) => {
         const id = request.params.id;
         if (!deps.exists(id))
             return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
-        const plan = deps.find(id);
+        const plan = await deps.refresh(id);
         return plan ? reply.send(plan) : reply.code(204).send();
     });
 }

package/dist/server/server/features/skills/model/skill-profile.js CHANGED Viewed

@@ -81,6 +81,36 @@ function canonicalSkillPath(value) {
     }
     return value;
 }
+/**
+ * Return the durable identity of a skill inside Codex's versioned plugin cache.
+ * The concrete version directory is installation state, while marketplace,
+ * plugin, and skill-relative path remain stable across plugin upgrades.
+ */
+function versionNeutralPluginSkillPath(value) {
+    const match = value.match(/^(.*[\\/]plugins[\\/]cache[\\/][^\\/]+[\\/][^\\/]+)[\\/][^\\/]+([\\/]skills[\\/].+[\\/]SKILL\.md)$/);
+    return match ? `${match[1]}${match[2]}` : undefined;
+}
+function rebindVersionedPluginSkills(discovered, selection) {
+    const discoveredPaths = new Set(discovered.map((skill) => canonicalSkillPath(skill.path)));
+    const discoveredByDurablePath = new Map();
+    for (const skill of discovered) {
+        const durablePath = versionNeutralPluginSkillPath(canonicalSkillPath(skill.path));
+        if (durablePath === undefined)
+            continue;
+        const matches = discoveredByDurablePath.get(durablePath) ?? [];
+        matches.push(skill);
+        discoveredByDurablePath.set(durablePath, matches);
+    }
+    return createSkillSelection(selection.map((entry) => {
+        if (discoveredPaths.has(entry.path))
+            return entry;
+        const durablePath = versionNeutralPluginSkillPath(entry.path);
+        if (durablePath === undefined)
+            return entry;
+        const matches = discoveredByDurablePath.get(durablePath) ?? [];
+        return matches.length === 1 ? { ...entry, path: matches[0].path } : entry;
+    }));
+}
 /**
  * Validate a complete selection and return its canonical deterministic order.
  * This is lexical only: resolving symlinks is I/O and belongs to a platform
@@ -137,11 +167,12 @@ export function compileSkillOverride(input) {
     const effective = selectEffectiveSkillSelection(input);
     if (effective.selection === undefined)
         return { source: 'native', skillsConfig: undefined, warnings: [] };
+    const reboundSelection = rebindVersionedPluginSkills(input.discovered, effective.selection);
     const discoveredPaths = new Set(input.discovered.map((skill) => canonicalSkillPath(skill.path)));
-    const warnings = effective.selection
+    const warnings = reboundSelection
         .filter((entry) => !discoveredPaths.has(entry.path))
         .map((entry) => `Saved skill path is no longer discovered: ${entry.path}`);
-    const configured = applySkillSelectionSnapshot(input.discovered, effective.selection);
+    const configured = applySkillSelectionSnapshot(input.discovered, reboundSelection);
     return {
         source: effective.source,
         skillsConfig: configured

package/dist/server/server/platform/git/git-summary-cache.js CHANGED Viewed

@@ -4,23 +4,29 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { resolve } from 'node:path';
-/** Caches successful workspace inspections until a Git mutation invalidates them. */
+/** Coalesces concurrent inspections without retaining results across refreshes. */
 export class GitSummaryCache {
     inspectWorkspace;
-    summaries = new Map();
+    inspections = new Map();
     constructor(inspectWorkspace) {
         this.inspectWorkspace = inspectWorkspace;
     }
     async inspect(workspacePath) {
         const key = resolve(workspacePath);
-        const cached = this.summaries.get(key);
-        if (cached !== undefined)
-            return cached;
-        const summary = await this.inspectWorkspace(workspacePath);
-        this.summaries.set(key, summary);
-        return summary;
+        const pending = this.inspections.get(key);
+        if (pending)
+            return pending;
+        const inspection = this.inspectWorkspace(workspacePath);
+        this.inspections.set(key, inspection);
+        try {
+            return await inspection;
+        }
+        finally {
+            if (this.inspections.get(key) === inspection)
+                this.inspections.delete(key);
+        }
     }
     invalidate(workspacePath) {
-        this.summaries.delete(resolve(workspacePath));
+        this.inspections.delete(resolve(workspacePath));
     }
 }

package/dist/server/server/platform/plans/filesystem-plan-status-source.js CHANGED Viewed

@@ -44,6 +44,9 @@ export class FilesystemPlanStatusSource {
             lease.close();
         this.leases.clear();
     }
+    async refresh(sessionId) {
+        return (await this.leases.get(sessionId)?.refreshCurrent()) ?? null;
+    }
     async remove(sessionId, identity) {
         const statusPath = this.activeStatusPaths.get(sessionId);
         const signal = statusPath ? await this.readStatusForRollback(statusPath) : undefined;
@@ -220,9 +223,12 @@ class ActiveLease {
             this.debounce = undefined;
             const pendingStatusPath = this.pendingStatusPath;
             this.pendingStatusPath = undefined;
-            void (pendingStatusPath ? this.refresh(pendingStatusPath) : this.refreshLatest());
+            void (pendingStatusPath ? this.refreshPath(pendingStatusPath) : this.refreshLatest());
         }, 25);
     }
+    async refreshCurrent() {
+        return this.activeStatusPath ? this.refreshPath(this.activeStatusPath) : this.refreshLatest();
+    }
     async refreshLatest() {
         try {
             const candidates = (await readdir(this.statusDirectory))
@@ -239,15 +245,13 @@ class ActiveLease {
                 .filter((candidate) => candidate.signal !== null)
                 .sort((left, right) => right.signal.updatedAt.localeCompare(left.signal.updatedAt) ||
                 right.modifiedAt - left.modifiedAt)[0];
-            if (latest)
-                await this.refresh(latest.statusPath, latest.signal);
+            return latest ? this.refreshPath(latest.statusPath, latest.signal) : null;
         }
         catch {
-            if (!this.closed)
-                this.emitUnavailable();
+            return !this.closed ? this.emitUnavailable() : null;
         }
     }
-    async refresh(statusPath, parsedSignal) {
+    async refreshPath(statusPath, parsedSignal) {
         try {
             const signal = parsedSignal ?? parseSignal(await this.planReadFilesystem.readFile(statusPath, 'utf8'));
             if (!signal)
@@ -260,7 +264,7 @@ class ActiveLease {
                 throw new Error('PATH_OUTSIDE_WORKSPACE');
             const identity = createHash('sha256').update(planPath).digest('hex');
             if (await this.isDismissed(identity))
-                return;
+                return null;
             const result = parseSupervisedPlan({
                 source: await this.planReadFilesystem.readFile(planPath, 'utf8'),
                 planPath,
@@ -285,24 +289,27 @@ class ActiveLease {
                     }
                     if (previousStatusPath && previousStatusPath !== statusPath)
                         await rm(previousStatusPath, { force: true }).catch(() => { });
+                    return update;
                 }
             }
             else if (!this.closed) {
-                this.emitUnavailable();
+                return this.emitUnavailable();
             }
+            return null;
         }
         catch (error) {
             if (error.code === 'ENOENT' &&
                 this.activeStatusPath !== undefined &&
                 statusPath !== this.activeStatusPath)
-                return;
-            if (!this.closed)
-                this.emitUnavailable();
+                return null;
+            return !this.closed ? this.emitUnavailable() : null;
         }
     }
     emitUnavailable() {
         this.lastEmittedUpdate = undefined;
-        this.listener({ kind: 'unavailable', code: 'PLAN_STATUS_UNAVAILABLE' });
+        const update = { kind: 'unavailable', code: 'PLAN_STATUS_UNAVAILABLE' };
+        this.listener(update);
+        return update;
     }
 }
 function parseSignal(source) {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "gestalt-mobile",
-  "version": "0.17.0",
+  "version": "0.17.2",
   "description": "Mobile-first web relay for durable Codex development sessions",
   "keywords": [
     "codex",