loopengine 0.1.38 → 0.1.41

package/dist/index.d.ts

@@ -57,9 +57,9 @@ export { listDeclaredEnvVars, setEnvVar, EnvVarNameError } from './web/env-admin
 export type { DeclaredEnvVar } from './web/env-admin.js';
 export { readActauthConfig, addActauthRule, updateActauthRule, removeActauthRule, setDefaultDecision, ActauthRuleExistsError, ActauthRuleNotFoundError, } from './web/actauth-admin.js';
 export type { ActauthRuleInput, ActauthConfigView } from './web/actauth-admin.js';
-export { installAbility, listInstalledAbilities, AbilityManifestError, AbilityVersionError, AbilityCollisionError, AbilityAlreadyInstalledError, } from './bin/ability-manager.js';
-export type { InstalledAbilityRecord, AbilityEnvDecl } from './bin/ability-manager.js';
-export { searchPublicAbilities } from './web/abilities-admin.js';
+export { installAbility, upgradeAbility, listInstalledAbilities, AbilityManifestError, AbilityVersionError, AbilityCollisionError, AbilityAlreadyInstalledError, AbilityNotInstalledError, } from './bin/ability-manager.js';
+export type { InstalledAbilityRecord, AbilityEnvDecl, UpgradeFileResult } from './bin/ability-manager.js';
+export { searchPublicAbilities, fetchLatestAbilityVersion } from './web/abilities-admin.js';
 export type { PublicAbilitySearchResult } from './web/abilities-admin.js';
 export { describeModelProviders, describeGateways } from './web/global-config.js';
 export type { ModelProviderInfo, AgentModelUsage, ModelsView, GatewayProviderInfo, GatewaysView } from './web/global-config.js';

package/dist/index.js

@@ -51,8 +51,8 @@ export { playgroundHtml } from './web/playground.js';
 export { readSkill, writeSkill, deleteSkill, SkillInvalidIdError, SkillNotFoundError } from './web/skills-admin.js';
 export { listDeclaredEnvVars, setEnvVar, EnvVarNameError } from './web/env-admin.js';
 export { readActauthConfig, addActauthRule, updateActauthRule, removeActauthRule, setDefaultDecision, ActauthRuleExistsError, ActauthRuleNotFoundError, } from './web/actauth-admin.js';
-export { installAbility, listInstalledAbilities, AbilityManifestError, AbilityVersionError, AbilityCollisionError, AbilityAlreadyInstalledError, } from './bin/ability-manager.js';
-export { searchPublicAbilities } from './web/abilities-admin.js';
+export { installAbility, upgradeAbility, listInstalledAbilities, AbilityManifestError, AbilityVersionError, AbilityCollisionError, AbilityAlreadyInstalledError, AbilityNotInstalledError, } from './bin/ability-manager.js';
+export { searchPublicAbilities, fetchLatestAbilityVersion } from './web/abilities-admin.js';
 export { describeModelProviders, describeGateways } from './web/global-config.js';
 export { createTrackedApprover, listApprovals, decideApproval, findApproval } from './web/web-approver.js';
 export { scaffoldAgent, scaffoldSubagent, AgentNameError, AgentExistsError, AgentNotFoundError, AgentModelError } from './bin/cli.js';

package/dist/web/abilities-admin.d.ts

@@ -4,3 +4,12 @@ export interface PublicAbilitySearchResult {
     version: string;
 }
 export declare function searchPublicAbilities(query?: string): Promise<PublicAbilitySearchResult[]>;
+/** The latest version currently published on the public npm registry for
+ * `packageName`, or null if it can't be determined — not published
+ * there at all (a private/file:/git-installed ability, the common case
+ * during local development), a network hiccup, or a timeout. Best-effort
+ * only: the Abilities tab uses this to decide whether an installed
+ * ability's own "Upgrade" button is worth showing, not to block
+ * anything, so a failure here surfaces as "can't tell, show the button
+ * anyway" rather than an error the operator has to deal with. */
+export declare function fetchLatestAbilityVersion(packageName: string): Promise<string | null>;

package/dist/web/abilities-admin.js

@@ -38,3 +38,29 @@ export async function searchPublicAbilities(query) {
     const needle = query.toLowerCase();
     return results.filter((r) => r.name.toLowerCase().includes(needle) || r.description.toLowerCase().includes(needle));
 }
+const NPM_LATEST_VERSION_TIMEOUT_MS = 5000;
+/** The latest version currently published on the public npm registry for
+ * `packageName`, or null if it can't be determined — not published
+ * there at all (a private/file:/git-installed ability, the common case
+ * during local development), a network hiccup, or a timeout. Best-effort
+ * only: the Abilities tab uses this to decide whether an installed
+ * ability's own "Upgrade" button is worth showing, not to block
+ * anything, so a failure here surfaces as "can't tell, show the button
+ * anyway" rather than an error the operator has to deal with. */
+export async function fetchLatestAbilityVersion(packageName) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), NPM_LATEST_VERSION_TIMEOUT_MS);
+    try {
+        const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`, { signal: controller.signal });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return typeof data.version === 'string' ? data.version : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/web/agents-config-page.js

@@ -1288,25 +1288,39 @@ export const agentsConfigPageHtml = `<!doctype html>
   }
 
   function renderInstalledAbilityRow(a) {
+    // a.upToDate only ever comes back true when the npm registry lookup
+    // (handleAbilitiesGet's own fetchLatestAbilityVersion) actually
+    // succeeded and matched — a private/file:/git-installed ability, or
+    // any registry hiccup, leaves it false, so the button still shows
+    // rather than silently hiding on an unknown instead of a genuine
+    // "nothing to upgrade".
+    var actionHtml = a.upToDate
+      ? '<span class="hint">up to date</span>'
+      : '<button type="button" class="ability-upgrade-btn" data-name="' + escapeHtml(a.name) + '">Upgrade</button>';
     return '<tr>' +
       '<td><code>' + escapeHtml(a.name) + '</code></td>' +
       '<td>' + escapeHtml(a.version) + '</td>' +
       '<td class="hint">' + escapeHtml((a.tools || []).join(', ')) + '</td>' +
+      '<td>' + actionHtml + '</td>' +
       '</tr>';
   }
 
-  function renderAbilitySearchResultRow(pkg) {
+  function renderAbilitySearchResultRow(pkg, installedNames) {
+    var actionHtml = installedNames.indexOf(pkg.name) !== -1
+      ? '<span class="hint">Installed</span>'
+      : '<button type="button" class="ability-install-btn" data-spec="' + escapeHtml(pkg.name) + '">Install</button>';
     return '<tr>' +
       '<td><code>' + escapeHtml(pkg.name) + '</code> <span class="hint">' + escapeHtml(pkg.version) + '</span></td>' +
       '<td>' + escapeHtml(pkg.description || '') + '</td>' +
-      '<td><button type="button" class="ability-install-btn" data-spec="' + escapeHtml(pkg.name) + '">Install</button></td>' +
+      '<td>' + actionHtml + '</td>' +
       '</tr>';
   }
 
   function renderAbilitiesConfigHtml(data) {
     var installed = data.abilities || [];
     var installedHtml = installed.length
-      ? '<table><thead><tr><th>Name</th><th>Version</th><th>Tools</th></tr></thead><tbody>' + installed.map(renderInstalledAbilityRow).join('') + '</tbody></table>'
+      ? '<table><thead><tr><th>Name</th><th>Version</th><th>Tools</th><th></th></tr></thead><tbody>' + installed.map(renderInstalledAbilityRow).join('') + '</tbody></table>' +
+        '<p id="abilityUpgradeStatus" class="hint"></p>'
       : '<p class="hint">No abilities installed for this agent yet.</p>';
 
     return '<h3>Installed</h3>' + installedHtml +
@@ -1371,12 +1385,54 @@ export const agentsConfigPageHtml = `<!doctype html>
       });
   }
 
+  // Upgrades an already-installed ability to whatever it currently
+  // resolves to — same endpoint upgradeAbility (bin/ability-manager.ts)
+  // backs, which three-way merges tool/skill files instead of blindly
+  // overwriting a hand-edited one, so a merge conflict is a real,
+  // expected outcome here, not an error — surfaced distinctly from a
+  // request actually failing.
+  function upgradeAbility(name, abilityName, statusEl, btn) {
+    if (btn) { btn.disabled = true; }
+    statusEl.className = 'hint';
+    statusEl.textContent = 'Upgrading ' + abilityName + '…';
+    fetch('/agents/' + encodeURIComponent(name) + '/abilities/' + encodeURIComponent(abilityName) + '/upgrade', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({}),
+    })
+      .then(function (r) { return r.json().then(function (j) { return { ok: r.ok, body: j }; }); })
+      .then(function (result) {
+        if (!result.ok) throw new Error(result.body.error || 'request failed');
+        var files = result.body.files || [];
+        var updated = files.filter(function (f) { return f.status === 'updated'; });
+        var conflicts = files.filter(function (f) { return f.status === 'conflict'; });
+        var message;
+        if (!files.length || (!updated.length && !conflicts.length)) {
+          message = escapeHtml(abilityName) + ' is already up to date.';
+        } else {
+          message = 'Upgraded ' + escapeHtml(abilityName) + ': ' + escapeHtml(updated.map(function (f) { return f.path; }).join(', ') || 'no files changed') +
+            '. Already running under npx loopengine dev? It becomes active automatically. Running under serve (or nothing yet)? Restart the server to pick it up.';
+          if (conflicts.length) {
+            message += ' <strong>' + conflicts.length + ' file(s) need resolving by hand: ' + escapeHtml(conflicts.map(function (f) { return f.path; }).join(', ')) + '</strong> — a hand-edited file with upstream changes too, left alone rather than overwritten.';
+          }
+        }
+        statusEl.className = conflicts.length ? 'error' : 'hint';
+        statusEl.innerHTML = message;
+        loadAbilitiesTab(name);
+      })
+      .catch(function (err) {
+        statusEl.className = 'error';
+        statusEl.textContent = 'Could not upgrade: ' + err.message;
+        if (btn) { btn.disabled = false; }
+      });
+  }
+
   // Shared by the initial (empty-query) load right after the tab opens
   // and the search form's own submit — the empty-query case is just
   // "list every published ability" (the keyword filter alone, no extra
   // search text), so an operator sees what's out there immediately
   // instead of having to search for something before anything shows up.
-  function runAbilitySearch(name, q, content, resultsEl) {
+  function runAbilitySearch(name, q, content, resultsEl, installedNames) {
     resultsEl.innerHTML = '<p class="hint">Loading&hellip;</p>';
     fetch('/agents/' + encodeURIComponent(name) + '/abilities/search' + (q ? '?q=' + encodeURIComponent(q) : ''))
       .then(function (r) { return r.json().then(function (j) { return { ok: r.ok, body: j }; }); })
@@ -1384,7 +1440,7 @@ export const agentsConfigPageHtml = `<!doctype html>
         if (!result.ok) throw new Error(result.body.error || 'search failed');
         var results = result.body.results || [];
         resultsEl.innerHTML = results.length
-          ? '<table><thead><tr><th>Package</th><th>Description</th><th></th></tr></thead><tbody>' + results.map(renderAbilitySearchResultRow).join('') + '</tbody></table>'
+          ? '<table><thead><tr><th>Package</th><th>Description</th><th></th></tr></thead><tbody>' + results.map(function (pkg) { return renderAbilitySearchResultRow(pkg, installedNames); }).join('') + '</tbody></table>'
           : '<p class="hint">No public abilities found.</p>';
         var installBtns = resultsEl.querySelectorAll('.ability-install-btn');
         for (var i = 0; i < installBtns.length; i++) {
@@ -1399,21 +1455,30 @@ export const agentsConfigPageHtml = `<!doctype html>
       });
   }
 
-  function wireAbilitiesHandlers(name) {
+  function wireAbilitiesHandlers(name, installedNames) {
     var content = abilitiesContentEl();
     if (!content) return;
 
+    var upgradeStatusEl = content.querySelector('#abilityUpgradeStatus');
+    var upgradeBtns = content.querySelectorAll('.ability-upgrade-btn');
+    for (var u = 0; u < upgradeBtns.length; u++) {
+      upgradeBtns[u].addEventListener('click', function (ev) {
+        var btn = ev.currentTarget;
+        upgradeAbility(name, btn.dataset.name, upgradeStatusEl, btn);
+      });
+    }
+
     var searchForm = content.querySelector('#abilitySearchForm');
     var resultsEl = content.querySelector('#abilitySearchResults');
     if (searchForm && resultsEl) {
       searchForm.addEventListener('submit', function (ev) {
         ev.preventDefault();
         var q = new FormData(searchForm).get('q');
-        runAbilitySearch(name, q, content, resultsEl);
+        runAbilitySearch(name, q, content, resultsEl, installedNames);
       });
       // List every published ability immediately, not just after the
       // operator explicitly searches for something.
-      runAbilitySearch(name, '', content, resultsEl);
+      runAbilitySearch(name, '', content, resultsEl, installedNames);
     }
 
     var installForm = content.querySelector('#abilityInstallForm');
@@ -1432,7 +1497,8 @@ export const agentsConfigPageHtml = `<!doctype html>
     var content = abilitiesContentEl();
     if (!content) return;
     content.innerHTML = renderAbilitiesConfigHtml(data);
-    wireAbilitiesHandlers(name);
+    var installedNames = (data.abilities || []).map(function (a) { return a.name; });
+    wireAbilitiesHandlers(name, installedNames);
     abilitiesLoadedFor = name;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loopengine",
-  "version": "0.1.38",
+  "version": "0.1.41",
   "type": "module",
   "description": "Runtime for tool-using AI agents with a transparent ReAct loop.",
   "license": "MIT",