pinokiod 8.2.17 → 8.2.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "8.2.17",
+  "version": "8.2.19",
   "description": "",
   "main": "index.js",
   "scripts": {

package/server/index.js

@@ -1037,7 +1037,7 @@ class Server {
     const entries = await this.kernel.api.listApps()
     return { apps: entries.map((entry) => ({ id: entry.id, name: entry.title || entry.name || entry.id, icon: entry.icon })) }
   }
-  // launch is a side effect: only pinokio.co and this computer may call it
+  // launch and stop are side effects: only pinokio.co and this computer may call them
   anywhereOriginAllowed(origin) {
     if (!origin) return true
     let parsed
@@ -1067,10 +1067,15 @@ class Server {
     }
     return items
   }
+  // the folder of an installed app, or "" for anything that is not exactly one folder name under api/
+  async anywhereAppDir(id) {
+    const dir = typeof id === "string" ? this.kernel.path("api", id) : ""
+    if (!dir || path.dirname(dir) !== this.kernel.path("api") || path.basename(dir) !== id) return ""
+    return (await this.kernel.api.exists(dir)) ? dir : ""
+  }
   async composeAnywhereLaunch({ id, href } = {}) {
     const api = this.kernel.api
-    const dir = typeof id === "string" ? this.kernel.path("api", id) : ""
-    if (!dir || path.dirname(dir) !== this.kernel.path("api") || path.basename(dir) !== id || !(await api.exists(dir))) {
+    if (!(await this.anywhereAppDir(id))) {
       return { status: 400, body: { error: `Unknown app: ${id}` } }
     }
     const menu = await this.anywhereMenu(api, await api.launcher_path(id))
@@ -1104,6 +1109,21 @@ class Server {
     }
     return { status: 200, body: { action: "started" } }
   }
+  // stops every run under the app's folder the way the desktop stops one (kernel.api.stop by its running key)
+  async composeAnywhereStop({ id } = {}) {
+    const api = this.kernel.api
+    const dir = await this.anywhereAppDir(id)
+    if (!dir) {
+      return { status: 400, body: { error: `Unknown app: ${id}` } }
+    }
+    for (const [key, value] of Object.entries(api.running || {})) {
+      const rel = path.relative(dir, key.split("?")[0])
+      if (value && rel && !rel.startsWith("..") && !path.isAbsolute(rel)) {
+        await api.stop({ params: { id: key } })
+      }
+    }
+    return { status: 200, body: { action: "stopped" } }
+  }
   async composeAnywhereStatus({ light } = {}) {
     const anywhere = this.kernel ? this.kernel.anywhere : null
     if (!anywhere) {
@@ -1140,7 +1160,8 @@ class Server {
           id: app.id,
           name: app.name,
           icon: app.icon,
-          state: entry ? app.state : (app.state === "ready" ? "publishing" : app.state),
+          // Anywhere's own states: ready once a Serve route carries the app, publishing while it is up locally without one
+          state: entry ? "ready" : (app.ready_url || app.url ? "publishing" : "starting"),
           remote: entry ? rewriteAnywhereHref(app.ready_url || app.url, snap.serve) : null,
           exposed: !!entry,
         })
@@ -14348,19 +14369,22 @@ class Server {
       res.set("Cache-Control", "no-store")
       res.json(await this.composeAnywhereApps())
     }))
-    this.app.post("/anywhere/launch", ex(async (req, res) => {
+    // app actions change what runs on this computer: pinokio.co and this computer only
+    const anywhereAppAction = (fn) => ex(async (req, res) => {
       res.set("Cache-Control", "no-store")
       if (!this.anywhereOriginAllowed(req.get("Origin"))) {
-        res.status(403).json({ error: "Launching is allowed only from pinokio.co or this computer" })
+        res.status(403).json({ error: "Allowed only from pinokio.co or this computer" })
         return
       }
       try {
-        const { status, body } = await this.composeAnywhereLaunch(req.body || {})
+        const { status, body } = await fn(req.body || {})
         res.status(status).json(body)
       } catch (error) {
         res.status(500).json({ error: error && error.message ? error.message : String(error) })
       }
-    }))
+    })
+    this.app.post("/anywhere/apps/launch", anywhereAppAction((body) => this.composeAnywhereLaunch(body)))
+    this.app.post("/anywhere/apps/stop", anywhereAppAction((body) => this.composeAnywhereStop(body)))
     const anywhereAction = (label, fn) => ex(async (req, res) => {
       const anywhere = this.kernel.anywhere
       if (!anywhere) {

package/test/anywhere-api.test.js

@@ -22,9 +22,11 @@ test('status carries app ids and complete remote addresses, and no installed cou
   let readyUrl
   const fake = {
     kernel: { anywhere, api: { listApps: async () => [{ id: 'comfy' }, { id: 'forge' }, { id: 'idle' }] } },
+    // Home Server states (pending: up locally, no external address) never leak into Anywhere's
     collectHomeServerApps: async () => [
-      { id: 'comfy', name: 'ComfyUI', icon: '/c.png', ready_url: readyUrl, state: 'ready' },
+      { id: 'comfy', name: 'ComfyUI', icon: '/c.png', ready_url: readyUrl, state: 'pending' },
       { id: 'forge', name: 'Forge', icon: '/f.png', ready_url: '', state: 'starting' },
+      { id: 'unrouted', name: 'Unrouted', icon: '/u.png', ready_url: 'http://127.0.0.1:9999', state: 'pending' },
     ],
     portFromUrl: Server.prototype.portFromUrl,
   }
@@ -35,7 +37,7 @@ test('status carries app ids and complete remote addresses, and no installed cou
     readyUrl = url
     const status = await Server.prototype.composeAnywhereStatus.call(fake, {})
     assert.equal(status.installed, undefined)
-    assert.deepEqual(status.apps.map((a) => [a.id, a.remote]), [['comfy', expected], ['forge', null]])
+    assert.deepEqual(status.apps.map((a) => [a.id, a.state, a.remote]), [['comfy', 'ready', expected], ['forge', 'starting', null], ['unrouted', 'publishing', null]])
   }
   const light = await Server.prototype.composeAnywhereStatus.call(fake, { light: true })
   assert.equal(light.apps, undefined, 'the light status is unchanged')
@@ -108,7 +110,7 @@ test('the catalog maps installed apps to id, name and icon', async () => {
 // a launch harness: one app "comfy" at /managed/api/comfy whose menu is set per case;
 // kernel.status mirrors the kernel's session-aware running check
 const launchHarness = ({ menu = [], running = {}, anywhere = readyAnywhere() } = {}) => {
-  const calls = { process: [], cleared: [], reserved: [], counted: [] }
+  const calls = { process: [], cleared: [], reserved: [], counted: [], stopped: [] }
   const api = {
     exists: async (p) => p === '/managed/api/comfy',
     launcher_path: async (name) => `/managed/api/${name}`,
@@ -116,6 +118,7 @@ const launchHarness = ({ menu = [], running = {}, anywhere = readyAnywhere() } =
     running,
     logSessions: { reserveLaunch: async (uri) => { calls.reserved.push(uri) } },
     process: (req) => { calls.process.push(req); return Promise.resolve() },
+    stop: async (req) => { calls.stopped.push(req.params.id) },
   }
   const server = Object.assign(Object.create(Server.prototype), {
     kernel: {
@@ -126,7 +129,7 @@ const launchHarness = ({ menu = [], running = {}, anywhere = readyAnywhere() } =
     },
     appPreferences: { recordLaunchByPath: async (p, options) => { calls.counted.push([p, options.source]) } },
   })
-  return { server, calls, launch: (body) => server.composeAnywhereLaunch(body) }
+  return { server, calls, launch: (body) => server.composeAnywhereLaunch(body), stop: (body) => server.composeAnywhereStop(body) }
 }
 
 test('launch opens a loopback URL default at its Anywhere address, null until Serve carries it, other URLs as they are', async () => {
@@ -205,7 +208,32 @@ test('a drive-relative app id is refused on Windows', { skip: process.platform !
   }
 })
 
-test('launch is allowed from pinokio.co and this computer only', () => {
+test('stop ends every run under the app folder by its running key, and nothing else', async () => {
+  const running = {
+    '/managed/api/comfy/start.js': true,
+    '/managed/api/comfy/start.js&session=abc': true,
+    '/managed/api/comfy/sub/worker.js?cwd=/managed/api/comfy': true,
+    '/managed/api/comfy/old.js': false,
+    '/managed/api/comfyui/start.js': true,
+    '/managed/api/other/start.js': true,
+  }
+  const h = launchHarness({ running })
+  assert.deepEqual(await h.stop({ id: 'comfy' }), { status: 200, body: { action: 'stopped' } })
+  assert.deepEqual(h.calls.stopped, [
+    '/managed/api/comfy/start.js',
+    '/managed/api/comfy/start.js&session=abc',
+    '/managed/api/comfy/sub/worker.js?cwd=/managed/api/comfy',
+  ])
+  const idle = launchHarness()
+  assert.deepEqual(await idle.stop({ id: 'comfy' }), { status: 200, body: { action: 'stopped' } })
+  assert.deepEqual(idle.calls.stopped, [])
+  for (const id of ['nope', '../comfy', 'comfy/start.js', '', undefined]) {
+    assert.equal((await h.stop({ id })).status, 400, String(id))
+  }
+  assert.equal(h.calls.stopped.length, 3)
+})
+
+test('launch and stop are allowed from pinokio.co and this computer only', () => {
   const server = Object.assign(Object.create(Server.prototype), { kernel: { anywhere: readyAnywhere() } })
   for (const origin of [undefined, 'https://pinokio.co', 'http://localhost:42000', 'http://127.0.0.1:42000', 'https://pinokio.tail1.ts.net']) {
     assert.equal(server.anywhereOriginAllowed(origin), true, String(origin))