pinokiod 7.5.21 → 7.5.24

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

@@ -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 })
+  }
+})

package/test/universal-launcher.smoke.spec.js

@@ -136,4 +136,54 @@ test.describe('universal launcher smoke', () => {
       await deleteTask(request, tempPluginTask && tempPluginTask.id);
     }
   });
+
+  test('plugins page create and download buttons open plugin launcher on expected tabs', async ({ page }) => {
+    const pageErrors = [];
+    const consoleErrors = [];
+
+    page.on('pageerror', (error) => {
+      pageErrors.push(String(error));
+    });
+
+    page.on('console', (msg) => {
+      if (msg.type() === 'error') {
+        consoleErrors.push(msg.text());
+      }
+    });
+
+    await page.goto(`${BASE_URL}/plugins`, { waitUntil: 'networkidle' });
+
+    const createTrigger = page.locator('.task-shell-header [data-universal-launcher-open="create_plugin"]:not([data-universal-launcher-mode])').first();
+    await expect(createTrigger).toBeVisible();
+    await createTrigger.click();
+
+    const overlay = page.locator('.universal-launcher-overlay:not([hidden])').first();
+    await expect(overlay).toBeVisible();
+    await expect(overlay.locator('.universal-launcher-title')).toHaveText('Create Plugin');
+    await expect(overlay.locator('.universal-launcher-mode[data-mode="primary"]')).toHaveClass(/active/);
+    await expect(overlay.locator('.universal-launcher-section-prompt')).toBeVisible();
+    await expect(overlay.locator('.universal-launcher-section-tools')).toBeVisible();
+    await expect(overlay.locator('.universal-launcher-section-download')).toBeHidden();
+
+    await overlay.locator('.universal-launcher-close').click();
+    await expect(overlay).toBeHidden();
+
+    const downloadTrigger = page.locator('.task-shell-header [data-universal-launcher-open="create_plugin"][data-universal-launcher-mode="download"]').first();
+    await expect(downloadTrigger).toBeVisible();
+    await downloadTrigger.click();
+
+    await expect(overlay).toBeVisible();
+    await expect(overlay.locator('.universal-launcher-title')).toHaveText('Create Plugin');
+    await expect(overlay.locator('.universal-launcher-mode[data-mode="download"]')).toHaveClass(/active/);
+    await expect(overlay.locator('.universal-launcher-section-download')).toBeVisible();
+    await expect(overlay.locator('.universal-launcher-section-prompt')).toBeHidden();
+    await expect(overlay.locator('.universal-launcher-section-tools')).toBeHidden();
+    await expect(overlay.locator('.universal-launcher-download-input').first()).toBeFocused();
+
+    expect(pageErrors, `page errors: ${pageErrors.join('\n')}`).toEqual([]);
+    expect(
+      consoleErrors.filter((line) => !line.includes('favicon')),
+      `console errors: ${consoleErrors.join('\n')}`
+    ).toEqual([]);
+  });
 });