@pasko70/pibo 3.2.3 → 3.2.5

package/dist/tools/runtime/node-worker-source.js

@@ -1,5 +1,6 @@
 export const NODE_RUNTIME_WORKER_SOURCE = String.raw `
 const vm = require("node:vm");
+const inspector = require("node:inspector");
 const util = require("node:util");
 const fs = require("node:fs");
 const childProcess = require("node:child_process");
@@ -153,6 +154,7 @@ const consoleProxy = {
 	dir: (value, options) => appendStdout(util.inspect(value, options) + "\n"),
 };
 
+const runtimeContextName = "pibo-runtime-" + process.pid;
 const context = vm.createContext({
 	console: consoleProxy,
 	require: runtimeRequire,
@@ -169,10 +171,24 @@ const context = vm.createContext({
 	setImmediate,
 	clearImmediate,
 	queueMicrotask,
-});
+}, { name: runtimeContextName });
 context.global = context;
 context.globalThis = context;
 
+const inspectorSession = new inspector.Session();
+let runtimeContextId;
+inspectorSession.on("Runtime.executionContextCreated", ({ params }) => {
+	if (params.context.name === runtimeContextName) runtimeContextId = params.context.id;
+});
+inspectorSession.connect();
+const inspectorReady = inspectorPost("Runtime.enable");
+
+function inspectorPost(method, params = {}) {
+	return new Promise((resolve, reject) => {
+		inspectorSession.post(method, params, (error, result) => error ? reject(error) : resolve(result));
+	});
+}
+
 async function execute(req) {
 	const mode = req.mode || "exec";
 	const code = req.code || "";
@@ -230,16 +246,31 @@ async function inspectValue(req) {
 	}
 }
 
-function listVars(req) {
+async function listVars(req) {
 	const includePrivate = Boolean(req.includePrivate);
 	const maxItems = Number(req.maxItems || 100);
 	const maxBytes = Number(req.maxBytes || 4096);
 	const hidden = new Set(["console", "require", "process", "Buffer", "URL", "URLSearchParams", "TextEncoder", "TextDecoder", "global", "globalThis"]);
+	const lexicalNames = new Set();
+	try {
+		await inspectorReady;
+		if (runtimeContextId !== undefined) {
+			const result = await inspectorPost("Runtime.globalLexicalScopeNames", { executionContextId: runtimeContextId });
+			for (const name of result.names || []) lexicalNames.add(name);
+		}
+	} catch {}
+	const names = new Set([...Object.keys(context), ...lexicalNames]);
 	const variables = [];
-	for (const name of Object.keys(context).sort()) {
+	for (const name of [...names].sort()) {
 		if (hidden.has(name)) continue;
 		if (!includePrivate && name.startsWith("_")) continue;
-		variables.push({ name, summary: summarize(context[name], maxBytes) });
+		let value;
+		try {
+			value = lexicalNames.has(name) ? vm.runInContext(name, context, { filename: "<pibo-runtime>", timeout: 15000 }) : context[name];
+		} catch {
+			continue;
+		}
+		variables.push({ name, summary: summarize(value, maxBytes) });
 		if (variables.length >= maxItems) break;
 	}
 	return { id: req.id, status: "ok", variables, truncated: variables.length >= maxItems };
@@ -253,7 +284,10 @@ async function handle(req) {
 	if (req.type === "exec") return await execute(req);
 	if (req.type === "inspect") return await inspectValue(req);
 	if (req.type === "vars") return listVars(req);
-	if (req.type === "shutdown") return { id: req.id, status: "ok", shutdown: true };
+	if (req.type === "shutdown") {
+		inspectorSession.disconnect();
+		return { id: req.id, status: "ok", shutdown: true };
+	}
 	return { id: req.id, status: "error", error: { name: "RuntimeProtocolError", message: "unknown request type " + req.type } };
 }
 

package/dist/tools/runtime/python-backend.js

@@ -90,6 +90,9 @@ export class PythonRuntimeBackend {
     isAlive() {
         return this.alive;
     }
+    isBusy() {
+        return [...this.pending.values()].some((pending) => pending.requestType === "exec");
+    }
     getRecord() {
         return { pid: this.child.pid, cwd: this.cwd, executable: this.executable };
     }
@@ -194,10 +197,11 @@ export class PythonRuntimeBackend {
         const id = `req_${++this.requestCounter}`;
         return new Promise((resolveRequest, rejectRequest) => {
             const timer = setTimeout(() => {
-                this.pending.delete(id);
+                if (!this.pending.has(id))
+                    return;
                 rejectRequest(new TimeoutError(`Runtime request ${type} timed out after ${timeoutMs}ms`));
             }, timeoutMs);
-            this.pending.set(id, { resolve: resolveRequest, reject: rejectRequest, timer });
+            this.pending.set(id, { requestType: type, resolve: resolveRequest, reject: rejectRequest, timer });
             this.child.stdin.write(`${JSON.stringify({ id, type, ...payload })}\n`);
         });
     }

package/dist/tools/runtime/registry.js

@@ -30,6 +30,7 @@ function notFoundVars(sessionId = "auto") {
 export class RuntimeSessionRegistry {
     options;
     sessions = new Map();
+    defaultStarts = new Map();
     maxHistoryEntries;
     constructor(options) {
         this.options = options;
@@ -79,9 +80,23 @@ export class RuntimeSessionRegistry {
         }
     }
     async exec(controllerPiboSessionId, input) {
-        const session = input.sessionId
+        let session = input.sessionId
             ? this.getSessionForController(controllerPiboSessionId, input.sessionId)
-            : await this.getOrStartDefault(controllerPiboSessionId, input);
+            : this.getDefault(controllerPiboSessionId, input.runtime ?? "python");
+        if (!input.sessionId && !session) {
+            const runtime = input.runtime ?? "python";
+            const started = await this.getOrStartDefault(controllerPiboSessionId, input);
+            if (started.status !== "ok" || !started.sessionId) {
+                return {
+                    status: started.status === "ok" ? "failed" : started.status,
+                    sessionId: started.sessionId ?? "auto",
+                    runtime: started.runtime ?? runtime,
+                    durationMs: 0,
+                    error: started.error ?? { name: "RuntimeStartError", message: "Runtime session failed to start." },
+                };
+            }
+            session = this.getSessionForController(controllerPiboSessionId, started.sessionId);
+        }
         const sessionId = input.sessionId ?? session?.sessionId ?? "auto";
         if (!session)
             return notFoundExec(sessionId);
@@ -106,7 +121,9 @@ export class RuntimeSessionRegistry {
         result.executionCount = session.executionCount;
         session.lastExecAt = startedAt;
         session.updatedAt = nowIso();
-        session.status = session.backend.isAlive() ? "idle" : "failed";
+        session.status = session.backend.isAlive()
+            ? session.backend.isBusy?.() === true ? "busy" : "idle"
+            : "failed";
         this.appendHistory(session, {
             id: randomUUID(),
             startedAt,
@@ -223,14 +240,25 @@ export class RuntimeSessionRegistry {
         const runtime = input.runtime ?? "python";
         const existing = this.getDefault(controllerPiboSessionId, runtime);
         if (existing)
-            return existing;
-        const started = await this.start(controllerPiboSessionId, {
+            return { status: "ok", sessionId: existing.sessionId, runtime: existing.runtime };
+        const key = `${controllerPiboSessionId}\0${runtime}`;
+        const pending = this.defaultStarts.get(key);
+        if (pending)
+            return pending;
+        const start = this.start(controllerPiboSessionId, {
             runtime,
             name: input.name,
             target: input.target,
             timeoutMs: input.timeoutMs,
         });
-        return started.sessionId ? this.getSessionForController(controllerPiboSessionId, started.sessionId) : undefined;
+        this.defaultStarts.set(key, start);
+        try {
+            return await start;
+        }
+        finally {
+            if (this.defaultStarts.get(key) === start)
+                this.defaultStarts.delete(key);
+        }
     }
     getSessionForController(controllerPiboSessionId, sessionId) {
         const session = this.sessions.get(sessionId);
@@ -243,6 +271,10 @@ export class RuntimeSessionRegistry {
             session.status = "failed";
             session.updatedAt = nowIso();
         }
+        else if (session.status === "busy" && session.backend.isBusy?.() === false) {
+            session.status = "idle";
+            session.updatedAt = nowIso();
+        }
         return session;
     }
     appendHistory(session, entry) {

package/dist/vscode/cli.js

@@ -50,9 +50,8 @@ export async function runVscodeCli(argv = process.argv) {
         else if (result.status === "installed") {
             console.log(`installed\t${result.tagName}\t${result.vsixPath}`);
         }
-        else {
+        if (result.status === "failed")
             process.exitCode = 1;
-        }
     });
     program
         .command("uninstall")

package/dist/vscode/install.js

@@ -11,13 +11,13 @@
  * The resolved VSIX is cached under `~/.pibo/vscode/cache/<tagName>/` so
  * repeated installs do not re-download.
  */
+import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { detectCodeBinary, listInstalledExtensions, runCodeCommand } from "./code-cli.js";
 import { downloadVsixAsset, fetchLatestVsix, isVsixAsset } from "./vsix-fetcher.js";
 import { DEFAULT_GITHUB_OWNER, DEFAULT_GITHUB_REPO, PIBO_VSCODE_CACHE_DIR, PIBO_VSCODE_EXTENSION_ID, } from "./types.js";
-import { findVsixAsset, fetchRelease } from "./vsix-fetcher.js";
 const DEFAULT_LOG = (message) => {
     console.log(message);
 };
@@ -33,6 +33,9 @@ function getCacheDir(options) {
 function cacheKeyForVersion(tagName) {
     return tagName.replace(/[^A-Za-z0-9._-]/g, "_");
 }
+function cacheTagForUrl(url) {
+    return `url-${createHash("sha256").update(url).digest("hex").slice(0, 16)}`;
+}
 function readCachedVsix(cacheDir, tagName) {
     const dir = join(cacheDir, cacheKeyForVersion(tagName));
     const path = join(dir, "pibo.vsix");
@@ -73,19 +76,23 @@ export async function resolveVsixArtifact(options) {
         }
         return { tagName: "local", vsixPath: absolute };
     }
+    if (options.fromUrl) {
+        const tagName = cacheTagForUrl(options.fromUrl);
+        if (!options.skipCache) {
+            const cached = readCachedVsix(options.cacheDir, tagName);
+            if (cached)
+                return { tagName, vsixPath: cached };
+        }
+        const bytes = await downloadVsixAsset({ url: options.fromUrl, fetchImpl: options.fetchImpl });
+        const cachedPath = writeCachedVsix(options.cacheDir, tagName, bytes);
+        return { tagName, vsixPath: cachedPath, bytes };
+    }
     if (!options.skipCache && !options.version) {
         const cachedTag = readCachedTagManifest(options.cacheDir);
         if (cachedTag?.tagName && cachedTag.vsixPath && existsSync(cachedTag.vsixPath)) {
             return { tagName: cachedTag.tagName, vsixPath: cachedTag.vsixPath };
         }
     }
-    if (options.fromUrl) {
-        const release = await fetchRelease({ owner: options.owner, repo: options.repo, fetchImpl: options.fetchImpl });
-        const asset = findVsixAsset(release) ?? { name: "remote.vsix", browserDownloadUrl: options.fromUrl, size: 0, contentType: "application/octet-stream" };
-        const bytes = await downloadVsixAsset({ url: options.fromUrl, fetchImpl: options.fetchImpl });
-        const cachedPath = writeCachedVsix(options.cacheDir, release.tagName, bytes);
-        return { tagName: release.tagName, vsixPath: cachedPath, bytes };
-    }
     const result = await fetchLatestVsix({
         owner: options.owner,
         repo: options.repo,
@@ -151,7 +158,6 @@ export async function runInstall(options) {
         errorLog(reason);
         return { status: "failed", reason, codeBinary: detected.path, tagName: artifact.tagName };
     }
-    writeCachedTagManifest(cacheDir, artifact.tagName, artifact.vsixPath);
     try {
         const installed = await listInstalledExtensions({
             binary: detected.path,
@@ -159,18 +165,19 @@ export async function runInstall(options) {
             env: options.env,
         });
         const ours = installed.find((entry) => entry.id === PIBO_VSCODE_EXTENSION_ID);
-        if (ours) {
-            log(`Installed ${ours.id}@${ours.version ?? "?"} via ${detected.path}`);
-        }
-        else {
-            log(`code --install-extension reported success but ${PIBO_VSCODE_EXTENSION_ID} is not in the installed list.`);
+        if (!ours) {
+            const reason = `code --install-extension reported success but ${PIBO_VSCODE_EXTENSION_ID} is not in the installed list.`;
+            errorLog(reason);
+            return { status: "failed", reason, codeBinary: detected.path, tagName: artifact.tagName };
         }
+        log(`Installed ${ours.id}@${ours.version ?? "?"} via ${detected.path}`);
     }
     catch (listError) {
         // Listing the installed extensions is a best-effort check; do not fail the install on a listing error.
         const reason = listError instanceof Error ? listError.message : String(listError);
         log(`Install completed; failed to verify via --list-extensions: ${reason}`);
     }
+    writeCachedTagManifest(cacheDir, artifact.tagName, artifact.vsixPath);
     return { status: "installed", tagName: artifact.tagName, vsixPath: artifact.vsixPath, codeBinary: detected.path };
 }
 // Re-export for symmetry with code-cli.ts consumers.

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@pasko70/pibo",
-  "version": "3.2.3",
+  "version": "3.2.5",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@pasko70/pibo",
-      "version": "3.2.3",
+      "version": "3.2.5",
       "workspaces": [
         "packages/workflows"
       ],

package/package.json

@@ -1,7 +1,9 @@
 {
   "name": "@pasko70/pibo",
-  "version": "3.2.3",
+  "version": "3.2.5",
   "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "workspaces": [
     "packages/workflows"
   ],