@zenera/neo 1.1.24 → 1.1.26

package/dist/runner.js

@@ -449,6 +449,13 @@ export class AgentRunner {
         catch (e) {
             return fail(`error: arguments are not valid JSON: ${String(e)}`);
         }
+        if (typeof args !== 'object' || args === null || Array.isArray(args)) {
+            return fail(`error: arguments to ${def.name} must be a JSON object`);
+        }
+        const missing = (def.parameters.required ?? []).filter((k) => args[k] == null);
+        if (missing.length) {
+            return fail(`error: ${def.name} is missing required arguments: ${missing.join(', ')}`);
+        }
         try {
             const out = await def.execute(args, {
                 ctx: state.context,

package/dist/tools/sandbox.js

@@ -243,7 +243,10 @@ export class Sandbox {
             this.#created = true;
             return;
         }
-        await this.#must(this.#createArgs(), `could not create container ${this.name}`);
+        const made = await this.#podman(this.#createArgs());
+        if (made.code !== 0) {
+            throw new SandboxError(`could not create container ${this.name}: ${message(made)}`, LOCKS.test(made.stderr) ? locksHint(this.spec.engine) : undefined);
+        }
         this.#created = true;
     }
     #createArgs() {
@@ -320,7 +323,13 @@ export class Sandbox {
         const cwd = this.inside(opts.cwd);
         const timeoutMs = this.#timeout(opts.timeout);
         const startedAt = Date.now();
-        const res = await this.#run(this.spec.engine, ['exec', '--interactive', '--workdir', cwd, this.name, '/bin/sh', '-s'], { input: command, timeoutMs, signal: opts.signal });
+        const once = () => this.#run(this.spec.engine, ['exec', '--interactive', '--workdir', cwd, this.name, '/bin/sh', '-s'], { input: command, timeoutMs, signal: opts.signal });
+        let res = await once();
+        if (gone(res)) {
+            // podman refused before running anything, so the retry cannot run the command twice.
+            await this.#revive(res);
+            res = await once();
+        }
         return {
             exit_code: res.code,
             stdout: res.stdout,
@@ -527,6 +536,18 @@ export class Sandbox {
     #podman(args) {
         return this.#run(this.spec.engine, args, { timeoutMs: 120_000 });
     }
+    /** The container stopped or vanished under us (machine slept, restarted, or someone removed it). */
+    async #revive(res) {
+        this.#ready = undefined;
+        try {
+            await this.start();
+        }
+        catch (err) {
+            throw new SandboxError(`the sandbox container ${this.name} stopped (${message(res)}) and could not be restarted: ` +
+                (err instanceof Error ? err.message : String(err)), `the ${this.spec.engine} machine may have stopped or restarted — check \`${this.spec.engine} machine list\`, ` +
+                `start it with \`${this.spec.engine} machine start\`, then retry`);
+        }
+    }
     async #must(args, what) {
         const res = await this.#podman(args);
         if (res.code !== 0) {
@@ -541,6 +562,23 @@ function mount(m) {
 function message(res) {
     return (res.stderr.trim() || res.stdout.trim() || `exit ${res.code}`).split('\n')[0];
 }
+/** podman's words for "every lock is taken": `allocating lock … exceeded num_locks (2048)`. */
+const LOCKS = /exceeded num_locks|allocating lock/i;
+/**
+ * A stopped container holds a lock as surely as a running one, and a
+ * persisted sandbox is stopped, never removed — so they pile up one per
+ * session until the engine can create nothing at all, for anyone.
+ */
+function locksHint(engine) {
+    return (`the ${engine} engine has no locks left: every container it holds, stopped ones ` +
+        `included, takes one. Remove the stopped sandbox containers with ` +
+        `\`${engine} container prune --force --filter label=zenera=1\`, then retry`);
+}
+/** podman's own exit code for "could not exec at all", with the two reasons that mean the container is not there to exec in. */
+function gone(res) {
+    return (res.code === 125 &&
+        /can only create exec sessions on running containers|container state improper|no such container/i.test(res.stderr));
+}
 /** Only ever applied to paths this module derived, never to a model's text. */
 function quote(s) {
     return `'${s.replaceAll("'", `'\\''`)}'`;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zenera/neo",
-    "version": "1.1.24",
+    "version": "1.1.26",
     "description": "A multi-agent runtime for Node.js: agents, models, tools, skills, memory and an append-only trajectory.",
     "keywords": [
         "agents",