mtech-ai-local-runner 0.1.30 → 0.1.32

package/dist/src/config.js

@@ -6,11 +6,11 @@ export function isExecutionConfig(config) {
     return config.mode === "shadow" || config.mode === "once";
 }
 export function isServiceConfig(config) {
-    return ["setup", "doctor", "run", "start", "stop", "status", "uninstall", "manual-codex"].includes(config.mode);
+    return ["setup", "doctor", "run", "start", "stop", "status", "uninstall", "manual-codex", "publication-recover"].includes(config.mode);
 }
 const EXECUTION_MODES = ["shadow", "once"];
 const AUTH_MODES = ["login", "logout"];
-const SERVICE_MODES = ["setup", "doctor", "run", "start", "stop", "status", "uninstall", "manual-codex"];
+const SERVICE_MODES = ["setup", "doctor", "run", "start", "stop", "status", "uninstall", "manual-codex", "publication-recover"];
 const ALL_MODES = [...EXECUTION_MODES, ...AUTH_MODES, ...SERVICE_MODES];
 export const DEFAULT_GATEWAY_MCP_URL = "https://cloud.dev.service.ai-gateway.laravelvapor.org/api/v1/web/ai-gateway/mcp";
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -101,9 +101,9 @@ export function loadConfig(argv, env) {
     const stateRoot = defaultStateRootFromEnv(env);
     if (SERVICE_MODES.includes(mode)) {
         let manualJobId;
-        if (mode === 'manual-codex') {
+        if (mode === 'manual-codex' || mode === 'publication-recover') {
             if (rest.length !== 1 || !rest[0].startsWith('--job-id=') || !UUID_PATTERN.test(rest[0].slice(9)))
-                throw new Error('manual-codex requires exactly --job-id=<uuid>');
+                throw new Error(`${mode} requires exactly --job-id=<uuid>`);
             manualJobId = rest[0].slice(9).toLowerCase();
         }
         return {

package/dist/src/daemon/daemon.js

@@ -1,15 +1,73 @@
 export class Daemon {
     deps;
+    stopping = new AbortController();
     constructor(deps) {
         this.deps = deps;
     }
+    stop() { this.deps.poller.stop?.(); this.stopping.abort(); }
+    async suspend(state, duringExecution = false) {
+        const phase = state && typeof state === 'object' && 'phase' in state ? state.phase : undefined;
+        const reason = duringExecution ? 'execution_outcome_unknown' : phase === 'binding' || phase === 'binding_uncertain' ? 'binding_outcome_unknown' : 'runner_restarted';
+        try {
+            await this.deps.state.suspend?.(reason);
+        }
+        catch { /* Preserve original state and remain alive even if the marker cannot be written. */ }
+        try {
+            this.deps.reportRecoveryRequired?.(reason);
+        }
+        catch { /* Logging cannot reopen claims or exit suspended recovery. */ }
+        if (this.stopping.signal.aborted)
+            return;
+        if (this.deps.wait) {
+            await this.deps.wait(this.stopping.signal);
+            return;
+        }
+        // A pending promise does not keep Node alive. This timer deliberately stays
+        // referenced, holds the process lock and wakes only for explicit close.
+        await new Promise(resolve => {
+            const timer = setInterval(() => { }, 60_000);
+            this.stopping.signal.addEventListener('abort', () => { clearInterval(timer); resolve(); }, { once: true });
+        });
+    }
     async run() {
         await this.deps.lock.acquire();
         try {
-            const state = await this.deps.state.load();
-            if (state)
-                await this.deps.reconcile(state);
-            await this.deps.poller.run();
+            let state;
+            try {
+                state = await this.deps.state.load();
+                if (state !== null && state !== undefined) {
+                    await this.deps.reconcile(state);
+                    state = await this.deps.state.load();
+                }
+            }
+            catch {
+                await this.suspend(state);
+                return;
+            }
+            if (state !== null && state !== undefined) {
+                await this.suspend(state);
+                return;
+            }
+            if (this.stopping.signal.aborted)
+                return;
+            try {
+                await this.deps.poller.run();
+            }
+            catch {
+                try {
+                    this.deps.poller.stop?.();
+                }
+                catch { /* Still inspect retained state and suspend below. */ }
+            }
+            try {
+                state = await this.deps.state.load();
+            }
+            catch {
+                await this.suspend(undefined, true);
+                return;
+            }
+            if (state !== null && state !== undefined)
+                await this.suspend(state, true);
         }
         finally {
             await this.deps.lock.release();