@pikku/core 0.12.19 → 0.12.21

package/run-tests.sh

@@ -1,5 +1,8 @@
 #!/bin/bash
 
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$script_dir"
+
 # Enable nullglob to handle cases where no files match the pattern
 shopt -s nullglob
 
@@ -34,7 +37,7 @@ files=($(find src -type f -name "*.test.ts"))
 # Check if any files matched the pattern
 if [ ${#files[@]} -eq 0 ]; then
   echo "No test files found matching pattern: $pattern"
-  if [ "${STRICT_TEST_DISCOVERY}" = "1" ] || [ "${CI}" = "true" ]; then
+  if [ "${STRICT_TEST_DISCOVERY}" = "1" ]; then
     exit 1
   fi
   exit 0

package/src/dev/hot-reload.test.ts

@@ -1,5 +1,12 @@
-import { describe, test, beforeEach, afterEach } from 'node:test'
+import {
+  describe,
+  test,
+  beforeEach,
+  afterEach,
+  type TestContext,
+} from 'node:test'
 import assert from 'node:assert/strict'
+import { watch } from 'node:fs'
 import { mkdtemp, writeFile, rm, mkdir } from 'node:fs/promises'
 import { join } from 'node:path'
 import { tmpdir } from 'node:os'
@@ -21,6 +28,32 @@ import {
 
 const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
 
+const ensureRecursiveWatchAvailable = async (
+  t: TestContext,
+  dir: string
+): Promise<boolean> => {
+  if (process.platform === 'darwin') {
+    t.skip('recursive fs.watch is unreliable on darwin')
+    return false
+  }
+
+  try {
+    const watcher = watch(dir, { recursive: true }, () => {})
+    watcher.close()
+    return true
+  } catch (error: any) {
+    if (
+      error?.code === 'EMFILE' ||
+      error?.code === 'ERR_FEATURE_UNAVAILABLE_ON_PLATFORM' ||
+      error?.code === 'ERR_INVALID_ARG_VALUE'
+    ) {
+      t.skip(`recursive fs.watch unavailable: ${error.code}`)
+      return false
+    }
+    throw error
+  }
+}
+
 const createMockLogger = () => {
   const logs: Array<{ level: string; message: string }> = []
   return {
@@ -47,7 +80,7 @@ const writeFunctionModule = async (
   await writeFile(join(dir, filename), `// ts trigger ${Date.now()}`)
 }
 
-describe('pikkuDevReloader', () => {
+describe('pikkuDevReloader', { concurrency: false }, () => {
   let tmpDir: string
   let reloader: { close: () => void } | undefined
   let mockLogger: ReturnType<typeof createMockLogger>
@@ -76,7 +109,9 @@ describe('pikkuDevReloader', () => {
     await rm(tmpDir, { recursive: true, force: true })
   })
 
-  test('should hot-reload a function and pick up new return value', async () => {
+  test('should hot-reload a function and pick up new return value', async (t) => {
+    if (!(await ensureRecursiveWatchAvailable(t, tmpDir))) return
+
     addFunction('myFunc', {
       func: async () => ({ version: 1 }),
     })
@@ -112,7 +147,9 @@ describe('pikkuDevReloader', () => {
     assert.ok(reloadLog, 'Should log hot-reload message')
   })
 
-  test('should not replace a function that is not registered', async () => {
+  test('should not replace a function that is not registered', async (t) => {
+    if (!(await ensureRecursiveWatchAvailable(t, tmpDir))) return
+
     addFunction('registeredFunc', {
       func: async () => ({ name: 'registered' }),
     })
@@ -135,7 +172,9 @@ describe('pikkuDevReloader', () => {
     )
   })
 
-  test('should keep old code when JS import fails', async () => {
+  test('should keep old code when JS import fails', async (t) => {
+    if (!(await ensureRecursiveWatchAvailable(t, tmpDir))) return
+
     addFunction('badFunc', {
       func: async () => ({ working: true }),
     })
@@ -166,7 +205,9 @@ describe('pikkuDevReloader', () => {
     })
   })
 
-  test('should ignore non-ts files, test files, and gen files', async () => {
+  test('should ignore non-ts files, test files, and gen files', async (t) => {
+    if (!(await ensureRecursiveWatchAvailable(t, tmpDir))) return
+
     addFunction('someFunc', {
       func: async () => ({ original: true }),
     })
@@ -190,7 +231,9 @@ describe('pikkuDevReloader', () => {
     assert.equal(reloadLogs.length, 0)
   })
 
-  test('should hot-reload function used via HTTP wire', async () => {
+  test('should hot-reload function used via HTTP wire', async (t) => {
+    if (!(await ensureRecursiveWatchAvailable(t, tmpDir))) return
+
     const sessionMiddleware = async (_services: any, wire: any, next: any) => {
       wire.setSession?.({ userId: 'test' } as any)
       await next()
@@ -251,7 +294,9 @@ describe('pikkuDevReloader', () => {
     })
   })
 
-  test('should hot-reload function used via scheduler wire', async () => {
+  test('should hot-reload function used via scheduler wire', async (t) => {
+    if (!(await ensureRecursiveWatchAvailable(t, tmpDir))) return
+
     const taskResult = { ref: 'initial' }
 
     pikkuState(null, 'scheduler', 'meta')['hotTask'] = {
@@ -371,7 +416,9 @@ describe('pikkuDevReloader', () => {
     assert.deepEqual(resultV2, { result: 'v2' })
   })
 
-  test('should debounce rapid file changes', async () => {
+  test('should debounce rapid file changes', async (t) => {
+    if (!(await ensureRecursiveWatchAvailable(t, tmpDir))) return
+
     addFunction('debounceFunc', {
       func: async () => ({ count: 0 }),
     })
@@ -396,7 +443,9 @@ describe('pikkuDevReloader', () => {
     assert.equal(result.count, 5)
   })
 
-  test('should watch subdirectories', async () => {
+  test('should watch subdirectories', async (t) => {
+    if (!(await ensureRecursiveWatchAvailable(t, tmpDir))) return
+
     const subDir = join(tmpDir, 'functions')
     await mkdir(subDir)
 
@@ -426,7 +475,9 @@ describe('pikkuDevReloader', () => {
     })
   })
 
-  test('should properly clean up on close', async () => {
+  test('should properly clean up on close', async (t) => {
+    if (!(await ensureRecursiveWatchAvailable(t, tmpDir))) return
+
     addFunction('cleanupFunc', {
       func: async () => ({ v: 1 }),
     })

package/src/dev/hot-reload.ts

@@ -1,6 +1,9 @@
 import { watch, type FSWatcher } from 'node:fs'
 import { stat, readFile } from 'node:fs/promises'
 import { join, resolve, relative } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+import { register } from 'tsx/esm/api'
 
 import { pikkuState } from '../pikku-state.js'
 import { addFunction } from '../function/function-runner.js'
@@ -54,10 +57,26 @@ const findCompiledFile = async (
 // Use data: URLs to import modules. This bypasses TypeScript loaders
 // (e.g. tsx) that intercept file:// imports and break dynamic ESM loading.
 // Each import gets unique content so there's no module cache to worry about.
+let tsxRegistered = false
+
+const ensureTsxRegistered = () => {
+  if (tsxRegistered) return
+  register()
+  tsxRegistered = true
+}
+
 const reimportModule = async (
-  filePath: string
+  filePath: string,
+  useTsx = false
 ): Promise<Record<string, unknown> | null> => {
   try {
+    if (useTsx) {
+      ensureTsxRegistered()
+      return await import(
+        `${pathToFileURL(resolve(filePath)).href}?t=${Date.now()}`
+      )
+    }
+
     const content = await readFile(resolve(filePath), 'utf-8')
     const dataUrl =
       'data:text/javascript;base64,' + Buffer.from(content).toString('base64')
@@ -98,17 +117,19 @@ export async function pikkuDevReloader(
       srcDir,
       absPikkuDir
     )
-    if (!compiledFile) {
-      logger.warn(
-        `Could not find compiled JS for: ${relative(process.cwd(), changedTsFile)}`
+    const importPath = compiledFile ?? changedTsFile
+    const usedTsxFallback = !compiledFile
+
+    if (usedTsxFallback) {
+      logger.debug(
+        `Hot-reload using tsx fallback for: ${relative(process.cwd(), changedTsFile)}`
       )
-      return
     }
 
-    const mod = await reimportModule(compiledFile)
+    const mod = await reimportModule(importPath, usedTsxFallback)
     if (!mod) {
       logger.error(
-        `Failed to import: ${relative(process.cwd(), compiledFile)} (keeping old code)`
+        `Failed to import: ${relative(process.cwd(), importPath)} (keeping old code)`
       )
       return
     }

package/src/errors/error-handler.ts

@@ -29,8 +29,14 @@ export interface ErrorDetails {
  * @param error - The error to add.
  * @param details - The details of the error.
  */
-export const addError = (error: any, { status, message }: ErrorDetails) => {
-  pikkuState(null, 'misc', 'errors').set(error, { status, message })
+export const addError = (
+  error: any,
+  { status, message, mcpCode }: ErrorDetails
+) => {
+  pikkuState(null, 'misc', 'errors').set(
+    error,
+    mcpCode === undefined ? { status, message } : { status, message, mcpCode }
+  )
 }
 
 /**

package/src/errors/error.test.ts

@@ -77,6 +77,7 @@ describe('getErrorResponse', () => {
     const response = getErrorResponse(error)
     assert.deepStrictEqual(response, {
       status: 400,
+      mcpCode: -32600,
       message:
         'The server cannot or will not process the request due to client error (e.g., malformed request syntax).',
     })
@@ -87,6 +88,7 @@ describe('getErrorResponse', () => {
     const response = getErrorResponse(error)
     assert.deepStrictEqual(response, {
       status: 404,
+      mcpCode: -32601,
       message: 'The server cannot find the requested resource.',
     })
   })