@pikku/core 0.11.2 → 0.12.1

package/src/services/deployment-service.ts

@@ -0,0 +1,22 @@
+export interface DeploymentServiceConfig {
+  heartbeatInterval?: number
+  heartbeatTtl?: number
+}
+
+export interface DeploymentConfig {
+  deploymentId: string
+  endpoint: string
+  functions?: string[]
+}
+
+export interface DeploymentInfo {
+  deploymentId: string
+  endpoint: string
+}
+
+export interface DeploymentService {
+  init(): Promise<void>
+  start(config: DeploymentConfig): Promise<void>
+  stop(): Promise<void>
+  findFunction(name: string): Promise<DeploymentInfo[]>
+}

package/src/services/gopass-secrets.ts

@@ -0,0 +1,98 @@
+import { execFileSync } from 'child_process'
+import type { SecretService } from './secret-service.js'
+
+/**
+ * Service for retrieving secrets from gopass.
+ * Requires gopass to be installed and configured on the system.
+ */
+export class GopassSecretService implements SecretService {
+  /**
+   * Creates an instance of GopassSecretService.
+   * @param prefix - Optional prefix for all secret keys (e.g., 'pikku/' will look up 'pikku/mykey' for key 'mykey')
+   */
+  constructor(private prefix: string = '') {}
+
+  private getFullKey(key: string): string {
+    if (!/^[\w.\-/]+$/.test(key)) {
+      throw new Error(`Invalid secret key format: ${key}`)
+    }
+    return this.prefix ? `${this.prefix}${key}` : key
+  }
+
+  /**
+   * Retrieves a secret by key and parses it as JSON.
+   * @param key - The key of the secret to retrieve.
+   * @returns A promise that resolves to the parsed secret value.
+   * @throws {Error} If the secret is not found or gopass fails.
+   */
+  public async getSecretJSON<R>(key: string): Promise<R> {
+    const value = await this.getSecret(key)
+    return JSON.parse(value)
+  }
+
+  /**
+   * Retrieves a secret by key as a string.
+   * @param key - The key of the secret to retrieve.
+   * @returns A promise that resolves to the secret value.
+   * @throws {Error} If the secret is not found or gopass fails.
+   */
+  public async getSecret(key: string): Promise<string> {
+    const fullKey = this.getFullKey(key)
+    try {
+      return execFileSync('gopass', ['show', '-o', fullKey], {
+        encoding: 'utf8',
+      }).trim()
+    } catch (error: any) {
+      throw new Error(`Secret Not Found: ${key}`, { cause: error })
+    }
+  }
+
+  /**
+   * Checks if a secret exists without throwing.
+   * @param key - The key of the secret to check.
+   * @returns A promise that resolves to true if the secret exists.
+   */
+  public async hasSecret(key: string): Promise<boolean> {
+    const fullKey = this.getFullKey(key)
+    try {
+      execFileSync('gopass', ['show', '-o', fullKey], { encoding: 'utf8' })
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Stores a JSON value as a secret in gopass.
+   * @param key - The key to store the secret under.
+   * @param value - The JSON value to store.
+   * @returns A promise that resolves when the secret is stored.
+   */
+  public async setSecretJSON(key: string, value: unknown): Promise<void> {
+    const fullKey = this.getFullKey(key)
+    const jsonValue = JSON.stringify(value)
+    try {
+      execFileSync('gopass', ['insert', '-f', fullKey], {
+        encoding: 'utf8',
+        input: jsonValue,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      })
+    } catch (error: any) {
+      throw new Error(`Failed to set secret: ${key}`, { cause: error })
+    }
+  }
+
+  /**
+   * Deletes a secret from gopass.
+   * @param key - The key of the secret to delete.
+   * @returns A promise that resolves when the secret is deleted.
+   */
+  public async deleteSecret(key: string): Promise<void> {
+    const fullKey = this.getFullKey(key)
+    try {
+      execFileSync('gopass', ['rm', '-f', fullKey], { encoding: 'utf8' })
+    } catch {
+      // Ignore errors if secret doesn't exist
+    }
+  }
+}

package/src/services/in-memory-ai-run-state-service.ts

@@ -0,0 +1,73 @@
+import type {
+  AIRunStateService,
+  CreateRunInput,
+} from './ai-run-state-service.js'
+import type {
+  AgentRunState,
+  PendingApproval,
+} from '../wirings/ai-agent/ai-agent.types.js'
+
+export class InMemoryAIRunStateService implements AIRunStateService {
+  private runs = new Map<string, AgentRunState>()
+  private counter = 0
+
+  async createRun(run: CreateRunInput): Promise<string> {
+    const runId = `run-${++this.counter}-${Date.now()}`
+    this.runs.set(runId, { ...run, runId })
+    return runId
+  }
+
+  async updateRun(
+    runId: string,
+    updates: Partial<AgentRunState>
+  ): Promise<void> {
+    const run = this.runs.get(runId)
+    if (run) {
+      Object.assign(run, updates, { updatedAt: new Date() })
+    }
+  }
+
+  async getRun(runId: string): Promise<AgentRunState | null> {
+    return this.runs.get(runId) ?? null
+  }
+
+  async getRunsByThread(threadId: string): Promise<AgentRunState[]> {
+    return [...this.runs.values()].filter((r) => r.threadId === threadId)
+  }
+
+  async resolveApproval(
+    toolCallId: string,
+    status: 'approved' | 'denied'
+  ): Promise<void> {
+    for (const run of this.runs.values()) {
+      if (run.pendingApprovals) {
+        const approval = run.pendingApprovals.find(
+          (a) => a.toolCallId === toolCallId
+        )
+        if (approval) {
+          run.pendingApprovals = run.pendingApprovals.filter(
+            (a) => a.toolCallId !== toolCallId
+          )
+          run.updatedAt = new Date()
+          return
+        }
+      }
+    }
+  }
+
+  async findRunByToolCallId(
+    toolCallId: string
+  ): Promise<{ run: AgentRunState; approval: PendingApproval } | null> {
+    for (const run of this.runs.values()) {
+      if (run.pendingApprovals) {
+        const approval = run.pendingApprovals.find(
+          (a) => a.toolCallId === toolCallId
+        )
+        if (approval) {
+          return { run, approval }
+        }
+      }
+    }
+    return null
+  }
+}

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

@@ -0,0 +1,64 @@
+import { PikkuTriggerService } from '../wirings/trigger/pikku-trigger-service.js'
+import { getSingletonServices } from '../pikku-state.js'
+
+/**
+ * In-memory TriggerService implementation.
+ *
+ * Reads both `wireTrigger` declarations and `wireTriggerSource` registrations
+ * from pikkuState. Only starts triggers that have both a declaration and a source.
+ * On fire, invokes target via `ContextAwareRPCService`.
+ *
+ * Single owner — one process runs triggers, no distributed claiming.
+ *
+ * @example
+ * ```typescript
+ * const triggerService = new InMemoryTriggerService()
+ * await triggerService.start()
+ *
+ * // On shutdown
+ * await triggerService.stop()
+ * ```
+ */
+export class InMemoryTriggerService extends PikkuTriggerService {
+  async start(): Promise<void> {
+    const singletonServices = getSingletonServices()
+
+    const triggerTargets = this.getTriggerTargets()
+    const triggerSources = this.getTriggerSources()
+
+    for (const [name, source] of triggerSources) {
+      if (this.activeTriggers.has(name)) {
+        continue
+      }
+
+      const targets = triggerTargets.get(name)
+      if (!targets || targets.length === 0) {
+        singletonServices.logger.info(
+          `Trigger source '${name}' has no targets, skipping`
+        )
+        continue
+      }
+
+      try {
+        const triggerInstance = await this.setupTriggerInstance(
+          name,
+          source.input,
+          (data) => this.onTriggerFire(name, targets, data)
+        )
+
+        this.activeTriggers.set(name, triggerInstance)
+        singletonServices.logger.info(`Started trigger: ${name}`)
+      } catch (error) {
+        singletonServices.logger.error(
+          `Failed to start trigger ${name}: ${error}`
+        )
+      }
+    }
+
+    if (this.activeTriggers.size === 0) {
+      singletonServices.logger.info(
+        'No triggers started (no matching sources and targets found)'
+      )
+    }
+  }
+}

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

@@ -0,0 +1,351 @@
+import { describe, test, beforeEach } from 'node:test'
+import assert from 'node:assert'
+import { InMemoryWorkflowService } from './in-memory-workflow-service.js'
+
+let service: InMemoryWorkflowService
+
+beforeEach(() => {
+  service = new InMemoryWorkflowService()
+})
+
+describe('InMemoryWorkflowService', () => {
+  describe('createRun', () => {
+    test('should create a run and return a UUID', async () => {
+      const runId = await service.createRun(
+        'test-workflow',
+        { key: 'val' },
+        true,
+        'hash1',
+        { type: 'test' } as any
+      )
+      assert.ok(runId)
+      assert.strictEqual(typeof runId, 'string')
+    })
+
+    test('should store the run with correct properties', async () => {
+      const runId = await service.createRun(
+        'my-workflow',
+        { input: 1 },
+        false,
+        'hash2',
+        { type: 'http' } as any
+      )
+      const run = await service.getRun(runId)
+      assert.ok(run)
+      assert.strictEqual(run.workflow, 'my-workflow')
+      assert.strictEqual(run.status, 'running')
+      assert.deepStrictEqual(run.input, { input: 1 })
+      assert.strictEqual(run.inline, false)
+      assert.strictEqual(run.graphHash, 'hash2')
+    })
+
+    test('should initialize empty step history and run state', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      const history = await service.getRunHistory(runId)
+      assert.deepStrictEqual(history, [])
+      const state = await service.getRunState(runId)
+      assert.deepStrictEqual(state, {})
+    })
+  })
+
+  describe('getRun', () => {
+    test('should return null for non-existent run', async () => {
+      const run = await service.getRun('non-existent')
+      assert.strictEqual(run, null)
+    })
+  })
+
+  describe('updateRunStatus', () => {
+    test('should update run status', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      await service.updateRunStatus(runId, 'succeeded', { result: 'done' })
+      const run = await service.getRun(runId)
+      assert.strictEqual(run!.status, 'succeeded')
+      assert.deepStrictEqual(run!.output, { result: 'done' })
+    })
+
+    test('should update run with error', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      const error = { name: 'Error', message: 'Failed' }
+      await service.updateRunStatus(runId, 'failed', undefined, error)
+      const run = await service.getRun(runId)
+      assert.strictEqual(run!.status, 'failed')
+      assert.deepStrictEqual(run!.error, error)
+    })
+
+    test('should handle non-existent run gracefully', async () => {
+      await service.updateRunStatus('non-existent', 'failed')
+      // Should not throw
+    })
+  })
+
+  describe('step lifecycle', () => {
+    test('should insert a step in pending state', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      const step = await service.insertStepState(runId, 'step1', 'rpcFunc', {
+        data: 1,
+      })
+      assert.strictEqual(step.status, 'pending')
+      assert.strictEqual(step.attemptCount, 1)
+      assert.ok(step.stepId)
+    })
+
+    test('should store step options', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      const step = await service.insertStepState(
+        runId,
+        'step1',
+        null,
+        {},
+        { retries: 3, retryDelay: 1000 }
+      )
+      assert.strictEqual(step.retries, 3)
+      assert.strictEqual(step.retryDelay, 1000)
+    })
+
+    test('should transition step to running', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      const step = await service.insertStepState(runId, 'step1', null, {})
+      await service.setStepRunning(step.stepId)
+      const updated = await service.getStepState(runId, 'step1')
+      assert.strictEqual(updated.status, 'running')
+      assert.ok(updated.runningAt)
+    })
+
+    test('should transition step to scheduled', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      const step = await service.insertStepState(runId, 'step1', null, {})
+      await service.setStepScheduled(step.stepId)
+      const updated = await service.getStepState(runId, 'step1')
+      assert.strictEqual(updated.status, 'scheduled')
+      assert.ok(updated.scheduledAt)
+    })
+
+    test('should transition step to succeeded with result', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      const step = await service.insertStepState(runId, 'step1', null, {})
+      await service.setStepResult(step.stepId, { output: 'done' })
+      const updated = await service.getStepState(runId, 'step1')
+      assert.strictEqual(updated.status, 'succeeded')
+      assert.deepStrictEqual(updated.result, { output: 'done' })
+      assert.ok(updated.succeededAt)
+    })
+
+    test('should transition step to failed with error', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      const step = await service.insertStepState(runId, 'step1', null, {})
+      const error = new Error('step failed')
+      await service.setStepError(step.stepId, error)
+      const updated = await service.getStepState(runId, 'step1')
+      assert.strictEqual(updated.status, 'failed')
+      assert.strictEqual(updated.error!.message, 'step failed')
+      assert.ok(updated.failedAt)
+    })
+
+    test('should return default step state for non-existent step', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      const step = await service.getStepState(runId, 'non-existent')
+      assert.strictEqual(step.stepId, '')
+      assert.strictEqual(step.status, 'pending')
+      assert.strictEqual(step.attemptCount, 0)
+    })
+  })
+
+  describe('retry attempts', () => {
+    test('should create a retry attempt with incremented count', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      const step = await service.insertStepState(
+        runId,
+        'step1',
+        'rpc',
+        {},
+        { retries: 2 }
+      )
+      await service.setStepError(step.stepId, new Error('fail'))
+      const retry = await service.createRetryAttempt(step.stepId, 'pending')
+      assert.strictEqual(retry.attemptCount, 2)
+      assert.strictEqual(retry.status, 'pending')
+    })
+
+    test('should set running status on retry if specified', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      const step = await service.insertStepState(runId, 'step1', null, {})
+      await service.setStepError(step.stepId, new Error('fail'))
+      const retry = await service.createRetryAttempt(step.stepId, 'running')
+      assert.strictEqual(retry.status, 'running')
+      assert.ok(retry.runningAt)
+    })
+
+    test('should throw for non-existent step retry', async () => {
+      await assert.rejects(
+        () => service.createRetryAttempt('non-existent', 'pending'),
+        { message: 'Step not found: non-existent' }
+      )
+    })
+
+    test('should add retry to history', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      const step = await service.insertStepState(runId, 'step1', null, {})
+      await service.setStepError(step.stepId, new Error('fail'))
+      await service.createRetryAttempt(step.stepId, 'pending')
+      const history = await service.getRunHistory(runId)
+      assert.strictEqual(history.length, 2)
+    })
+  })
+
+  describe('run state', () => {
+    test('should update and get run state', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      await service.updateRunState(runId, 'counter', 5)
+      await service.updateRunState(runId, 'status', 'active')
+      const state = await service.getRunState(runId)
+      assert.deepStrictEqual(state, { counter: 5, status: 'active' })
+    })
+
+    test('should return empty object for non-existent run state', async () => {
+      const state = await service.getRunState('non-existent')
+      assert.deepStrictEqual(state, {})
+    })
+  })
+
+  describe('graph state', () => {
+    test('should track completed and failed nodes', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      const step1 = await service.insertStepState(runId, 'node1', null, {})
+      await service.setStepResult(step1.stepId, 'ok')
+      const step2 = await service.insertStepState(
+        runId,
+        'node2',
+        null,
+        {},
+        { retries: 0 }
+      )
+      await service.setStepError(step2.stepId, new Error('fail'))
+
+      const state = await service.getCompletedGraphState(runId)
+      assert.deepStrictEqual(state.completedNodeIds, ['node1'])
+      assert.deepStrictEqual(state.failedNodeIds, ['node2'])
+    })
+
+    test('should not count failed step as terminal if retries remain', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      const step = await service.insertStepState(
+        runId,
+        'node1',
+        null,
+        {},
+        { retries: 2 }
+      )
+      await service.setStepError(step.stepId, new Error('fail'))
+
+      const state = await service.getCompletedGraphState(runId)
+      assert.deepStrictEqual(state.failedNodeIds, [])
+    })
+
+    test('should find nodes without steps', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      await service.insertStepState(runId, 'node1', null, {})
+
+      const missing = await service.getNodesWithoutSteps(runId, [
+        'node1',
+        'node2',
+        'node3',
+      ])
+      assert.deepStrictEqual(missing, ['node2', 'node3'])
+    })
+
+    test('should get node results', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      const step1 = await service.insertStepState(runId, 'node1', null, {})
+      await service.setStepResult(step1.stepId, { value: 42 })
+      await service.insertStepState(runId, 'node2', null, {})
+
+      const results = await service.getNodeResults(runId, ['node1', 'node2'])
+      assert.deepStrictEqual(results, { node1: { value: 42 } })
+    })
+  })
+
+  describe('branch keys', () => {
+    test('should set and track branch keys', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      const step = await service.insertStepState(runId, 'branch-node', null, {})
+      await service.setBranchKey(runId, 'branch-node', 'left')
+
+      const state = await service.getCompletedGraphState(runId)
+      assert.strictEqual(state.branchKeys['branch-node'], 'left')
+    })
+
+    test('should set branch taken by stepId', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      const step = await service.insertStepState(runId, 'node1', null, {})
+      await service.setBranchTaken(step.stepId, 'right')
+
+      const state = await service.getCompletedGraphState(runId)
+      assert.strictEqual(state.branchKeys['node1'], 'right')
+    })
+  })
+
+  describe('workflow versions', () => {
+    test('should upsert and get workflow version', async () => {
+      const graph = { nodes: ['a', 'b'] }
+      await service.upsertWorkflowVersion('myWf', 'hash1', graph, 'source-code')
+
+      const version = await service.getWorkflowVersion('myWf', 'hash1')
+      assert.deepStrictEqual(version, { graph, source: 'source-code' })
+    })
+
+    test('should return null for non-existent version', async () => {
+      const version = await service.getWorkflowVersion('unknown', 'unknown')
+      assert.strictEqual(version, null)
+    })
+  })
+
+  describe('locking', () => {
+    test('withRunLock should execute function directly', async () => {
+      const result = await service.withRunLock('run1', async () => 'result')
+      assert.strictEqual(result, 'result')
+    })
+
+    test('withStepLock should execute function directly', async () => {
+      const result = await service.withStepLock('run1', 'step1', async () => 42)
+      assert.strictEqual(result, 42)
+    })
+  })
+
+  describe('close', () => {
+    test('should clear all internal state', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      await service.insertStepState(runId, 'step1', null, {})
+      await service.updateRunState(runId, 'key', 'val')
+      await service.upsertWorkflowVersion('wf', 'h', {}, 'src')
+
+      await service.close()
+
+      assert.strictEqual(await service.getRun(runId), null)
+      const history = await service.getRunHistory(runId)
+      assert.deepStrictEqual(history, [])
+      const state = await service.getRunState(runId)
+      assert.deepStrictEqual(state, {})
+      const version = await service.getWorkflowVersion('wf', 'h')
+      assert.strictEqual(version, null)
+    })
+  })
+
+  describe('run history', () => {
+    test('should track step insertions in history', async () => {
+      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
+      await service.insertStepState(runId, 'step1', null, {})
+      await service.insertStepState(runId, 'step2', null, {})
+
+      const history = await service.getRunHistory(runId)
+      assert.strictEqual(history.length, 2)
+      assert.strictEqual(history[0].stepName, 'step1')
+      assert.strictEqual(history[1].stepName, 'step2')
+    })
+
+    test('should return empty array for non-existent run', async () => {
+      const history = await service.getRunHistory('non-existent')
+      assert.deepStrictEqual(history, [])
+    })
+  })
+})