npm - pinokiod - Versions diffs - 8.0.39 → 8.0.41 - Mend

pinokiod 8.0.39 → 8.0.41

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 (37) hide show

package/kernel/api/hf/index.js +2 -2
package/kernel/api/index.js +12 -3
package/kernel/connect/index.js +2 -2
package/kernel/connect/providers/huggingface/index.js +14 -5
package/kernel/index.js +14 -2
package/kernel/shell.js +3 -2
package/kernel/shells.js +6 -0
package/kernel/vault/constants.js +13 -0
package/kernel/vault/hash_worker.js +9 -2
package/kernel/vault/index.js +1856 -316
package/kernel/vault/registry.js +526 -52
package/kernel/vault/snapshot.js +29 -0
package/kernel/vault/sweeper.js +480 -210
package/kernel/vault/walker.js +142 -0
package/package.json +1 -1
package/server/index.js +79 -90
package/server/lib/privacy_filter_cache.js +4 -1
package/server/public/storage-size.js +12 -0
package/server/public/style.css +13 -0
package/server/public/tab-link-popover.js +3 -0
package/server/public/vault-nav.js +96 -0
package/server/public/vault.css +1079 -0
package/server/public/vault.js +1835 -0
package/server/views/app.ejs +93 -16
package/server/views/connect/huggingface.ejs +7 -9
package/server/views/partials/main_sidebar.ejs +6 -1
package/server/views/partials/vault_workspace.ejs +55 -0
package/server/views/vault.ejs +5 -1532
package/server/views/vault_app.ejs +22 -0
package/test/hf-api.test.js +4 -2
package/test/huggingface-connect.test.js +7 -11
package/test/huggingface-token-validity.test.js +135 -0
package/test/plugin-action-functions.test.js +19 -0
package/test/privacy-filter-cache.test.js +1 -0
package/test/vault-engine.test.js +1276 -26
package/test/vault-sweep.test.js +1043 -35
package/test/vault-ui.test.js +2184 -65

package/server/views/vault_app.ejs ADDED Viewed

@@ -0,0 +1,22 @@
+<html>
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1" />
+<link href="/css/fontawesome.min.css" rel="stylesheet">
+<link href="/css/solid.min.css" rel="stylesheet">
+<link href="/css/regular.min.css" rel="stylesheet">
+<link href="/style.css" rel="stylesheet"/>
+<link href="/task-launcher.css" rel="stylesheet"/>
+<% if (agent === "electron") { %>
+  <link href="/electron.css" rel="stylesheet"/>
+<% } %>
+<link href="/vault.css" rel="stylesheet"/>
+</head>
+<body class='<%=theme%> task-launcher-page task-page vault-page vault-embed-page' data-agent="<%=agent%>" data-vault-mode="app" data-vault-scope="<%=scope_id%>">
+  <main class='vault-embed-main'>
+    <%- include('partials/vault_workspace', { appMode: true }) %>
+  </main>
+  <script src="/storage-size.js"></script>
+  <script src="/vault.js"></script>
+</body>
+</html>

package/test/hf-api.test.js CHANGED Viewed

@@ -41,7 +41,8 @@ test('hf.login shows a modal, waits for the user to open Hugging Face, then clos
           login,
           token_path: '/tmp/pinokio/hf-token'
         }
-      }
+      },
+      connected: async () => true
     },
     api: {
       async wait(key) {
@@ -161,7 +162,8 @@ test('hf.login returns success without opening anything when already logged in',
           access_token: 'hf_secret',
           token_path: '/tmp/pinokio/hf-token'
         }
-      }
+      },
+      connected: async () => true
     }
   }

package/test/huggingface-connect.test.js CHANGED Viewed

@@ -240,7 +240,7 @@ test('Hugging Face connect leaves existing token and refresh files unchanged', a
   }
 })
-test('Hugging Face connect removes a non-empty token directory', async () => {
+test('Hugging Face connect preserves a non-empty token directory', async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-hf-connect-invalid-dir-'))
   const authDir = path.join(root, 'cache', 'HF_AUTH')
   const tokenPath = path.join(authDir, 'token')
@@ -248,16 +248,12 @@ test('Hugging Face connect removes a non-empty token directory', async () => {
   await fs.writeFile(path.join(tokenPath, 'leftover.txt'), 'leftover')
   await fs.writeFile(path.join(authDir, 'stored_tokens'), 'refresh state')
   try {
-    const provider = new HuggingfaceConnect(createKernel(root), {})
-    await Promise.all([provider.authEnv(), provider.authEnv()])
-    provider.hfPath = () => process.execPath
-    const { env } = await provider.runHf([
-      '-e',
-      'require("node:fs").writeFileSync(process.env.HF_TOKEN_PATH, "hf_replacement_token")'
-    ])
-    assert.equal(env.HF_TOKEN_PATH, tokenPath)
-    assert.equal(await fs.readFile(tokenPath, 'utf8'), 'hf_replacement_token')
+    const kernel = createKernel(root)
+    kernel.envs = { HF_TOKEN_PATH: tokenPath }
+    const provider = new HuggingfaceConnect(kernel, {})
+    assert.equal(await provider.connected(), false)
+    assert.equal(kernel.envs.HF_TOKEN_PATH, path.join(authDir, 'anonymous'))
+    assert.equal(await fs.readFile(path.join(tokenPath, 'leftover.txt'), 'utf8'), 'leftover')
     assert.equal(await fs.readFile(path.join(authDir, 'stored_tokens'), 'utf8'), 'refresh state')
   } finally {
     await fs.rm(root, { recursive: true, force: true })

package/test/huggingface-token-validity.test.js ADDED Viewed

@@ -0,0 +1,135 @@
+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 HF = require('../kernel/api/hf')
+const HuggingfaceConnect = require('../kernel/connect/providers/huggingface')
+const Shell = require('../kernel/shell')
+const Shells = require('../kernel/shells')
+function createKernel(root) {
+  return {
+    homedir: root,
+    platform: process.platform,
+    path: (...parts) => path.join(root, ...parts),
+    exists: async (target) => fs.access(target).then(() => true, () => false)
+  }
+}
+test('hf.login does not accept an invalid saved token', async () => {
+  const context = {
+    parentPath: '/pinokio/api/test/login.js',
+    cwd: '/pinokio/api/test',
+    env: { HF_TOKEN_PATH: './token' }
+  }
+  const kernel = {
+    connect: {
+      keys: async () => ({ access_token: 'invalid' }),
+      async connected(provider, options, receivedContext) {
+        assert.equal(provider, 'huggingface')
+        assert.deepEqual(options, { timeout: 5000 })
+        assert.deepEqual(receivedContext, context)
+        return false
+      },
+      login: async () => ({ status: 'error', error: 'login started' })
+    }
+  }
+  const result = await new HF().login({
+    parent: { path: context.parentPath },
+    cwd: context.cwd,
+    params: { env: context.env }
+  }, () => {}, kernel)
+  assert.deepEqual(result, { status: 'error', error: 'login started' })
+})
+test('whoami updates only the managed shared token path', async () => {
+  const root = path.join(os.tmpdir(), 'pinokio-hf-state')
+  const tokenPath = path.join(root, 'cache', 'HF_AUTH', 'token')
+  const anonymousPath = path.join(root, 'cache', 'HF_AUTH', 'anonymous')
+  const kernel = createKernel(root)
+  kernel.envs = { HF_TOKEN_PATH: anonymousPath }
+  const provider = new HuggingfaceConnect(kernel, {})
+  const customContext = { env: { HF_TOKEN_PATH: '/tmp/custom-hf-token' } }
+  provider.runHf = async (_args, _options, receivedContext) => {
+    assert.equal(receivedContext, customContext)
+    return { env: { HF_TOKEN_PATH: customContext.env.HF_TOKEN_PATH } }
+  }
+  assert.equal(await provider.connected({}, customContext), true)
+  assert.equal(kernel.envs.HF_TOKEN_PATH, anonymousPath)
+  provider.runHf = async () => ({ env: { HF_TOKEN_PATH: tokenPath } })
+  assert.equal(await provider.connected(), true)
+  assert.equal(kernel.envs.HF_TOKEN_PATH, tokenPath)
+  provider.runHf = async () => {
+    const error = new Error('invalid token')
+    error.tokenPath = tokenPath
+    throw error
+  }
+  assert.equal(await provider.connected(), false)
+  assert.equal(kernel.envs.HF_TOKEN_PATH, anonymousPath)
+})
+test('provider login ignores only Pinokio\'s inherited anonymous path', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-hf-context-'))
+  const appDir = path.join(root, 'api', 'demo')
+  const scriptPath = path.join(appDir, 'start.js')
+  await fs.mkdir(appDir, { recursive: true })
+  await fs.writeFile(path.join(root, 'ENVIRONMENT'), '')
+  await fs.writeFile(path.join(appDir, 'ENVIRONMENT'), '')
+  await fs.writeFile(scriptPath, '')
+  try {
+    const kernel = createKernel(root)
+    kernel.envs = { HF_TOKEN_PATH: path.join(root, 'cache', 'HF_AUTH', 'anonymous') }
+    const provider = new HuggingfaceConnect(kernel, {})
+    const context = { parentPath: scriptPath, cwd: appDir }
+    assert.equal((await provider.authEnv(context)).HF_TOKEN_PATH, provider.defaultTokenPath())
+    assert.equal(
+      (await provider.authEnv({ ...context, env: { HF_TOKEN_PATH: './custom-token' } })).HF_TOKEN_PATH,
+      path.join(appDir, 'custom-token')
+    )
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+test('invalid managed tokens are replaced once without overriding apps', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-hf-shells-'))
+  await fs.writeFile(path.join(root, 'ENVIRONMENT'), '')
+  let checks = 0
+  const kernel = createKernel(root)
+  kernel.bin = { envs: () => ({}) }
+  kernel.bracketedPasteSupport = {}
+  kernel.which = () => null
+  kernel.connect = {
+    connected: async () => {
+      checks++
+      return false
+    }
+  }
+  const shells = new Shells(kernel)
+  shells.ensureBracketedPasteSupport = async () => {}
+  try {
+    await shells.init()
+    const anonymousPath = path.join(root, 'cache', 'HF_AUTH', 'anonymous')
+    assert.equal(kernel.envs.HF_TOKEN_PATH, anonymousPath)
+    await shells.init()
+    assert.equal(checks, 1)
+    const inheritedShell = new Shell(kernel)
+    await inheritedShell.init_env({ env: {} })
+    assert.equal(inheritedShell.env.HF_TOKEN_PATH, anonymousPath)
+    const appShell = new Shell(kernel)
+    await appShell.init_env({ env: { HF_TOKEN_PATH: '/tmp/app-hf-token' } })
+    assert.equal(appShell.env.HF_TOKEN_PATH, '/tmp/app-hf-token')
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})

package/test/plugin-action-functions.test.js CHANGED Viewed

@@ -77,6 +77,19 @@ test("resolveActionSteps preserves array actions without changing launcher synta
   })
 })
+test("running request ids retain their authoritative script paths", () => {
+  const api = new Api(createKernel())
+  const request = { id: "custom-run-id", path: "/pinokio/api/demo/start.js" }
+  api.setRunning(request, () => {})
+  assert.equal(api.running[request.id], true)
+  assert.equal(api.running_paths[request.id], request.path)
+  api.clearRunning(request)
+  assert.equal(api.running[request.id], undefined)
+  assert.equal(api.running_paths[request.id], undefined)
+})
 test("resolveActionSteps executes function actions once per request and clears cached steps", async () => {
   const api = new Api(createKernel())
   const request = { id: "function-request", path: "/pinokio/api/demo/plugin/pinokio.js" }
@@ -311,6 +324,7 @@ test("step clears resolved function actions when an RPC returns an error", async
     }
     const steps = [{ method: "test.fail" }]
     api.running[request.id] = true
+    api.running_paths[request.id] = request.path
     api.resolved_actions[request.id] = { actionKey: "run", steps }
     api.resolveScript = async () => ({
       cwd: appDir,
@@ -328,6 +342,8 @@ test("step clears resolved function actions when an RPC returns an error", async
     await api.step(request, steps[0], {}, 0, 1, {})
     assert.equal(api.resolved_actions[request.id], undefined)
+    assert.equal(api.running[request.id], true)
+    assert.equal(api.running_paths[request.id], request.path)
   })
 })
@@ -339,6 +355,7 @@ test("step clears resolved function actions when an RPC throws", async () => {
     }
     const steps = [{ method: "test.throw" }]
     api.running[request.id] = true
+    api.running_paths[request.id] = request.path
     api.resolved_actions[request.id] = { actionKey: "run", steps }
     api.resolveScript = async () => ({
       cwd: appDir,
@@ -361,5 +378,7 @@ test("step clears resolved function actions when an RPC throws", async () => {
     }
     assert.equal(api.resolved_actions[request.id], undefined)
+    assert.equal(api.running[request.id], true)
+    assert.equal(api.running_paths[request.id], request.path)
   })
 })

package/test/privacy-filter-cache.test.js CHANGED Viewed

@@ -110,6 +110,7 @@ test('privacy filter cache install endpoint accepts only same-origin browser wri
   const { mod, restore } = loadCacheWithAxiosMock({ get: async () => ({ data: Readable.from(['']) }) })
   try {
     assert.equal(mod.isInstallRequestAllowed(fakeRequest({})), true)
+    assert.strictEqual(mod.isSameOriginRequest, mod.isInstallRequestAllowed)
     assert.equal(mod.isInstallRequestAllowed(fakeRequest({
       Host: 'localhost:42000',
       Origin: 'http://localhost:42000',