@pikku/core 0.12.2 → 0.12.3

package/src/handle-error.test.ts

@@ -267,7 +267,7 @@ describe('handleHTTPError', () => {
     // Should not throw
   })
 
-  test('should call response.close when available', () => {
+  test('should not call response.close automatically', () => {
     const logger = createMockLogger()
     const http = createMockHTTP()
     const error = new BadRequestError('bad')
@@ -282,7 +282,7 @@ describe('handleHTTPError', () => {
       false
     )
 
-    assert.strictEqual(http._state.closed, true)
+    assert.strictEqual(http._state.closed, false)
   })
 
   test('should handle undefined http gracefully', () => {
@@ -335,6 +335,69 @@ describe('handleHTTPError', () => {
     assert.ok(errors.some((e) => e.args[0] === 'just a string error'))
   })
 
+  test('should include message and stack when exposeErrors is true', () => {
+    const logger = createMockLogger()
+    const http = createMockHTTP()
+    const error = new Error('something unexpected')
+
+    handleHTTPError(
+      error,
+      http as any,
+      'tracker-expose',
+      logger as any,
+      [],
+      true,
+      false,
+      true
+    )
+
+    assert.strictEqual(http._state.statusCode, 500)
+    assert.strictEqual(http._state.jsonBody.errorId, 'tracker-expose')
+    assert.strictEqual(http._state.jsonBody.message, 'something unexpected')
+    assert.ok(typeof http._state.jsonBody.stack === 'string')
+  })
+
+  test('should not include message and stack when exposeErrors is false', () => {
+    const logger = createMockLogger()
+    const http = createMockHTTP()
+    const error = new Error('something unexpected')
+
+    handleHTTPError(
+      error,
+      http as any,
+      'tracker-no-expose',
+      logger as any,
+      [],
+      true,
+      false,
+      false
+    )
+
+    assert.strictEqual(http._state.statusCode, 500)
+    assert.deepStrictEqual(http._state.jsonBody, {
+      errorId: 'tracker-no-expose',
+    })
+  })
+
+  test('should not expose details for non-Error objects even when exposeErrors is true', () => {
+    const logger = createMockLogger()
+    const http = createMockHTTP()
+
+    handleHTTPError(
+      'string error',
+      http as any,
+      'tracker-str',
+      logger as any,
+      [],
+      true,
+      false,
+      true
+    )
+
+    assert.strictEqual(http._state.statusCode, 500)
+    assert.deepStrictEqual(http._state.jsonBody, { errorId: 'tracker-str' })
+  })
+
   test('should handle warning log without trackerId', () => {
     const logger = createMockLogger()
     const http = createMockHTTP()

package/src/handle-error.ts

@@ -21,7 +21,8 @@ export const handleHTTPError = (
   logger: Logger,
   logWarningsForStatusCodes: number[],
   respondWith404: boolean,
-  bubbleError: boolean
+  bubbleError: boolean,
+  exposeErrors: boolean = false
 ) => {
   // Skip 404 handling if configured to do so
   if (e instanceof NotFoundError && !respondWith404) {
@@ -53,13 +54,16 @@ export const handleHTTPError = (
 
     if (trackerId) {
       logger.warn(`Error id: ${trackerId}`)
-      http?.response?.json({ errorId: trackerId })
+      const errorBody: Record<string, unknown> = { errorId: trackerId }
+      if (exposeErrors && e instanceof Error) {
+        errorBody.message = e.message
+        errorBody.stack = e.stack
+      }
+      http?.response?.json(errorBody)
     }
   }
 
   if (bubbleError) {
     throw e
   }
-
-  http?.response?.close?.()
 }

package/src/index.ts

@@ -47,6 +47,7 @@ export type {
   CorePikkuPermission,
   CorePikkuPermissionConfig,
   CorePikkuPermissionFactory,
+  CorePikkuApprovalDescription,
   CorePermissionGroup,
   ZodLike,
 } from './function/functions.types.js'
@@ -54,6 +55,7 @@ export {
   pikkuAuth,
   pikkuPermission,
   pikkuPermissionFactory,
+  pikkuApprovalDescription,
 } from './function/functions.types.js'
 export { addFunction, getAllFunctionNames } from './function/index.js'
 export { PikkuRequest } from './pikku-request.js'
@@ -86,6 +88,18 @@ export { NotFoundError } from './errors/errors.js'
 export type { EventHubService } from './wirings/channel/eventhub-service.js'
 export type { QueueService } from './wirings/queue/queue.types.js'
 export type { JWTService } from './services/jwt-service.js'
+export type { SecretService } from './services/secret-service.js'
+export type { VariablesService } from './services/variables-service.js'
+export type { ContentService } from './services/content-service.js'
+export type { DeploymentService } from './services/deployment-service.js'
+export type { WorkflowService } from './services/workflow-service.js'
+export type { GatewayService } from './services/gateway-service.js'
+export type { TriggerService } from './services/trigger-service.js'
+export type { SchemaService } from './services/schema-service.js'
+export type { SessionService } from './services/user-session-service.js'
+export type { AIAgentRunnerService } from './services/ai-agent-runner-service.js'
+export type { AIRunStateService } from './services/ai-run-state-service.js'
+export type { AIStorageService } from './services/ai-storage-service.js'
 export type { HTTPMethod } from './wirings/http/http.types.js'
 export type { GraphNodeConfig } from './wirings/workflow/graph/workflow-graph.types.js'
 export { createGraph } from './wirings/workflow/graph/graph-node.js'

package/src/pikku-state.ts

@@ -72,7 +72,9 @@ const createEmptyPackageState = (): PikkuPackageState => ({
   rpc: {
     meta: {},
     files: new Map(),
-    addons: new Map(),
+  },
+  addons: {
+    packages: new Map(),
   },
   http: {
     middleware: new Map(),

package/src/schema.ts

@@ -146,6 +146,6 @@ export const validateSchema = async (
       )
     }
     await schemaService.compileSchema(key, schema)
-    await schemaService.validateSchema(key, data)
+    await schemaService.validateSchema(key, data ?? {})
   }
 }

package/src/services/in-memory-workflow-service.ts

@@ -6,6 +6,7 @@ import type {
   WorkflowRunWire,
   StepState,
   WorkflowStatus,
+  WorkflowVersionStatus,
   WorkflowStepOptions,
 } from '../wirings/workflow/workflow.types.js'
 
@@ -40,7 +41,10 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
   >() // keyed by runId
   private runState = new Map<string, Record<string, unknown>>() // keyed by runId
   private branchKeys = new Map<string, string>() // keyed by stepId
-  private workflowVersions = new Map<string, { graph: any; source: string }>() // keyed by `${name}:${graphHash}`
+  private workflowVersions = new Map<
+    string,
+    { graph: any; source: string; status: WorkflowVersionStatus }
+  >() // keyed by `${name}:${graphHash}`
 
   async createRun(
     workflowName: string,
@@ -376,14 +380,28 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
     name: string,
     graphHash: string,
     graph: any,
-    source: string
+    source: string,
+    status?: WorkflowVersionStatus
   ): Promise<void> {
     this.workflowVersions.set(`${name}:${graphHash}`, {
       graph,
       source,
+      status: status ?? 'active',
     })
   }
 
+  async updateWorkflowVersionStatus(
+    name: string,
+    graphHash: string,
+    status: WorkflowVersionStatus
+  ): Promise<void> {
+    const key = `${name}:${graphHash}`
+    const version = this.workflowVersions.get(key)
+    if (version) {
+      version.status = status
+    }
+  }
+
   async getWorkflowVersion(
     name: string,
     graphHash: string
@@ -392,4 +410,29 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
     if (!version) return null
     return { graph: version.graph, source: version.source }
   }
+
+  async getAIGeneratedWorkflows(
+    agentName?: string
+  ): Promise<Array<{ workflowName: string; graphHash: string; graph: any }>> {
+    const results: Array<{
+      workflowName: string
+      graphHash: string
+      graph: any
+    }> = []
+    const prefix = agentName ? `ai:${agentName}:` : 'ai:'
+    for (const [key, value] of this.workflowVersions) {
+      if (value.source !== 'ai-agent' || value.status !== 'active') continue
+      const separatorIdx = key.lastIndexOf(':')
+      const wfName = key.substring(0, separatorIdx)
+      const hash = key.substring(separatorIdx + 1)
+      if (wfName.startsWith(prefix)) {
+        results.push({
+          workflowName: wfName,
+          graphHash: hash,
+          graph: value.graph,
+        })
+      }
+    }
+    return results
+  }
 }

package/src/services/workflow-service.ts

@@ -4,6 +4,7 @@ import type {
   WorkflowRunWire,
   StepState,
   WorkflowStatus,
+  WorkflowVersionStatus,
 } from '../wirings/workflow/workflow.types.js'
 
 /**
@@ -75,10 +76,20 @@ export interface WorkflowService {
     name: string,
     graphHash: string,
     graph: any,
-    source: string
+    source: string,
+    status?: WorkflowVersionStatus
+  ): Promise<void>
+  updateWorkflowVersionStatus(
+    name: string,
+    graphHash: string,
+    status: WorkflowVersionStatus
   ): Promise<void>
   getWorkflowVersion(
     name: string,
     graphHash: string
   ): Promise<{ graph: any; source: string } | null>
+
+  getAIGeneratedWorkflows(
+    agentName?: string
+  ): Promise<Array<{ workflowName: string; graphHash: string; graph: any }>>
 }

package/src/testing/index.ts

@@ -0,0 +1,2 @@
+export { defineServiceTests } from './service-tests.js'
+export type { ServiceTestConfig } from './service-tests.js'