pinokiod 7.2.7 → 7.2.9

package/server/lib/workspace_runtime.js

@@ -0,0 +1,390 @@
+const path = require("path");
+
+function createWorkspaceRuntimeService({ kernel }) {
+  if (!kernel) {
+    throw new Error("kernel is required");
+  }
+
+  const normalizePathKey = (value) => {
+    if (typeof value !== "string" || !value.trim()) {
+      return "";
+    }
+    const resolved = path.resolve(value.trim());
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+  };
+
+  const decodeMaybe = (value) => {
+    const raw = typeof value === "string" ? value.trim() : "";
+    if (!raw) {
+      return "";
+    }
+    try {
+      return decodeURIComponent(raw).trim();
+    } catch (_) {
+      return raw;
+    }
+  };
+
+  const resolveCandidatePath = (value) => {
+    const decoded = decodeMaybe(value);
+    if (!decoded || decoded.includes("\0")) {
+      return "";
+    }
+    if (decoded.startsWith("~/")) {
+      return path.resolve(kernel.homedir, decoded.slice(2));
+    }
+    if (path.isAbsolute(decoded)) {
+      return path.resolve(decoded);
+    }
+    return "";
+  };
+
+  const knownRoots = () => {
+    const roots = [];
+    const addRoot = (type, label) => {
+      if (!kernel || typeof kernel.path !== "function") {
+        return;
+      }
+      const rootPath = kernel.path(type);
+      if (typeof rootPath === "string" && rootPath.trim()) {
+        roots.push({
+          type,
+          label,
+          path: path.resolve(rootPath)
+        });
+      }
+    };
+    addRoot("workspaces", "Workspace");
+    addRoot("api", "App");
+    addRoot("plugin", "Plugin");
+    return roots;
+  };
+
+  const isPathWithin = (candidate, root) => {
+    if (!candidate || !root) {
+      return false;
+    }
+    const relative = path.relative(root, candidate);
+    return Boolean(relative && !relative.startsWith("..") && !path.isAbsolute(relative));
+  };
+
+  const resolveWorkspaceForPath = (candidatePath) => {
+    const candidate = resolveCandidatePath(candidatePath);
+    if (!candidate) {
+      return null;
+    }
+    for (const root of knownRoots()) {
+      if (!isPathWithin(candidate, root.path)) {
+        continue;
+      }
+      const relative = path.relative(root.path, candidate);
+      const segments = relative.split(path.sep).filter(Boolean);
+      const name = segments[0] || "";
+      if (!name) {
+        continue;
+      }
+      const cwd = path.resolve(root.path, name);
+      return {
+        key: normalizePathKey(cwd),
+        cwd,
+        name,
+        root: root.type,
+        rootLabel: root.label
+      };
+    }
+    return null;
+  };
+
+  const parseParamsFromText = (value) => {
+    const raw = typeof value === "string" ? value : "";
+    const index = raw.indexOf("?");
+    if (index < 0) {
+      return null;
+    }
+    try {
+      return new URLSearchParams(raw.slice(index + 1).replace(/&amp;/g, "&"));
+    } catch (_) {
+      return null;
+    }
+  };
+
+  const firstWorkspaceFromCandidates = (candidates) => {
+    for (const candidate of candidates) {
+      const workspace = resolveWorkspaceForPath(candidate);
+      if (workspace) {
+        return workspace;
+      }
+    }
+    return null;
+  };
+
+  const getShellCandidates = (shell) => {
+    const candidates = [];
+    if (!shell || typeof shell !== "object") {
+      return candidates;
+    }
+    const push = (value) => {
+      if (typeof value === "string" && value.trim()) {
+        candidates.push(value);
+      }
+    };
+    push(shell.path);
+    push(shell.group);
+    if (shell.params && typeof shell.params === "object") {
+      push(shell.params.cwd);
+      push(shell.params.path);
+      if (shell.params.$parent && typeof shell.params.$parent === "object") {
+        push(shell.params.$parent.cwd);
+        push(shell.params.$parent.path);
+      }
+    }
+    for (const text of [shell.id, shell.group]) {
+      const params = parseParamsFromText(text);
+      if (!params) {
+        continue;
+      }
+      push(params.get("cwd"));
+      push(params.get("path"));
+    }
+    return candidates;
+  };
+
+  const getScriptCandidates = (id) => {
+    const candidates = [];
+    const raw = typeof id === "string" ? id : "";
+    if (!raw) {
+      return candidates;
+    }
+    const params = parseParamsFromText(raw);
+    if (params) {
+      candidates.push(params.get("cwd"));
+      candidates.push(params.get("path"));
+    }
+    const pathPart = raw.split("?")[0];
+    candidates.push(pathPart);
+    return candidates;
+  };
+
+  const parseTerminalIdFromText = (value) => {
+    const params = parseParamsFromText(value);
+    if (!params) {
+      return "";
+    }
+    const terminalId = params.get("terminal_id");
+    return typeof terminalId === "string" ? terminalId.trim() : "";
+  };
+
+  const buildShellUrl = (shell) => {
+    const raw = shell && typeof shell.id === "string" ? shell.id.trim() : "";
+    if (!raw) {
+      return "";
+    }
+    const index = raw.indexOf("?");
+    const base = index >= 0 ? raw.slice(0, index) : raw;
+    const query = index >= 0 ? raw.slice(index + 1) : "";
+    const params = new URLSearchParams(query);
+    if (!params.has("path") && shell && typeof shell.path === "string" && shell.path.trim()) {
+      params.set("path", shell.path.trim());
+    }
+    if (!params.has("terminal_id") && shell && typeof shell.terminal_id === "string" && shell.terminal_id.trim()) {
+      params.set("terminal_id", shell.terminal_id.trim());
+    }
+    if (!params.has("input")) {
+      params.set("input", "1");
+    }
+    const queryString = params.toString();
+    let route = "";
+    if (base.startsWith("/shell/")) {
+      const shellId = base.slice("/shell/".length);
+      route = shellId.includes("/")
+        ? `/shell/${encodeURIComponent(shellId)}`
+        : base;
+    } else if (base.startsWith("shell/")) {
+      route = `/shell/${encodeURIComponent(base.slice("shell/".length))}`;
+    } else {
+      route = `/shell/${encodeURIComponent(base)}`;
+    }
+    return queryString ? `${route}?${queryString}` : route;
+  };
+
+  const buildRunUrl = (id) => {
+    const raw = typeof id === "string" ? id.trim() : "";
+    if (!raw) {
+      return "";
+    }
+    const index = raw.indexOf("?");
+    const scriptPath = resolveCandidatePath(index >= 0 ? raw.slice(0, index) : raw);
+    const query = index >= 0 ? raw.slice(index + 1) : "";
+    if (!scriptPath) {
+      return "";
+    }
+    const roots = [
+      { name: "api", path: kernel.path("api") },
+      { name: "plugin", path: kernel.path("plugin") },
+      { name: "scripts", path: kernel.path("scripts") }
+    ].filter((root) => typeof root.path === "string" && root.path.trim());
+    for (const root of roots) {
+      const rootPath = path.resolve(root.path);
+      const relative = path.relative(rootPath, scriptPath);
+      if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+        continue;
+      }
+      const params = new URLSearchParams(query);
+      if (!params.has("chrome")) {
+        params.set("chrome", "full");
+      }
+      const route = relative.split(path.sep).map(encodeURIComponent).join("/");
+      const queryString = params.toString();
+      return `/run/${root.name}/${route}${queryString ? `?${queryString}` : ""}`;
+    }
+    return "";
+  };
+
+  const shellTitle = (shell) => {
+    if (shell && shell.params && typeof shell.params.$title === "string" && shell.params.$title.trim()) {
+      return shell.params.$title.trim();
+    }
+    if (shell && typeof shell.cmd === "string" && shell.cmd.trim()) {
+      return shell.cmd.trim().slice(0, 120);
+    }
+    return "Terminal";
+  };
+
+  const scriptTitle = (id) => {
+    const raw = typeof id === "string" ? id.trim() : "";
+    if (!raw) {
+      return "Script";
+    }
+    const pathPart = raw.split("?")[0];
+    if (pathPart && path.isAbsolute(pathPart)) {
+      return path.basename(pathPart) || "Script";
+    }
+    return raw.slice(0, 120);
+  };
+
+  const createGroup = (workspace) => ({
+    cwd: workspace.cwd,
+    name: workspace.name,
+    root: workspace.root,
+    rootLabel: workspace.rootLabel,
+    running: true,
+    shells: [],
+    scripts: []
+  });
+
+  const list = () => {
+    const groups = new Map();
+    const unscoped = {
+      shells: [],
+      scripts: []
+    };
+    const getGroup = (workspace) => {
+      if (!workspace || !workspace.key) {
+        return null;
+      }
+      if (!groups.has(workspace.key)) {
+        groups.set(workspace.key, createGroup(workspace));
+      }
+      return groups.get(workspace.key);
+    };
+
+    const shells = kernel.shell && Array.isArray(kernel.shell.shells)
+      ? kernel.shell.shells
+      : [];
+    for (const shell of shells) {
+      if (!shell || shell.done === true || !shell.ptyProcess) {
+        continue;
+      }
+      const item = {
+        id: typeof shell.id === "string" ? shell.id : "",
+        group: typeof shell.group === "string" ? shell.group : "",
+        title: shellTitle(shell),
+        cwd: typeof shell.path === "string" ? shell.path : "",
+        state: shell.state || null,
+        start_time: Number.isFinite(shell.start_time) ? shell.start_time : null,
+        terminal_id: shell.terminal_id || parseTerminalIdFromText(shell.id) || parseTerminalIdFromText(shell.group) || null,
+        url: buildRunUrl(shell.group) || buildShellUrl(shell)
+      };
+      const workspace = firstWorkspaceFromCandidates(getShellCandidates(shell));
+      const group = getGroup(workspace);
+      if (group) {
+        group.shells.push(item);
+      } else {
+        unscoped.shells.push(item);
+      }
+    }
+
+    const running = kernel.api && kernel.api.running && typeof kernel.api.running === "object"
+      ? kernel.api.running
+      : {};
+    for (const id of Object.keys(running)) {
+      if (typeof id !== "string" || !id || id.startsWith("shell/")) {
+        continue;
+      }
+      const item = {
+        id,
+        title: scriptTitle(id),
+        path: id.split("?")[0],
+        cwd: "",
+        url: buildRunUrl(id)
+      };
+      const workspace = firstWorkspaceFromCandidates(getScriptCandidates(id));
+      if (workspace) {
+        item.cwd = workspace.cwd;
+      }
+      const group = getGroup(workspace);
+      if (group) {
+        group.scripts.push(item);
+      } else {
+        unscoped.scripts.push(item);
+      }
+    }
+
+    const workspaces = Array.from(groups.values())
+      .map((workspace) => ({
+        ...workspace,
+        counts: {
+          shells: workspace.shells.length,
+          scripts: workspace.scripts.length
+        }
+      }))
+      .sort((a, b) => {
+        const totalA = a.counts.shells + a.counts.scripts;
+        const totalB = b.counts.shells + b.counts.scripts;
+        if (totalA !== totalB) {
+          return totalB - totalA;
+        }
+        return String(a.name || "").localeCompare(String(b.name || ""));
+      });
+
+    return {
+      workspaces,
+      unscoped,
+      counts: {
+        workspaces: workspaces.length,
+        shells: workspaces.reduce((total, workspace) => total + workspace.counts.shells, 0) + unscoped.shells.length,
+        scripts: workspaces.reduce((total, workspace) => total + workspace.counts.scripts, 0) + unscoped.scripts.length
+      }
+    };
+  };
+
+  const summary = () => {
+    const runtime = list();
+    return {
+      runningWorkspaces: runtime.counts.workspaces,
+      runningShells: runtime.counts.shells,
+      runningScripts: runtime.counts.scripts,
+      unscopedShells: runtime.unscoped.shells.length,
+      unscopedScripts: runtime.unscoped.scripts.length
+    };
+  };
+
+  return {
+    list,
+    summary
+  };
+}
+
+module.exports = {
+  createWorkspaceRuntimeService
+};

package/server/public/common.js

@@ -2328,6 +2328,14 @@ if (typeof hotkeys === 'function') {
     playNextSound();
   };
 
+  window.PinokioPlayNotificationSound = (sound) => {
+    if (sound === false || isFalseyString(sound)) {
+      return false;
+    }
+    enqueueSound(typeof sound === 'string' && sound ? sound : '/chime.mp3');
+    return true;
+  };
+
   const handlePacket = (packet) => {
     if (!packet || packet.id !== CHANNEL_ID || packet.type !== 'notification') {
       return;

package/server/routes/workspaces.js

@@ -0,0 +1,44 @@
+const express = require("express")
+
+function registerWorkspacesRoutes(app, options = {}) {
+  const {
+    workspaceCatalog,
+    composePeerAccessPayload,
+    getTheme,
+    getPeers,
+    getCurrentHost,
+    getPortal,
+  } = options
+
+  if (!workspaceCatalog) {
+    throw new Error("workspaceCatalog is required")
+  }
+
+  const router = express.Router()
+
+  router.get("/workspaces", async (req, res, next) => {
+    try {
+      const catalog = await workspaceCatalog.list({ sort: req.query.sort })
+      res.render("workspaces", {
+        title: "Workspaces",
+        sidebarSelected: "workspaces",
+        workspaceCatalog: catalog,
+        theme: getTheme ? getTheme(req) : null,
+        peers: getPeers ? getPeers() : [],
+        currentHost: getCurrentHost ? getCurrentHost(req) : null,
+        portal: getPortal ? getPortal(req) : null,
+        peerAccess: composePeerAccessPayload ? composePeerAccessPayload(req) : null,
+      })
+    } catch (err) {
+      next(err)
+    }
+  })
+
+  router.get("/activity", (req, res) => {
+    res.redirect("/workspaces")
+  })
+
+  app.use(router)
+}
+
+module.exports = registerWorkspacesRoutes

package/server/socket.js

@@ -284,7 +284,7 @@ class Socket {
                 } else {
                   let buf = this.buffer[id]
                   let sh = this.active_shell[id]
-                  this.subscribe(ws, id, buf, sh)
+                  this.subscribe(ws, id, buf, sh, req)
                   if (req.mode !== "listen") {
                     // Run only if currently not running
                     if (!this.parent.kernel.api.running[id]) {
@@ -308,7 +308,7 @@ class Socket {
             if (req.id) {
               let buf = this.buffer[req.id]
               let sh = this.active_shell[req.id]
-              this.subscribe(ws, req.id, buf, sh)
+              this.subscribe(ws, req.id, buf, sh, req)
               if (req.mode === "listen") {
                 return
               }
@@ -345,13 +345,7 @@ class Socket {
                 // Mark local client sockets by IP matching any local address
                 try {
                   const ip = ws._ip || ''
-                  const isLocal = (addr) => {
-                    if (!addr || typeof addr !== 'string') return false
-                    if (this.localAddresses.has(addr)) return true
-                    const v = addr.trim().toLowerCase()
-                    return v.startsWith('::ffff:127.') || v.startsWith('127.')
-                  }
-                  ws._isLocalClient = isLocal(ip)
+                  ws._isLocalClient = this.isLocalAddress(ip)
                   if (ws._isLocalClient && ws._deviceId) {
                     this.localDeviceIds.add(ws._deviceId)
                   }
@@ -431,18 +425,22 @@ class Socket {
       this.old_buffer = structuredClone(this.buffer)
     }, 5000)
   }
-  subscribe(ws, id, buf, sh) {
+  subscribe(ws, id, buf, sh, req = {}) {
     let resolvedShellId = sh || null
     let resolvedState = buf
     let hasState = typeof resolvedState === "string" ? resolvedState.length > 0 : Boolean(resolvedState)
+    let resolvedShell = null
     if ((!resolvedShellId || !hasState) && this.parent && this.parent.kernel && this.parent.kernel.shell && Array.isArray(this.parent.kernel.shell.shells)) {
-      const groupedShell = this.parent.kernel.shell.shells.find((candidate) => {
+      const directShell = this.parent.kernel.shell.get(id)
+      const liveDirectShell = directShell && directShell.done !== true ? directShell : null
+      const groupedShell = liveDirectShell || this.parent.kernel.shell.shells.find((candidate) => {
         return candidate
           && candidate.done !== true
           && typeof candidate.group === "string"
           && candidate.group === id
       })
       if (groupedShell) {
+        resolvedShell = groupedShell
         if (!resolvedShellId) {
           resolvedShellId = groupedShell.id
         }
@@ -455,6 +453,12 @@ class Socket {
         }
       }
     }
+    if (!resolvedShell && resolvedShellId && this.parent && this.parent.kernel && this.parent.kernel.shell) {
+      resolvedShell = this.parent.kernel.shell.get(resolvedShellId)
+    }
+    if (resolvedShell && req && req.input) {
+      resolvedShell.input = true
+    }
     if (this.parent.kernel.api.running[id] || resolvedShellId || hasState) {
       ws.send(JSON.stringify({
         type: "connect",
@@ -652,6 +656,13 @@ class Socket {
     return this.localDeviceIds.has(deviceId)
   }
 
+  isLocalAddress(addr) {
+    if (!addr || typeof addr !== 'string') return false
+    if (this.localAddresses.has(addr)) return true
+    const v = addr.trim().toLowerCase()
+    return v === 'localhost' || v === '::1' || v.startsWith('::ffff:127.') || v.startsWith('127.')
+  }
+
   ensureNotificationBridge() {
     if (this.notificationBridgeDispose) {
       return