@ponythewhite/base-context 1.0.14 → 1.0.16

package/dist/core/kernel/repl-manager.js

@@ -78,6 +78,37 @@ export class ReplKernelManager {
     childOrphanOwner;
     readyDeferred;
     pythonVersion;
+    jobWatchCapability = false;
+    jobWatchRequests = new Map();
+    jobWatchProbe(request) {
+        if (!this.jobWatchCapability || !this.isRunning)
+            return Promise.reject(new Error("Kernel job_watch_probe_v1 is unavailable; no probe was launched"));
+        const id = uuid();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.jobWatchRequests.delete(id);
+                void this.writeLine({ type: "job_watch_probe", id, cancel: true }).catch(() => { });
+                reject(new Error("Job watch probe transport timed out"));
+            }, request.timeoutMs + 5000);
+            timer.unref();
+            this.jobWatchRequests.set(id, { watchId: request.watchId, resolve, reject, timer });
+            void this.writeLine({ type: "job_watch_probe", id, ...request }).catch((error) => {
+                clearTimeout(timer);
+                this.jobWatchRequests.delete(id);
+                reject(error);
+            });
+        });
+    }
+    cancelJobWatchProbe(watchId) {
+        for (const [id, pending] of this.jobWatchRequests) {
+            if (pending.watchId !== watchId)
+                continue;
+            clearTimeout(pending.timer);
+            this.jobWatchRequests.delete(id);
+            void this.writeLine({ type: "job_watch_probe", id, cancel: true }).catch(() => { });
+            pending.reject(new Error("Job watch probe cancelled"));
+        }
+    }
     kernelStderr = "";
     /** Serializes execute() calls — the runtime runs one request at a time. */
     executionQueue = Promise.resolve();
@@ -404,6 +435,11 @@ export class ReplKernelManager {
                 return;
             this.appendKernelDiagnostic(`kernel stdout error: ${errorMessage(error)}`);
         });
+        child.stderr?.on("error", (error) => {
+            if (this.child !== child)
+                return;
+            this.appendKernelDiagnostic(`kernel stderr error: ${errorMessage(error)}`);
+        });
         child.once("exit", () => {
             // One turn for the poll phase to deliver the bytes the kernel wrote
             // before dying (the pipe buffer bounds them), then destroy: EOF may
@@ -721,6 +757,8 @@ export class ReplKernelManager {
     handleEvent(event) {
         const type = event.event;
         if (type === "ready") {
+            this.jobWatchCapability =
+                Array.isArray(event.capabilities) && event.capabilities.includes("job_watch_probe_v1");
             this.pythonVersion = typeof event.python === "string" ? event.python : undefined;
             this.readyDeferred?.resolve(typeof event.protocol === "number" ? event.protocol : -1);
             return;
@@ -1213,6 +1251,19 @@ export class ReplKernelManager {
         if (typeof data.type !== "string" || data.type.length === 0) {
             throw new Error("host request payload must have a string type");
         }
+        if (data.type === "job_watch.probe_result") {
+            const id = typeof data.request_id === "string" ? data.request_id : "";
+            const pending = this.jobWatchRequests.get(id);
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.jobWatchRequests.delete(id);
+                if (isRecord(data.result))
+                    pending.resolve(data.result);
+                else
+                    pending.reject(new Error("Malformed job watch probe result"));
+            }
+            return {};
+        }
         const handler = this.options.hostHandlers?.[data.type];
         if (!handler) {
             throw new Error(`host request type "${data.type}" is not available in this session`);
@@ -1273,6 +1324,12 @@ export class ReplKernelManager {
         await this.writeLine({ type: "interrupt", id: requestId });
     }
     cleanupResources(killSignal = "SIGTERM") {
+        this.jobWatchCapability = false;
+        for (const pending of this.jobWatchRequests.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error("Kernel lost; job state is unknown"));
+        }
+        this.jobWatchRequests.clear();
         const failures = [];
         this.startGeneration++; // any teardown invalidates in-flight starts
         this.clearSnapshotTimer();