npm - pinokiod - Versions diffs - 7.5.21 → 7.5.23 - Mend

pinokiod 7.5.21 → 7.5.23

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/kernel/plugin_sources.js +8 -0
package/package.json +1 -1
package/server/index.js +113 -13
package/server/lib/plugin_delete.js +89 -0
package/server/public/common.js +6 -2
package/server/public/plugin-detail.js +131 -1
package/server/public/task-launcher.css +221 -17
package/server/public/universal-launcher.js +2 -1
package/server/socket.js +59 -99
package/server/views/app.ejs +141 -20
package/server/views/plugin_detail.ejs +52 -20
package/server/views/plugins.ejs +14 -1
package/server/views/terminal.ejs +11 -5
package/test/plugin-delete.test.js +143 -0
package/test/plugin-detail-ui.test.js +269 -0
package/test/plugin-detail-view.test.js +160 -0
package/test/plugin-sources.test.js +19 -0
package/test/terminal-log-paths.test.js +238 -0
package/test/universal-launcher.smoke.spec.js +50 -0

package/test/plugin-detail-ui.test.js ADDED Viewed

@@ -0,0 +1,269 @@
+const assert = require("node:assert/strict")
+const fs = require("node:fs/promises")
+const path = require("node:path")
+const test = require("node:test")
+const { JSDOM, VirtualConsole } = require("jsdom")
+const repoRoot = path.resolve(__dirname, "..")
+function visibleTextMatches(document, selector, text) {
+  return Array.from(document.querySelectorAll(selector)).filter((element) => {
+    if (element.textContent.trim() !== text) {
+      return false
+    }
+    return !element.closest(".task-hidden")
+  })
+}
+async function renderSharePanel(shareOverrides, options = {}) {
+  const script = await fs.readFile(path.join(repoRoot, "server/public/plugin-detail.js"), "utf8")
+  const share = {
+    manageable: true,
+    githubConnected: false,
+    gitInitialized: false,
+    hasCommit: false,
+    remoteUrl: "",
+    remoteWebUrl: "",
+    hasPublished: false,
+    changeCount: 0,
+    aheadCount: 0,
+    createUrl: "/github/create",
+    commitUrl: "/github/commit",
+    pushUrl: "/github/push",
+    dir: "/tmp/demo-plugin",
+    ...shareOverrides,
+  }
+  const staticClass = share.remoteWebUrl || (share.remoteUrl && share.githubConnected) ? "" : " task-hidden"
+  const remoteClass = share.remoteWebUrl ? "" : " task-hidden"
+  const refreshClass = share.remoteUrl && share.githubConnected ? "" : " task-hidden"
+  const bootstrap = {
+    plugin: { title: "Demo Plugin", cwd: "/tmp/demo-plugin", pluginPath: "plugin/demo/pinokio.js" },
+    share,
+    apps: [],
+    stateUrl: "",
+  }
+  const dom = new JSDOM(`<!doctype html>
+<body>
+  ${options.actionMarkup || ""}
+  <section class="task-side-group">
+    <div class="task-section-note" data-plugin-share-note></div>
+    <div class="task-share-next-step-main">
+      <h3 data-plugin-share-next-title></h3>
+      <p data-plugin-share-next-copy></p>
+      <div class="task-actions" data-plugin-share-next-actions></div>
+    </div>
+    <form class="task-share-inline-create task-hidden" data-plugin-share-create-form>
+      <input type="text" data-plugin-share-repo-name>
+      <select data-plugin-share-visibility><option value="public">Public</option></select>
+      <button type="button" data-plugin-share-create-cancel>Cancel</button>
+    </form>
+    <div class="task-actions plugin-share-static-actions${staticClass}" data-plugin-share-static-actions>
+      <a class="task-link-button${remoteClass}" href="${share.remoteWebUrl || "#"}" data-plugin-share-remote-link>
+        <span>View on GitHub</span>
+      </a>
+      <button class="${refreshClass}" type="button" data-plugin-share-refresh><span>Check again</span></button>
+    </div>
+    <p data-plugin-share-copy></p>
+    <div data-plugin-share-feedback hidden></div>
+  </section>
+  <script id="plugin-detail-bootstrap" type="application/json">${JSON.stringify(bootstrap)}</script>
+</body>`, {
+    runScripts: "dangerously",
+    url: "http://localhost/plugin",
+    virtualConsole: options.virtualConsole,
+  })
+  if (typeof options.beforeScript === "function") {
+    options.beforeScript(dom.window)
+  }
+  const scriptElement = dom.window.document.createElement("script")
+  scriptElement.textContent = script
+  dom.window.document.body.appendChild(scriptElement)
+  return dom.window.document
+}
+test("plugin detail hides static GitHub actions until a remote exists", async () => {
+  const document = await renderSharePanel()
+  const staticActions = document.querySelector("[data-plugin-share-static-actions]")
+  assert.ok(staticActions.classList.contains("task-hidden"))
+  assert.equal(visibleTextMatches(document, "a,button", "Check again").length, 1)
+  assert.equal(document.querySelector("[data-plugin-share-note]").textContent, "Setup needed")
+})
+test("plugin detail shows one static refresh action after a remote exists", async () => {
+  const document = await renderSharePanel({
+    githubConnected: true,
+    gitInitialized: true,
+    hasCommit: true,
+    remoteUrl: "git@github.com:octocat/demo-plugin.git",
+    remoteWebUrl: "https://github.com/octocat/demo-plugin",
+    hasPublished: true,
+  })
+  const staticActions = document.querySelector("[data-plugin-share-static-actions]")
+  assert.ok(!staticActions.classList.contains("task-hidden"))
+  assert.equal(visibleTextMatches(document, "a,button", "Check again").length, 1)
+  assert.equal(visibleTextMatches(document, "a,button", "View on GitHub").length, 1)
+  assert.equal(document.querySelector("[data-plugin-share-note]").textContent, "Connected")
+})
+test("plugin detail keeps refresh available for non-GitHub remotes", async () => {
+  const document = await renderSharePanel({
+    githubConnected: true,
+    gitInitialized: true,
+    hasCommit: true,
+    remoteUrl: "https://gitlab.com/octocat/demo-plugin.git",
+    remoteWebUrl: "",
+    hasPublished: true,
+  })
+  const staticActions = document.querySelector("[data-plugin-share-static-actions]")
+  assert.ok(!staticActions.classList.contains("task-hidden"))
+  assert.equal(visibleTextMatches(document, "a,button", "Check again").length, 1)
+  assert.equal(visibleTextMatches(document, "a,button", "View on GitHub").length, 0)
+})
+test("plugin detail does not duplicate refresh when auth is disconnected but a remote exists", async () => {
+  const document = await renderSharePanel({
+    githubConnected: false,
+    gitInitialized: true,
+    hasCommit: true,
+    remoteUrl: "git@github.com:octocat/demo-plugin.git",
+    remoteWebUrl: "https://github.com/octocat/demo-plugin",
+    hasPublished: true,
+  })
+  assert.equal(visibleTextMatches(document, "a,button", "Check again").length, 1)
+  assert.equal(visibleTextMatches(document, "a,button", "View on GitHub").length, 1)
+  assert.equal(document.querySelector("[data-plugin-share-note]").textContent, "Connected")
+})
+test("plugin action event panel completion closes the modal and refreshes after close", async () => {
+  let closeCount = 0
+  let fireOptions = null
+  let actionIframe = null
+  let reloadCount = 0
+  const unexpectedJsdomErrors = []
+  const virtualConsole = new VirtualConsole()
+  virtualConsole.on("jsdomError", (error) => {
+    if (error && /Not implemented: navigation/.test(error.message || "")) {
+      reloadCount += 1
+      return
+    }
+    unexpectedJsdomErrors.push(error)
+  })
+  const document = await renderSharePanel({}, {
+    actionMarkup: '<button type="button" data-plugin-action="install">Install</button>',
+    virtualConsole,
+    beforeScript(window) {
+      window.Swal = {
+        fire(options) {
+          fireOptions = options
+          const popup = window.document.createElement("div")
+          popup.innerHTML = options.html || ""
+          window.document.body.appendChild(popup)
+          actionIframe = popup.querySelector("iframe")
+          if (typeof options.didOpen === "function") {
+            options.didOpen(popup)
+          }
+          return Promise.resolve({})
+        },
+        close() {
+          closeCount += 1
+          if (fireOptions && typeof fireOptions.didClose === "function") {
+            fireOptions.didClose()
+          }
+        },
+      }
+    },
+  })
+  const window = document.defaultView
+  document.querySelector("[data-plugin-action='install']").click()
+  assert.ok(fireOptions)
+  assert.match(fireOptions.html, /\/action\/install\/plugin\/demo\/pinokio\.js/)
+  assert.match(fireOptions.html, /__pinokio_event_panel=1/)
+  assert.ok(actionIframe && actionIframe.contentWindow)
+  window.dispatchEvent(new window.MessageEvent("message", {
+    origin: window.location.origin,
+    data: {
+      e: "pinokio:event-panel-status",
+      success: true,
+    },
+  }))
+  assert.equal(closeCount, 0)
+  assert.equal(reloadCount, 0)
+  window.dispatchEvent(new window.MessageEvent("message", {
+    origin: window.location.origin,
+    source: actionIframe.contentWindow,
+    data: {
+      e: "pinokio:event-panel-status",
+      success: true,
+    },
+  }))
+  assert.equal(closeCount, 1)
+  assert.equal(reloadCount, 1)
+  assert.deepEqual(unexpectedJsdomErrors, [])
+})
+test("plugin delete confirmation and failure do not request SweetAlert icons", async () => {
+  const fireOptions = []
+  const document = await renderSharePanel({
+    localLabel: "plugin/demo",
+  }, {
+    actionMarkup: '<button type="button" data-plugin-delete>Delete</button>',
+    beforeScript(window) {
+      window.fetch = () => Promise.resolve({
+        ok: false,
+        status: 400,
+        json: () => Promise.resolve({ ok: false, error: "Plugin path is required." }),
+      })
+      window.Swal = {
+        fire(options) {
+          fireOptions.push(options)
+          return Promise.resolve(fireOptions.length === 1 ? { isConfirmed: true } : {})
+        },
+      }
+    },
+  })
+  document.querySelector("[data-plugin-delete]").click()
+  await new Promise((resolve) => setTimeout(resolve, 0))
+  await new Promise((resolve) => setTimeout(resolve, 0))
+  assert.equal(fireOptions.length, 2)
+  assert.equal(fireOptions[0].icon, undefined)
+  assert.equal(fireOptions[0].title, "Delete Demo Plugin?")
+  assert.match(fireOptions[0].html, /plugin\/demo/)
+  assert.equal(fireOptions[0].confirmButtonText, "Delete plugin")
+  assert.equal(fireOptions[1].icon, undefined)
+  assert.equal(fireOptions[1].title, "Delete failed")
+  assert.equal(fireOptions[1].text, "Plugin path is required.")
+  assert.equal(fireOptions[1].confirmButtonText, "Close")
+  assert.equal(fireOptions[1].buttonsStyling, false)
+})
+test("terminal action view uses generic event panel completion", async () => {
+  const terminalView = await fs.readFile(path.join(repoRoot, "server/views/terminal.ejs"), "utf8")
+  const disconnectBranchStart = terminalView.indexOf("packet.type === 'disconnect'")
+  const eventBranchStart = terminalView.indexOf('packet.type === "event"', disconnectBranchStart)
+  const eventBranchEnd = terminalView.indexOf("//this.socket.close()", eventBranchStart)
+  assert.ok(disconnectBranchStart >= 0)
+  assert.ok(eventBranchStart > disconnectBranchStart)
+  assert.ok(eventBranchEnd > eventBranchStart)
+  assert.match(terminalView, /pinokio:event-panel-status/)
+  assert.match(terminalView.slice(disconnectBranchStart, eventBranchStart), /pinokio:event-panel-status/)
+  assert.match(terminalView.slice(eventBranchStart, eventBranchEnd), /eventPanelStopPending = true/)
+  assert.doesNotMatch(terminalView.slice(eventBranchStart, eventBranchEnd), /pinokio:event-panel-status/)
+  assert.doesNotMatch(terminalView, /pluginActionCompletion/)
+  assert.doesNotMatch(terminalView, /pinokio:plugin-action-complete/)
+})

package/test/plugin-detail-view.test.js ADDED Viewed

@@ -0,0 +1,160 @@
+const assert = require("node:assert/strict")
+const path = require("node:path")
+const test = require("node:test")
+const ejs = require("ejs")
+const { JSDOM } = require("jsdom")
+const viewPath = path.resolve(__dirname, "..", "server/views/plugin_detail.ejs")
+function basePlugin(overrides = {}) {
+  return {
+    title: "Demo Plugin",
+    description: "Demo plugin description.",
+    link: "https://example.com/plugin",
+    image: "",
+    icon: "fa-solid fa-terminal",
+    pluginPath: "/plugin/demo/pinokio.js",
+    extraParams: [],
+    defaultCwd: "",
+    hasInstall: true,
+    hasUpdate: true,
+    hasUninstall: true,
+    hasInstalledCheck: true,
+    installed: true,
+    category: "cli",
+    ...overrides,
+  }
+}
+function basePluginUi(overrides = {}) {
+  return {
+    badges: [{ label: "Local plugin", tone: "accent" }],
+    launchSummary: "Launches inside Pinokio",
+    hasChanges: false,
+    changePreview: [],
+    extraChangeCount: 0,
+    localChangesCopy: "",
+    showSidebar: true,
+    sourceLabel: "Local folder",
+    sourceValue: "plugin/demo",
+    statusLabel: "Status",
+    statusValue: "Not version tracked yet",
+    canOpenFolder: false,
+    canManageSource: true,
+    isManagedSource: false,
+    githubPanelTitle: "GitHub",
+    githubPanelCopy: "",
+    remoteLabel: "",
+    ...overrides,
+  }
+}
+function baseShareState(overrides = {}) {
+  return {
+    ownership: "local",
+    manageable: true,
+    canOpenFolder: false,
+    dir: "/tmp/pinokio/plugin/demo",
+    localLabel: "plugin/demo",
+    remoteUrl: "",
+    remoteWebUrl: "",
+    githubConnected: false,
+    gitInitialized: false,
+    hasCommit: false,
+    changeCount: 0,
+    changes: [],
+    branch: "HEAD",
+    commitUrl: "",
+    createUrl: "",
+    pushUrl: "",
+    ...overrides,
+  }
+}
+async function renderPluginDetail({ plugin = {}, pluginUi = {}, shareState = {} } = {}) {
+  const html = await ejs.renderFile(viewPath, {
+    theme: "dark",
+    agent: "browser",
+    list: [],
+    current_host: "",
+    showPeerAccess: false,
+    plugin: basePlugin(plugin),
+    pluginUi: basePluginUi(pluginUi),
+    pluginCwd: "",
+    shareState: baseShareState(shareState),
+    apps: [],
+  })
+  return new JSDOM(html).window.document
+}
+test("plugin detail omits the right column for built-in system plugins", async () => {
+  const document = await renderPluginDetail({
+    plugin: {
+      title: "Antigravity CLI Auto",
+      pluginPath: "/pinokio/run/plugin/antigravity-cli-auto/pinokio.js",
+    },
+    pluginUi: {
+      badges: [{ label: "Built-in plugin", tone: "neutral" }],
+      showSidebar: false,
+    },
+    shareState: {
+      ownership: "system",
+      localLabel: "plugin/antigravity-cli-auto/pinokio.js",
+      manageable: false,
+    },
+  })
+  assert.equal(document.querySelector(".task-detail-sidebar"), null)
+  assert.ok(document.querySelector(".task-detail-layout-single"))
+  assert.equal(document.querySelector("[data-plugin-share-next-title]"), null)
+  assert.doesNotMatch(document.body.textContent, /Plugin status/)
+  assert.match(document.querySelector(".task-header-actions").textContent, /Website/)
+  assert.doesNotMatch(document.querySelector(".task-header-actions").textContent, /Back/)
+  assert.equal(document.querySelector("[data-plugin-delete]"), null)
+  assert.equal(document.querySelector('.plugin-detail-breadcrumb a[href="/plugins"]')?.textContent, "Plugins")
+})
+test("plugin detail keeps source management column for local plugins", async () => {
+  const document = await renderPluginDetail()
+  assert.ok(document.querySelector(".task-detail-sidebar"))
+  assert.equal(document.querySelector(".task-detail-layout-single"), null)
+  assert.ok(document.querySelector("[data-plugin-share-next-title]"))
+  assert.match(document.body.textContent, /Plugin status/)
+  assert.equal(document.querySelector('.plugin-detail-breadcrumb a[href="/plugins"]')?.textContent, "Plugins")
+  assert.equal(
+    document.querySelector('.plugin-detail-breadcrumb a[aria-current="page"]')?.getAttribute("href"),
+    "/plugin?path=%2Fplugin%2Fdemo%2Fpinokio.js"
+  )
+  assert.match(document.querySelector(".task-header-actions").textContent, /Delete/)
+  assert.ok(document.querySelector(".task-header-actions [data-plugin-delete]"))
+  assert.doesNotMatch(document.querySelector(".task-header-actions").textContent, /Back/)
+  assert.equal(document.querySelectorAll(".plugin-detail-status-row").length, 3)
+  assert.equal(document.querySelectorAll(".task-detail-sidebar .task-meta-chip").length, 0)
+  assert.equal(
+    Array.from(document.querySelectorAll(".task-detail-sidebar h2")).some((heading) => heading.textContent.trim() === "GitHub"),
+    false
+  )
+})
+test("plugin detail does not show delete for managed non-local plugin source", async () => {
+  const document = await renderPluginDetail({
+    pluginUi: {
+      badges: [{ label: "Managed by Pinokio", tone: "neutral" }],
+      canManageSource: false,
+      isManagedSource: true,
+      sourceLabel: "Managed folder",
+      sourceValue: "plugin/code/demo",
+      githubPanelTitle: "Managed by Pinokio",
+      githubPanelCopy: "Managed plugin source.",
+    },
+    shareState: {
+      ownership: "managed",
+      manageable: false,
+      dir: "/tmp/pinokio/plugin/code/demo",
+      localLabel: "plugin/code/demo",
+    },
+  })
+  assert.equal(document.querySelector("[data-plugin-delete]"), null)
+})

package/test/plugin-sources.test.js CHANGED Viewed

@@ -32,6 +32,25 @@ test("resolveLauncherPluginSelection returns app-dev plugin query paths", () =>
   )
 })
+test("systemPluginPathForLocalPath maps local-shaped plugin paths to system candidates", () => {
+  assert.strictEqual(
+    PluginSources.systemPluginPathForLocalPath("/plugin/antigravity-cli-auto/pinokio.js"),
+    "/pinokio/run/plugin/antigravity-cli-auto/pinokio.js"
+  )
+  assert.strictEqual(
+    PluginSources.systemPluginPathForLocalPath("plugin/antigravity-cli-auto"),
+    "/pinokio/run/plugin/antigravity-cli-auto/pinokio.js"
+  )
+  assert.strictEqual(
+    PluginSources.systemPluginPathForLocalPath("/pinokio/run/plugin/antigravity-cli-auto/pinokio.js"),
+    ""
+  )
+  assert.strictEqual(
+    PluginSources.systemPluginPathForLocalPath("/api/example/plugins/helper/pinokio.js"),
+    ""
+  )
+})
 test("normalizeActionPathComponents maps action URLs back to filesystem roots", () => {
   assert.deepStrictEqual(
     PluginSources.normalizeActionPathComponents(["pinokio", "run", "plugin", "antigravity-cli", "pinokio.js"]),

package/test/terminal-log-paths.test.js ADDED Viewed

@@ -0,0 +1,238 @@
+const assert = require('node:assert/strict')
+const fs = require('node:fs/promises')
+const os = require('node:os')
+const path = require('node:path')
+const test = require('node:test')
+const Socket = require('../server/socket')
+const Util = require('../kernel/util')
+function createSocket(home) {
+  const kernel = {
+    homedir: home,
+    path: (...parts) => path.resolve(home, ...parts),
+    exists: async (targetPath) => {
+      try {
+        await fs.access(targetPath)
+        return true
+      } catch (_) {
+        return false
+      }
+    }
+  }
+  return Object.assign(Object.create(Socket.prototype), {
+    parent: { kernel },
+    rawLog: {},
+    logMeta: {},
+    sessions: {}
+  })
+}
+test('plugin source without cwd writes to home-relative logs', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-terminal-log-'))
+  try {
+    const socket = createSocket(root)
+    const key = path.join(root, 'plugin', 'oc', 'pinokio.js')
+    assert.equal(
+      await socket.resolveLogDir(key),
+      path.join(root, 'logs', 'plugin', 'oc', 'pinokio.js')
+    )
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+test('plugin source with cwd=undefined does not create repo-relative undefined logs', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-terminal-log-'))
+  try {
+    const socket = createSocket(root)
+    const key = `${path.join(root, 'plugin', 'oc', 'pinokio.js')}?cwd=undefined`
+    assert.equal(
+      await socket.resolveLogDir(key),
+      path.join(root, 'logs', 'plugin', 'oc', 'pinokio.js')
+    )
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+test('plugin source with app cwd writes app-local dev logs', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-terminal-log-'))
+  try {
+    const socket = createSocket(root)
+    const appRoot = path.join(root, 'api', 'example')
+    const key = `${path.join(root, 'plugin', 'oc', 'pinokio.js')}?cwd=${encodeURIComponent(appRoot)}`
+    assert.equal(
+      await socket.resolveLogDir(key),
+      path.join(appRoot, 'logs', 'dev', 'plugin', 'oc', 'pinokio.js')
+    )
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+test('future top-level source with app cwd writes app-local dev logs', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-terminal-log-'))
+  try {
+    const socket = createSocket(root)
+    const appRoot = path.join(root, 'api', 'example')
+    const key = `${path.join(root, 'tasks', 'build', 'run.js')}?cwd=${encodeURIComponent(appRoot)}`
+    assert.equal(
+      await socket.resolveLogDir(key),
+      path.join(appRoot, 'logs', 'dev', 'tasks', 'build', 'run.js')
+    )
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+test('global source with non-app cwd writes home-relative logs', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-terminal-log-'))
+  try {
+    const socket = createSocket(root)
+    const workspace = path.join(root, 'workspaces', 'tmp')
+    const key = `${path.join(root, 'plugin', 'oc', 'pinokio.js')}?cwd=${encodeURIComponent(workspace)}`
+    assert.equal(
+      await socket.resolveLogDir(key),
+      path.join(root, 'logs', 'plugin', 'oc', 'pinokio.js')
+    )
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+test('app script source writes app-local api logs', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-terminal-log-'))
+  try {
+    const socket = createSocket(root)
+    const key = path.join(root, 'api', 'example', 'start.js')
+    assert.equal(
+      await socket.resolveLogDir(key),
+      path.join(root, 'api', 'example', 'logs', 'api', 'start.js')
+    )
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+test('app script source uses nested pinokio app root when present', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-terminal-log-'))
+  try {
+    const socket = createSocket(root)
+    await fs.mkdir(path.join(root, 'api', 'example', 'pinokio'), { recursive: true })
+    const key = path.join(root, 'api', 'example', 'start.js')
+    assert.equal(
+      await socket.resolveLogDir(key),
+      path.join(root, 'api', 'example', 'pinokio', 'logs', 'api', 'start.js')
+    )
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+test('future top-level source writes home-relative logs without a special case', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-terminal-log-'))
+  try {
+    const socket = createSocket(root)
+    const key = path.join(root, 'tasks', 'build', 'run.js')
+    assert.equal(
+      await socket.resolveLogDir(key),
+      path.join(root, 'logs', 'tasks', 'build', 'run.js')
+    )
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+test('api-like top-level source is not treated as an app script', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-terminal-log-'))
+  try {
+    const socket = createSocket(root)
+    const key = path.join(root, 'apiary', 'run.js')
+    assert.equal(
+      await socket.resolveLogDir(key),
+      path.join(root, 'logs', 'apiary', 'run.js')
+    )
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+test('event and output logging use the same terminal log resolver', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-terminal-log-'))
+  try {
+    const socket = createSocket(root)
+    const key = path.join(root, 'plugin', 'oc', 'pinokio.js')
+    await socket.appendEventLog(key, { source: 'api', method: 'notify' }, 'event')
+    socket.sessions[key] = 'session-1'
+    await socket.log_buffer(key, 'hello\n', { source: 'api', method: 'shell.run' })
+    const dir = await socket.resolveLogDir(key)
+    assert.match(await fs.readFile(path.join(dir, 'events'), 'utf8'), /event/)
+    assert.match(await fs.readFile(path.join(dir, 'latest'), 'utf8'), /hello/)
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+test('plugin output with invalid cwd writes latest under home-relative logs', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-terminal-log-'))
+  try {
+    const socket = createSocket(root)
+    const key = `${path.join(root, 'plugin', 'oc', 'pinokio.js')}?cwd=undefined`
+    socket.sessions[key] = 'session-1'
+    await socket.log_buffer(key, 'hello\n', { source: 'api', method: 'shell.run' })
+    const latest = await fs.readFile(path.join(root, 'logs', 'plugin', 'oc', 'pinokio.js', 'latest'), 'utf8')
+    assert.match(latest, /\[api shell\.run\]/)
+    assert.match(latest, /hello/)
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+test('absolute sources outside PINOKIO_HOME do not get guessed log paths', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-terminal-log-'))
+  const outside = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-terminal-external-'))
+  try {
+    const socket = createSocket(root)
+    assert.equal(
+      await socket.resolveLogDir(path.join(outside, 'run.js')),
+      null
+    )
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+    await fs.rm(outside, { recursive: true, force: true })
+  }
+})
+test('legacy shell workspace logs remain workspace-owned', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-terminal-log-'))
+  const workspace = process.platform === 'win32'
+    ? await fs.mkdtemp(path.join(os.tmpdir(), 'pinokioterminalworkspace-'))
+    : await fs.mkdtemp('/tmp/pinokioterminalworkspace-')
+  try {
+    const socket = createSocket(root)
+    const key = `shell/${Util.p2u(workspace)}_0`
+    assert.equal(
+      await socket.resolveLogDir(key),
+      path.join(workspace, 'logs', 'shell')
+    )
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+    await fs.rm(workspace, { recursive: true, force: true })
+  }
+})