pinokiod 7.3.0 → 7.3.3

package/test/shell-run-template.test.js

@@ -0,0 +1,209 @@
+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 ShellRunTemplate = require('../kernel/api/shell_run_template')
+const Shell = require('../kernel/shell')
+
+function createKernel(root = process.cwd()) {
+  return {
+    homedir: root,
+    bracketedPasteSupport: {},
+    connect: {
+      keys: async () => null
+    },
+    envs: process.env,
+    exists: async (filepath) => {
+      try {
+        await fs.access(filepath)
+        return true
+      } catch (_) {
+        return false
+      }
+    },
+    path: (type, ...parts) => path.join(root, type, ...parts)
+  }
+}
+
+function createShell(kernel = createKernel()) {
+  return new Shell(kernel)
+}
+
+test('renderEnvArgs protects multiline structured shell.run argv values', () => {
+  const rpc = {
+    method: 'shell.run',
+    params: {
+      shell: 'bash',
+      message: {
+        _: ['python', '-c', 'print("a")\nprint("b")']
+      },
+      env: {
+        EXISTING: '1'
+      }
+    }
+  }
+
+  const rendered = ShellRunTemplate.renderEnvArgs({ platform: 'darwin' }, rpc, {})
+
+  assert.notStrictEqual(rendered, rpc)
+  assert.deepEqual(rendered.params.message, {
+    _: ['python', '-c', '__PINOKIO_ENVARG_0__']
+  })
+  assert.equal(rendered.params.env.EXISTING, '1')
+  assert.equal(rendered.params.env.PINOKIO_ARG_0, 'print("a")\nprint("b")')
+  assert.deepEqual(rendered.params._pinokio_env_args, [
+    {
+      name: 'PINOKIO_ARG_0',
+      value: 'print("a")\nprint("b")'
+    }
+  ])
+  assert.equal(rendered.params._pinokio_cmd_delayed_expansion, false)
+})
+
+test('renderEnvArgs is a no-op for non-multiline or raw string shell.run messages', () => {
+  const structured = {
+    method: 'shell.run',
+    params: {
+      message: {
+        _: ['echo', 'hello']
+      }
+    }
+  }
+  const rawString = {
+    method: 'shell.run',
+    params: {
+      message: 'echo one\necho two'
+    }
+  }
+  const differentMethod = {
+    method: 'fs.write',
+    params: {
+      message: {
+        _: ['echo', 'one\ntwo']
+      }
+    }
+  }
+
+  assert.strictEqual(ShellRunTemplate.renderEnvArgs({ platform: 'darwin' }, structured, {}), structured)
+  assert.strictEqual(ShellRunTemplate.renderEnvArgs({ platform: 'darwin' }, rawString, {}), rawString)
+  assert.strictEqual(ShellRunTemplate.renderEnvArgs({ platform: 'darwin' }, differentMethod, {}), differentMethod)
+})
+
+test('renderEnvArgs marks cmd shell runs for delayed expansion', () => {
+  const rpc = {
+    method: 'shell.run',
+    params: {
+      shell: 'cmd.exe',
+      message: {
+        _: ['node', '-e', 'console.log("a")\nconsole.log("b")']
+      }
+    }
+  }
+
+  const rendered = ShellRunTemplate.renderEnvArgs({ platform: 'win32' }, rpc, {})
+
+  assert.equal(rendered.params._pinokio_cmd_delayed_expansion, true)
+  assert.equal(rendered.params.env.PINOKIO_ARG_0, 'console.log("a")\nconsole.log("b")')
+})
+
+test('Shell.buildStructuredMessage expands env arg markers with shell-specific quoting', () => {
+  const shell = createShell()
+  const message = {
+    _: ['python', '-c', '__PINOKIO_ENVARG_0__']
+  }
+
+  assert.equal(
+    shell.buildStructuredMessage(message, 'bash'),
+    '\'python\' \'-c\' "$PINOKIO_ARG_0"'
+  )
+  assert.equal(
+    shell.buildStructuredMessage(message, 'powershell'),
+    '& \'python\' \'-c\' "${env:PINOKIO_ARG_0}"'
+  )
+  assert.equal(
+    shell.buildStructuredMessage(message, 'cmd.exe'),
+    '"python" "-c" "!PINOKIO_ARG_0!"'
+  )
+})
+
+test('Shell.init_env preserves multiline Pinokio argv env values only', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-shell-envarg-'))
+  await fs.mkdir(path.join(root, 'api'), { recursive: true })
+  await fs.writeFile(path.join(root, 'ENVIRONMENT'), 'PINOKIO_TEST_ENV=1\n')
+  const shell = createShell(createKernel(root))
+
+  await shell.init_env({
+    path: process.cwd(),
+    env: {
+      PINOKIO_ARG_0: 'line one\nline two',
+      OTHER_MULTILINE: 'line one\nline two'
+    }
+  })
+
+  assert.equal(shell.env.PINOKIO_ARG_0, 'line one\nline two')
+  assert.equal(shell.env.OTHER_MULTILINE, 'line one line two')
+})
+
+test('Shell.init_env disables Hugging Face hub update checks by default without overriding apps', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-shell-hf-env-'))
+  await fs.mkdir(path.join(root, 'api'), { recursive: true })
+  await fs.writeFile(path.join(root, 'ENVIRONMENT'), 'PINOKIO_TEST_ENV=1\n')
+
+  const defaultShell = createShell(createKernel(root))
+  await defaultShell.init_env({
+    path: process.cwd(),
+    env: {}
+  })
+  assert.equal(defaultShell.env.HF_HUB_DISABLE_UPDATE_CHECK, '1')
+
+  const overrideShell = createShell(createKernel(root))
+  await overrideShell.init_env({
+    path: process.cwd(),
+    env: {
+      HF_HUB_DISABLE_UPDATE_CHECK: '0'
+    }
+  })
+  assert.equal(overrideShell.env.HF_HUB_DISABLE_UPDATE_CHECK, '0')
+})
+
+test('Shell.init_env keeps Windows Hugging Face symlink defaults scoped to win32', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-shell-hf-win-'))
+  await fs.mkdir(path.join(root, 'api'), { recursive: true })
+  await fs.writeFile(path.join(root, 'ENVIRONMENT'), 'PINOKIO_TEST_ENV=1\n')
+
+  const darwinShell = createShell(createKernel(root))
+  darwinShell.platform = 'darwin'
+  await darwinShell.init_env({
+    path: process.cwd(),
+    env: {}
+  })
+  assert.equal(darwinShell.env.HF_HUB_DISABLE_UPDATE_CHECK, '1')
+  assert.equal(darwinShell.env.HF_HUB_DISABLE_SYMLINKS, undefined)
+
+  const winShell = createShell(createKernel(root))
+  winShell.platform = 'win32'
+  await winShell.init_env({
+    path: process.cwd(),
+    env: {}
+  })
+  assert.equal(winShell.env.HF_HUB_DISABLE_UPDATE_CHECK, '1')
+  assert.equal(winShell.env.HF_HUB_DISABLE_SYMLINKS, '1')
+  assert.equal(winShell.env.HF_HUB_DISABLE_SYMLINKS_WARNING, '1')
+})
+
+test('redactEnvArgs summarizes protected argv env values', () => {
+  const redacted = ShellRunTemplate.redactEnvArgs({
+    PINOKIO_ARG_0: 'line one\nline two',
+    REGULAR_VALUE: 'visible'
+  })
+
+  assert.equal(redacted.REGULAR_VALUE, 'visible')
+  assert.deepEqual(redacted.PINOKIO_ARG_0, {
+    type: 'pinokio env arg',
+    lines: 2,
+    preview: 'line one\nline two',
+    truncated: false
+  })
+})

package/test/storage-api.test.js

@@ -0,0 +1,137 @@
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('node:fs/promises')
+const os = require('node:os')
+const path = require('node:path')
+const Loader = require('../kernel/loader')
+const setApi = require('../kernel/api/set')
+const rmApi = require('../kernel/api/rm')
+const SelfAPI = require('../kernel/api/self')
+
+function createKernel () {
+  return {
+    memory: {
+      local: {},
+      global: {}
+    },
+    loader: new Loader()
+  }
+}
+
+test('generic set and rm update local/global memory and self JSON files', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-storage-api-'))
+  const kernel = createKernel()
+  const parent = {
+    id: 'request-1',
+    path: path.join(root, 'script.js')
+  }
+
+  try {
+    await setApi({
+      parent,
+      cwd: root,
+      params: {
+        local: {
+          'nested.value': 42,
+          items: ['a', 'b', 'c']
+        },
+        global: {
+          'state.ready': true
+        },
+        self: {
+          'data/state.json': {
+            'nested.keep': 'yes',
+            'nested.drop': 'no',
+            items: ['x', 'y', 'z']
+          }
+        }
+      }
+    }, () => {}, kernel)
+
+    assert.deepEqual(kernel.memory.local[parent.id], {
+      nested: { value: 42 },
+      items: ['a', 'b', 'c']
+    })
+    assert.deepEqual(kernel.memory.global[parent.id], {
+      state: { ready: true }
+    })
+
+    await rmApi({
+      parent,
+      cwd: root,
+      params: {
+        local: ['nested.value'],
+        global: ['state.ready'],
+        self: {
+          'data/state.json': ['nested.drop', 'items.1']
+        }
+      }
+    }, () => {}, kernel)
+
+    assert.deepEqual(kernel.memory.local[parent.id], {
+      nested: {},
+      items: ['a', 'b', 'c']
+    })
+    assert.deepEqual(kernel.memory.global[parent.id], {
+      state: {}
+    })
+    assert.deepEqual(
+      JSON.parse(await fs.readFile(path.join(root, 'data/state.json'), 'utf8')),
+      {
+        nested: { keep: 'yes' },
+        items: ['x', 'z']
+      }
+    )
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+
+test('self.set and self.rm wrap JSON file mutation without touching real launchers', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-self-api-'))
+  const kernel = createKernel()
+  const selfApi = new SelfAPI()
+  const parent = {
+    id: 'request-2',
+    path: path.join(root, 'script.js')
+  }
+
+  try {
+    await selfApi.set({
+      parent,
+      cwd: root,
+      params: {
+        'pinokio.json': {
+          title: 'Temporary launcher',
+          'plugin.menu': ['Run']
+        }
+      }
+    }, () => {}, kernel)
+
+    assert.deepEqual(
+      JSON.parse(await fs.readFile(path.join(root, 'pinokio.json'), 'utf8')),
+      {
+        title: 'Temporary launcher',
+        plugin: { menu: ['Run'] }
+      }
+    )
+
+    await selfApi.rm({
+      parent,
+      cwd: root,
+      params: {
+        'pinokio.json': ['plugin.menu']
+      }
+    }, () => {}, kernel)
+
+    assert.deepEqual(
+      JSON.parse(await fs.readFile(path.join(root, 'pinokio.json'), 'utf8')),
+      {
+        title: 'Temporary launcher',
+        plugin: {}
+      }
+    )
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})

package/test/uri-api.test.js

@@ -0,0 +1,100 @@
+const assert = require('node:assert/strict')
+const test = require('node:test')
+
+const URI = require('../kernel/api/uri')
+const Util = require('../kernel/util')
+
+test('uri.open builds URIs with query params without corrupting schemes', () => {
+  const api = new URI()
+
+  assert.equal(
+    api.build({ uri: 'https://example.test/path' }),
+    'https://example.test/path'
+  )
+  assert.equal(
+    api.build({
+      uri: 'https://example.test/path',
+      params: {
+        q: 'hello world',
+        tag: ['one', 'two'],
+        meta: { nested: true },
+        skip: null
+      }
+    }),
+    'https://example.test/path?q=hello%20world&tag=one&tag=two&meta=%7B%22nested%22%3Atrue%7D'
+  )
+  assert.equal(
+    api.build({
+      uri: 'https://example.test/path#section',
+      params: { q: 'x' }
+    }),
+    'https://example.test/path?q=x#section'
+  )
+  assert.equal(
+    api.build({
+      uri: 'vscode://file/tmp/test.js',
+      params: { line: 12 }
+    }),
+    'vscode://file/tmp/test.js?line=12'
+  )
+  assert.equal(
+    api.build({
+      uri: 'cursor://file/tmp/test.js',
+      params: { line: 12 }
+    }),
+    'cursor://file/tmp/test.js?line=12'
+  )
+  assert.equal(
+    api.build({
+      uri: 'obsidian://open?vault=test',
+      params: { file: 'Daily Note' }
+    }),
+    'obsidian://open?vault=test&file=Daily%20Note'
+  )
+  assert.equal(
+    api.build({
+      uri: 'mailto:test@example.com',
+      params: { subject: 'Pinokio test' }
+    }),
+    'mailto:test@example.com?subject=Pinokio%20test'
+  )
+  assert.equal(
+    api.build({ uri: 'file:///tmp/pinokio-uri-open-test.txt' }),
+    'file:///tmp/pinokio-uri-open-test.txt'
+  )
+  assert.throws(
+    () => api.build({}),
+    /uri\.open requires params\.uri/
+  )
+})
+
+test('uri.open dispatches the exact built URI to Util.openURI', async () => {
+  const api = new URI()
+  const originalOpenURI = Util.openURI
+  const opened = []
+
+  Util.openURI = async (uri) => {
+    opened.push(uri)
+    return { ok: true, status: 'stubbed' }
+  }
+
+  try {
+    const response = await api.open({
+      params: {
+        uri: 'cursor://file/tmp/test.js',
+        params: {
+          line: 42,
+          column: 7
+        }
+      }
+    }, () => {})
+
+    assert.deepEqual(opened, ['cursor://file/tmp/test.js?line=42&column=7'])
+    assert.deepEqual(response, {
+      uri: 'cursor://file/tmp/test.js?line=42&column=7',
+      result: { ok: true, status: 'stubbed' }
+    })
+  } finally {
+    Util.openURI = originalOpenURI
+  }
+})