loopengine 0.1.11 → 0.1.12

package/dist/bin/cli.js

@@ -320,6 +320,9 @@ async function main() {
             console.log(`Installed into agents/${agent}/:`);
             for (const p of installed)
                 console.log(`  ${p}`);
+            console.log();
+            console.log('Already running under `npx loopengine dev`? The new tool becomes active automatically.');
+            console.log('Running under `serve` (or nothing yet)? Restart the server to pick it up.');
         }
         catch (err) {
             console.error(err instanceof Error ? err.message : String(err));

package/dist/bin/package-manager.d.ts

@@ -64,12 +64,30 @@ export interface FetchOptions {
  * createHttpTool does), copies each skill directory verbatim (a raw
  * cpSync, not skills-admin.ts's writeSkill — that regenerates
  * frontmatter from scratch and can't carry a package's own
- * frontmatter/assets), appends each actauth rule (addActauthRule), then
- * splices the newly-imported tools into the live agent registry so
- * they're callable immediately, no restart — same updateAgent call
- * adapters/http.ts's handleHttpToolPost already makes. All-or-nothing:
- * every collision check below runs, and the whole install is refused,
- * before a single file is written. */
+ * frontmatter/assets), and appends each actauth rule (addActauthRule).
+ *
+ * Deliberately does *not* attempt a live in-memory registry splice the
+ * way adapters/http.ts's own handleHttpToolPost does for an
+ * admin-created tool — that works there because the HTTP request
+ * creating the tool runs *inside the same process* as the already-running
+ * server, so updateAgent's mutation is visible to every later request in
+ * that same process immediately. `add-package` is a separate, one-off
+ * CLI process with no connection to whatever server might be running
+ * elsewhere — even a successful getEntry/updateAgent call here would
+ * only mutate *this* CLI invocation's own throwaway registry, then
+ * vanish the moment the process exits, having done nothing to the real
+ * running server. (Confirmed live: this used to import
+ * core/agent-registry.js, whose own discoverAgents does a top-level
+ * directory scan relative to *its own compiled file's location* —
+ * inside node_modules/loopengine when this runs there, not the
+ * consuming project's real agents/ at all, throwing ENOENT immediately.)
+ * Same reason add-agent/add-subagent above don't attempt this either —
+ * a new tool becomes active the same way a new agent does: the next
+ * request under `serve`, or automatically under `npx loopengine dev`'s
+ * file watcher once tools/index.ts's own edit is picked up.
+ *
+ * All-or-nothing: every collision check below runs, and the whole
+ * install is refused, before a single file is written. */
 export declare function installPackage(agentName: string, spec: string, options?: FetchOptions): Promise<{
     installed: string[];
 }>;

package/dist/bin/package-manager.js

@@ -21,12 +21,9 @@ import { execFileSync } from 'node:child_process';
 import { basename, join } from 'node:path';
 import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { pathToFileURL } from 'node:url';
 import { parse as parseYaml } from 'yaml';
 import semver from 'semver';
 import { agentDir } from '../core/gateway-tools.js';
-import { getEntry, updateAgent } from '../core/agent-registry.js';
-import { loadDefaultTools } from '../core/run-agent.js';
 import { addToolToIndex, toCamelCase } from '../web/http-tool-admin.js';
 import { addActauthRule, updateActauthRule, removeActauthRule, readActauthConfig } from '../web/actauth-admin.js';
 export class PackageManifestError extends Error {
@@ -137,7 +134,20 @@ function checkLoopengineVersion(manifest, installedRangeOverride) {
             throw new PackageVersionError(`This project's package.json has no "loopengine" dependency — can't check compatibility.`);
         }
     }
-    const floor = semver.minVersion(installedRange);
+    // A non-registry dependency specifier (file:, git:, workspace:, ...) —
+    // common for local development against an unpublished loopengine
+    // build — isn't a semver range at all, so minVersion throws rather
+    // than returning null; nothing meaningful to compare against, so skip
+    // the check rather than crash the whole command on it (same "nothing
+    // to compare, nothing to refuse" reasoning the this-repo-itself skip
+    // above already uses).
+    let floor;
+    try {
+        floor = semver.minVersion(installedRange);
+    }
+    catch {
+        return;
+    }
     if (!floor || !semver.satisfies(floor, manifest.loopengineVersion)) {
         throw new PackageVersionError(`Package '${manifest.name}' needs loopengine ${manifest.loopengineVersion}, but this project depends on loopengine ${installedRange} — bump the dependency first.`);
     }
@@ -162,12 +172,30 @@ function parseActauthRules(packageDir, manifest) {
  * createHttpTool does), copies each skill directory verbatim (a raw
  * cpSync, not skills-admin.ts's writeSkill — that regenerates
  * frontmatter from scratch and can't carry a package's own
- * frontmatter/assets), appends each actauth rule (addActauthRule), then
- * splices the newly-imported tools into the live agent registry so
- * they're callable immediately, no restart — same updateAgent call
- * adapters/http.ts's handleHttpToolPost already makes. All-or-nothing:
- * every collision check below runs, and the whole install is refused,
- * before a single file is written. */
+ * frontmatter/assets), and appends each actauth rule (addActauthRule).
+ *
+ * Deliberately does *not* attempt a live in-memory registry splice the
+ * way adapters/http.ts's own handleHttpToolPost does for an
+ * admin-created tool — that works there because the HTTP request
+ * creating the tool runs *inside the same process* as the already-running
+ * server, so updateAgent's mutation is visible to every later request in
+ * that same process immediately. `add-package` is a separate, one-off
+ * CLI process with no connection to whatever server might be running
+ * elsewhere — even a successful getEntry/updateAgent call here would
+ * only mutate *this* CLI invocation's own throwaway registry, then
+ * vanish the moment the process exits, having done nothing to the real
+ * running server. (Confirmed live: this used to import
+ * core/agent-registry.js, whose own discoverAgents does a top-level
+ * directory scan relative to *its own compiled file's location* —
+ * inside node_modules/loopengine when this runs there, not the
+ * consuming project's real agents/ at all, throwing ENOENT immediately.)
+ * Same reason add-agent/add-subagent above don't attempt this either —
+ * a new tool becomes active the same way a new agent does: the next
+ * request under `serve`, or automatically under `npx loopengine dev`'s
+ * file watcher once tools/index.ts's own edit is picked up.
+ *
+ * All-or-nothing: every collision check below runs, and the whole
+ * install is refused, before a single file is written. */
 export async function installPackage(agentName, spec, options = {}) {
     const fetch = options.fetchPackageDir ?? fetchPackageDir;
     const packageDir = fetch(spec);
@@ -215,19 +243,11 @@ export async function installPackage(agentName, spec, options = {}) {
         }
     }
     const contentHashes = {};
-    // Write tool files, patch tools/index.ts, dynamic-import each fresh
-    // file. currentTools is captured once, before any write — accumulate
-    // newly-installed tools locally and splice with one final updateAgent
-    // call, avoiding the exact double-append hazard handleHttpToolPost's
-    // own comment already warns about for a folder-form agent with no
-    // cached config.tools (re-reading tools/index.ts after it's already
-    // been patched would see the just-added entry a second time).
+    // Write tool files and patch tools/index.ts — pure filesystem
+    // operations, no dynamic import and no registry interaction (see this
+    // function's own doc comment for why: a CLI process can't live-splice
+    // into a separate, already-running server).
     if (toolNames.length > 0) {
-        const entry = getEntry(agentName);
-        if (!entry)
-            throw new Error(`Unknown agent '${agentName}'.`);
-        const currentTools = entry.config.tools ?? (await loadDefaultTools(entry.config));
-        const newTools = [];
         mkdirSync(toolsDir, { recursive: true });
         const indexPath = join(toolsDir, 'index.ts');
         for (const toolFile of toolFiles) {
@@ -243,10 +263,7 @@ export async function installPackage(agentName, spec, options = {}) {
             else {
                 writeFileSync(indexPath, `import type { ToolDefinition } from 'loopengine'\nimport { ${exportName} } from './${toolName}.js'\n\nexport const tools: ToolDefinition[] = [${exportName}]\n`);
             }
-            const mod = (await import(pathToFileURL(destPath).href));
-            newTools.push(mod[exportName]);
         }
-        updateAgent(agentName, { config: { tools: [...currentTools, ...newTools] } });
     }
     // Copy skill directories verbatim.
     for (const skillDir of skillDirs) {

package/package.json

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