@pikku/core 0.12.107 → 0.12.111

package/src/services/file-scenario-run-store.ts

@@ -1,282 +0,0 @@
-import { mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
-import type {
-  ScenarioArtifact,
-  ScenarioResult,
-  ScenarioRunRecord,
-  ScenarioRunStore,
-  ScenarioRunSummary,
-} from '../wirings/workflow/scenario-run.types.js'
-
-/** The record, beside the images and footage the same run produced. */
-const RECORD_FILE = 'run.json'
-
-/**
- * A run id is a path segment, and `get('../../etc')` is a file read.
- *
- * Ids are generated here, so anything failing this arrived from outside and is
- * refused rather than sanitised — a request for a run that cannot exist is a
- * request for a run that does not exist.
- */
-const SAFE_RUN_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/
-
-/** Counts and duration, derived rather than stored so they cannot disagree. */
-export const scenarioRunSummary = (
-  record: ScenarioRunRecord
-): ScenarioRunSummary => ({
-  runId: record.runId,
-  environment: record.environment,
-  surface: record.surface,
-  status: record.status,
-  startedAt: record.startedAt,
-  finishedAt: record.finishedAt,
-  durationMs: record.finishedAt
-    ? new Date(record.finishedAt).getTime() -
-      new Date(record.startedAt).getTime()
-    : undefined,
-  passed: record.results.filter((r) => r.status === 'passed').length,
-  failed: record.results.filter((r) => r.status === 'failed').length,
-  skipped: record.skipped.length,
-  artifacts: record.results.reduce(
-    (total, result) => total + (result.artifacts?.length ?? 0),
-    0
-  ),
-})
-
-/**
- * What a scenario artifact is served as.
- *
- * A short, closed list rather than a MIME database: a run produces images and
- * recordings and nothing else, and anything unrecognised is served as bytes the
- * browser is told not to interpret.
- */
-const CONTENT_TYPES: Record<string, string> = {
-  png: 'image/png',
-  jpg: 'image/jpeg',
-  jpeg: 'image/jpeg',
-  webp: 'image/webp',
-  mp4: 'video/mp4',
-  webm: 'video/webm',
-}
-
-export const scenarioArtifactContentType = (path: string): string =>
-  CONTENT_TYPES[path.split('.').pop()?.toLowerCase() ?? ''] ??
-  'application/octet-stream'
-
-/**
- * An artifact path is a content key from the record, but it arrives from a
- * client and is joined onto a directory. Anything that could climb out of the
- * run, or name something other than a file inside it, is refused.
- */
-const SAFE_ARTIFACT_PATH =
-  /^[A-Za-z0-9][A-Za-z0-9._-]*(\/[A-Za-z0-9][A-Za-z0-9._-]*)*$/
-
-export interface FileScenarioRunStoreOptions {
-  /** The directory runs live under — one folder per run, named by its id. */
-  dir: string
-  /**
-   * How many runs to keep. Older ones are deleted, with their artifacts, as a
-   * new run opens.
-   *
-   * Bounded on purpose: a run with video is megabytes, and an unbounded history
-   * beside a project is a directory nobody notices until it is enormous.
-   */
-  keep?: number
-}
-
-const DEFAULT_KEEP = 20
-
-/**
- * Scenario run history as files on disk — the OSS store.
- *
- * One folder per run holding its record and everything it filed, which makes a
- * run a thing you can open, copy, attach to an issue or delete with `rm -rf`.
- * A hosted project swaps this for a table and an object store; the console
- * reads the same shapes from either.
- *
- * Writes are serialised through one chain. Scenarios finish one at a time, but
- * `recordScenario` is read-modify-write on a single file, and a store that
- * corrupts its own history the first time two things overlap is worse than no
- * history.
- */
-export class FileScenarioRunStore implements ScenarioRunStore {
-  private writes: Promise<unknown> = Promise.resolve()
-
-  constructor(private readonly options: FileScenarioRunStoreOptions) {}
-
-  async start(record: ScenarioRunRecord): Promise<void> {
-    await this.serialise(async () => {
-      await this.write(record)
-      await this.prune(record.runId)
-    })
-  }
-
-  async recordScenario(runId: string, result: ScenarioResult): Promise<void> {
-    await this.serialise(async () => {
-      const record = await this.read(runId)
-      if (!record) {
-        return
-      }
-      record.results.push(result)
-      await this.write(record)
-    })
-  }
-
-  async attachArtifacts(
-    runId: string,
-    artifacts: ScenarioArtifact[]
-  ): Promise<void> {
-    if (artifacts.length === 0) {
-      return
-    }
-    await this.serialise(async () => {
-      const record = await this.read(runId)
-      if (!record) {
-        return
-      }
-      for (const artifact of artifacts) {
-        const result = record.results.find(
-          (candidate) => candidate.name === artifact.scenario
-        )
-        // An artifact whose scenario is not in the results belongs to a
-        // scenario that never produced one — it is dropped rather than filed
-        // under a run-level bucket nothing renders.
-        if (result) {
-          result.artifacts = [...(result.artifacts ?? []), artifact]
-        }
-      }
-      await this.write(record)
-    })
-  }
-
-  async finish(
-    runId: string,
-    outcome: Pick<
-      ScenarioRunRecord,
-      'status' | 'finishedAt' | 'skipped' | 'hookFailures'
-    >
-  ): Promise<void> {
-    await this.serialise(async () => {
-      const record = await this.read(runId)
-      if (!record) {
-        return
-      }
-      await this.write({ ...record, ...outcome })
-    })
-  }
-
-  async readArtifact(
-    runId: string,
-    path: string
-  ): Promise<
-    { body: Uint8Array<ArrayBuffer>; contentType: string } | undefined
-  > {
-    if (!SAFE_RUN_ID.test(runId) || !SAFE_ARTIFACT_PATH.test(path)) {
-      return undefined
-    }
-    try {
-      const file = await readFile(
-        join(this.options.dir, runId, ...path.split('/'))
-      )
-      return {
-        body: new Uint8Array(file),
-        contentType: scenarioArtifactContentType(path),
-      }
-    } catch {
-      return undefined
-    }
-  }
-
-  async list(options: { limit?: number } = {}): Promise<ScenarioRunSummary[]> {
-    const summaries: ScenarioRunSummary[] = []
-    for (const runId of await this.runIds()) {
-      const record = await this.read(runId)
-      if (record) {
-        summaries.push(scenarioRunSummary(record))
-      }
-    }
-    summaries.sort((a, b) => b.startedAt.localeCompare(a.startedAt))
-    return options.limit ? summaries.slice(0, options.limit) : summaries
-  }
-
-  async get(runId: string): Promise<ScenarioRunRecord | undefined> {
-    return this.read(runId)
-  }
-
-  async remove(runId: string): Promise<void> {
-    if (!SAFE_RUN_ID.test(runId)) {
-      return
-    }
-    await rm(join(this.options.dir, runId), { recursive: true, force: true })
-  }
-
-  /** Where this run's artifacts live, for a driver writing into it. */
-  runDir(runId: string): string {
-    return join(this.options.dir, runId)
-  }
-
-  private serialise<T>(work: () => Promise<T>): Promise<T> {
-    const next = this.writes.then(work, work)
-    // Swallowed on the CHAIN only, so one failed write does not reject every
-    // later one; the caller still sees its own rejection through `next`.
-    this.writes = next.catch(() => {})
-    return next
-  }
-
-  private async read(runId: string): Promise<ScenarioRunRecord | undefined> {
-    if (!SAFE_RUN_ID.test(runId)) {
-      return undefined
-    }
-    try {
-      const raw = await readFile(
-        join(this.options.dir, runId, RECORD_FILE),
-        'utf-8'
-      )
-      return JSON.parse(raw) as ScenarioRunRecord
-    } catch {
-      // A folder with artifacts but no readable record is a run that was killed
-      // mid-write. It is not listable, and it is not an error either.
-      return undefined
-    }
-  }
-
-  private async write(record: ScenarioRunRecord): Promise<void> {
-    const dir = join(this.options.dir, record.runId)
-    await mkdir(dir, { recursive: true })
-    await writeFile(
-      join(dir, RECORD_FILE),
-      JSON.stringify(record, null, 2) + '\n'
-    )
-  }
-
-  private async runIds(): Promise<string[]> {
-    try {
-      const entries = await readdir(this.options.dir, { withFileTypes: true })
-      return entries
-        .filter((entry) => entry.isDirectory() && SAFE_RUN_ID.test(entry.name))
-        .map((entry) => entry.name)
-    } catch {
-      return []
-    }
-  }
-
-  /**
-   * Drop the oldest runs past the limit, never the one just opened — a `keep`
-   * of zero or one must still leave the run being started.
-   */
-  private async prune(keeping: string): Promise<void> {
-    const keep = this.options.keep ?? DEFAULT_KEEP
-    const dated: Array<{ runId: string; startedAt: string }> = []
-    for (const runId of await this.runIds()) {
-      if (runId === keeping) {
-        continue
-      }
-      const record = await this.read(runId)
-      dated.push({ runId, startedAt: record?.startedAt ?? '' })
-    }
-    dated.sort((a, b) => b.startedAt.localeCompare(a.startedAt))
-    for (const { runId } of dated.slice(Math.max(keep - 1, 0))) {
-      await rm(join(this.options.dir, runId), { recursive: true, force: true })
-    }
-  }
-}

package/src/services/gateway-service.ts

@@ -1,5 +0,0 @@
-export interface GatewayService {
-  start(): Promise<void>
-
-  stop(): Promise<void>
-}

package/src/services/http-personas-converse.test.ts

@@ -1,274 +0,0 @@
-import { describe, test, after } from 'node:test'
-import assert from 'node:assert/strict'
-import { createServer, type Server } from 'node:http'
-
-import { createHttpPersonas } from './http-personas.js'
-import { pikkuState, resetPikkuState } from '../pikku-state.js'
-import type { AgentStepResult } from './agent-runner-service.js'
-
-/**
- * Minimal target app exposing the agent HTTP surface: actor sign-in, the agent
- * run route (suspends once for approval, then completes), and the batch approve
- * route (records the decisions). `authRequired` toggles whether the agent
- * routes reject unauthenticated calls with 401 (to exercise lazy sign-in).
- */
-const startAgentTarget = async () => {
-  let agentRuns = 0
-  let logins = 0
-  let authRequired = false
-  let approvalsSeen: unknown[] = []
-  let firstAgentRequestAuthed: boolean | null = null
-  const server: Server = createServer((req, res) => {
-    const chunks: Buffer[] = []
-    req.on('data', (c) => chunks.push(c))
-    req.on('end', () => {
-      const body = chunks.length
-        ? JSON.parse(Buffer.concat(chunks).toString())
-        : {}
-      const json = (obj: unknown) =>
-        res
-          .writeHead(200, { 'content-type': 'application/json' })
-          .end(JSON.stringify(obj))
-
-      if (req.url === '/api/auth/sign-in/actor') {
-        logins++
-        res.setHeader('set-cookie', ['session=s1; Path=/; HttpOnly'])
-        json({ ok: true })
-        return
-      }
-
-      const isAgentRoute = req.url?.startsWith('/api/rpc/agent/')
-      if (isAgentRoute && firstAgentRequestAuthed === null) {
-        firstAgentRequestAuthed = (req.headers.cookie ?? '').includes(
-          'session='
-        )
-      }
-      if (
-        isAgentRoute &&
-        authRequired &&
-        !(req.headers.cookie ?? '').includes('session=')
-      ) {
-        res.writeHead(401).end()
-        return
-      }
-
-      if (req.url === '/api/rpc/agent/todoBot/approve') {
-        approvalsSeen.push(body.approvals)
-        json({ runId: body.runId, text: 'Created it.', status: 'completed' })
-        return
-      }
-      // The SSE route, because that is the one a persona's turn goes to — the
-      // plain route buffers the whole run and dies on undici's headers timeout.
-      if (req.url === '/api/rpc/agent/todoBot/stream') {
-        agentRuns++
-        const runId = `run-${agentRuns}`
-        const events: unknown[] =
-          agentRuns === 1
-            ? [
-                { type: 'RUN_STARTED', runId },
-                { type: 'TEXT_MESSAGE_CONTENT', delta: 'Let me ' },
-                { type: 'TEXT_MESSAGE_CONTENT', delta: 'do that.' },
-                {
-                  type: 'approval-request',
-                  runId,
-                  toolCallId: 'tc1',
-                  toolName: 'createTodo',
-                  args: { title: 'x' },
-                },
-                { type: 'done' },
-              ]
-            : [
-                { type: 'RUN_STARTED', runId },
-                { type: 'TEXT_MESSAGE_CONTENT', delta: 'All set.' },
-                { type: 'RUN_FINISHED', runId },
-                { type: 'done' },
-              ]
-        res.writeHead(200, { 'content-type': 'text/event-stream' })
-        for (const event of events) {
-          res.write(`data: ${JSON.stringify(event)}\n\n`)
-        }
-        res.end()
-        return
-      }
-      res.writeHead(404).end()
-    })
-  })
-  await new Promise<void>((resolve) => server.listen(0, resolve))
-  const { port } = server.address() as { port: number }
-  return {
-    server,
-    apiUrl: `http://127.0.0.1:${port}/api`,
-    loginCount: () => logins,
-    approvalsSeen: () => approvalsSeen,
-    /** Whether the very first agent call carried a session, not merely that one was minted. */
-    firstAgentRequestAuthed: () => firstAgentRequestAuthed,
-    reset: (opts?: { authRequired?: boolean }) => {
-      agentRuns = 0
-      logins = 0
-      approvalsSeen = []
-      firstAgentRequestAuthed = null
-      authRequired = opts?.authRequired ?? false
-    },
-  }
-}
-
-/** Persona LLM scripted by the outputSchema it's asked for. */
-const scriptedRunner = () => {
-  let turn = 0
-  const turns = [
-    { message: 'please make a todo', done: false },
-    { message: 'thanks', done: true },
-  ]
-  return {
-    run: async (params: {
-      outputSchema?: unknown
-    }): Promise<AgentStepResult> => {
-      const props =
-        (params.outputSchema as { properties?: Record<string, unknown> })
-          ?.properties ?? {}
-      const object =
-        'message' in props
-          ? (turns[turn++] ?? turns[turns.length - 1])
-          : 'decisions' in props
-            ? { decisions: [{ toolCallId: 'tc1', approved: true }] }
-            : { passed: true, reasoning: 'a todo was created' }
-      return {
-        text: '',
-        object,
-        toolCalls: [],
-        toolResults: [],
-        usage: { inputTokens: 0, outputTokens: 0 },
-        finishReason: 'stop',
-      }
-    },
-  }
-}
-
-const wireRunner = () => {
-  resetPikkuState()
-  pikkuState(null, 'package', 'singletonServices', {
-    logger: {
-      info: () => {},
-      warn: () => {},
-      error: () => {},
-      debug: () => {},
-    },
-    agentRunner: scriptedRunner(),
-  } as any)
-}
-
-describe('HttpPersona.converse', async () => {
-  const target = await startAgentTarget()
-  after(() => {
-    target.server.close()
-    resetPikkuState()
-  })
-
-  test('converses over HTTP, approves in-persona, returns a verdict', async () => {
-    wireRunner()
-    target.reset()
-
-    const actors = createHttpPersonas({
-      apiUrl: target.apiUrl,
-      secret: 'impersonation-secret-impersonation',
-      model: 'test/test-model',
-      personas: {
-        pm: {
-          id: 'pm',
-          name: 'Priya',
-          email: 'pm@personas.invalid',
-          personality: 'concise',
-          roles: [],
-          goals: [],
-          tags: [],
-          runnable: true,
-        },
-      },
-    })
-
-    const verdict = await actors.pm!.converse({
-      agent: 'todoBot',
-      task: 'Get a todo created for the launch',
-      evaluate: 'A todo about the launch now exists',
-    })
-
-    assert.equal(verdict.passed, true)
-    assert.match(verdict.reasoning, /todo/i)
-    // The target's approval was answered in-persona (approved) over HTTP.
-    assert.deepEqual(target.approvalsSeen(), [
-      [{ toolCallId: 'tc1', approved: true }],
-    ])
-    // Signed in even though the agent route is public: a thread minted under a
-    // fresh anonymous id per request belongs to nobody, so turn two comes back
-    // as somebody else's. A persona is a real account either way — and it is
-    // the *first* call that has to carry the session, which a login count
-    // alone would not show.
-    assert.equal(target.loginCount(), 1)
-    assert.equal(target.firstAgentRequestAuthed(), true)
-  })
-
-  test('signs in lazily and retries once when an agent route returns 401', async () => {
-    wireRunner()
-    target.reset({ authRequired: true })
-
-    const actors = createHttpPersonas({
-      apiUrl: target.apiUrl,
-      secret: 'impersonation-secret-impersonation',
-      model: 'test/test-model',
-      personas: {
-        pm: {
-          id: 'pm',
-          name: 'Priya',
-          email: 'pm@personas.invalid',
-          roles: [],
-          goals: [],
-          tags: [],
-          runnable: true,
-        },
-      },
-    })
-
-    const verdict = await actors.pm!.converse({
-      agent: 'todoBot',
-      task: 'make a todo',
-      evaluate: 'a todo exists',
-    })
-
-    assert.equal(verdict.passed, true)
-    // 401 on the first (unauthenticated) call → one sign-in, then cached.
-    assert.equal(target.loginCount(), 1)
-  })
-
-  test('throws when no AI provider is configured', async () => {
-    resetPikkuState()
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: {
-        info: () => {},
-        warn: () => {},
-        error: () => {},
-        debug: () => {},
-      },
-    } as any)
-
-    const actors = createHttpPersonas({
-      apiUrl: target.apiUrl,
-      secret: 'impersonation-secret-impersonation',
-      model: 'test/test-model',
-      personas: {
-        pm: {
-          id: 'pm',
-          name: 'Priya',
-          email: 'pm@personas.invalid',
-          roles: [],
-          goals: [],
-          tags: [],
-          runnable: true,
-        },
-      },
-    })
-
-    await assert.rejects(
-      actors.pm!.converse({ agent: 'todoBot', task: 't', evaluate: 'e' })
-    )
-  })
-})