@studio-foundation/api 0.3.0-beta.1 → 0.3.0-beta.6

package/src/integration-store.ts

@@ -1,125 +0,0 @@
-// IntegrationStore — generic SQLite persistence for integration configs and trigger logs
-// Partitioned by integration_name — supports any integration (linear, slack, github, etc.)
-// Uses the same DB file as the run store (.studio/runs/runs.db)
-
-import { createRequire } from 'node:module';
-
-export interface IntegrationConfig {
-  pipeline?: string;
-  active: boolean;
-}
-
-export interface IntegrationTriggerRecord {
-  id: string;
-  integration_name: string;
-  received_at: string;
-  external_id?: string;
-  external_label?: string;
-  external_url?: string;
-  pipeline: string;
-  run_id?: string;
-  status: 'success' | 'failed';
-}
-
-export class IntegrationStore {
-  private db: import('better-sqlite3').Database;
-
-  constructor(dbPath: string) {
-    const _require = createRequire(import.meta.url);
-    const Database = _require('better-sqlite3') as new (path: string) => import('better-sqlite3').Database;
-    this.db = new Database(dbPath);
-    this.db.pragma('journal_mode = WAL');
-    this.initSchema();
-  }
-
-  private initSchema(): void {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS integration_config (
-        integration_name TEXT NOT NULL,
-        pipeline TEXT,
-        active INTEGER NOT NULL DEFAULT 0,
-        PRIMARY KEY (integration_name)
-      );
-
-      CREATE TABLE IF NOT EXISTS integration_triggers (
-        id TEXT PRIMARY KEY,
-        integration_name TEXT NOT NULL,
-        received_at TEXT NOT NULL,
-        external_id TEXT,
-        external_label TEXT,
-        external_url TEXT,
-        pipeline TEXT NOT NULL,
-        run_id TEXT,
-        status TEXT NOT NULL
-      );
-    `);
-  }
-
-  getConfig(integrationName: string): IntegrationConfig {
-    const row = this.db.prepare(
-      'SELECT pipeline, active FROM integration_config WHERE integration_name = ?'
-    ).get(integrationName) as { pipeline: string | null; active: number } | undefined;
-
-    if (!row) return { active: false };
-    return {
-      ...(row.pipeline != null ? { pipeline: row.pipeline } : {}),
-      active: row.active === 1,
-    };
-  }
-
-  patchConfig(integrationName: string, data: Partial<IntegrationConfig>): void {
-    const current = this.getConfig(integrationName);
-    const pipeline = 'pipeline' in data ? (data.pipeline ?? null) : (current.pipeline ?? null);
-    const active = 'active' in data ? (data.active ? 1 : 0) : (current.active ? 1 : 0);
-    this.db.prepare(`
-      INSERT INTO integration_config (integration_name, pipeline, active) VALUES (?, ?, ?)
-      ON CONFLICT(integration_name) DO UPDATE SET pipeline = excluded.pipeline, active = excluded.active
-    `).run(integrationName, pipeline, active);
-  }
-
-  insertTrigger(trigger: IntegrationTriggerRecord): void {
-    this.db.prepare(`
-      INSERT INTO integration_triggers
-        (id, integration_name, received_at, external_id, external_label, external_url, pipeline, run_id, status)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      trigger.id,
-      trigger.integration_name,
-      trigger.received_at,
-      trigger.external_id ?? null,
-      trigger.external_label ?? null,
-      trigger.external_url ?? null,
-      trigger.pipeline,
-      trigger.run_id ?? null,
-      trigger.status,
-    );
-  }
-
-  listTriggers(integrationName: string, limit = 50): IntegrationTriggerRecord[] {
-    type Row = {
-      id: string; integration_name: string; received_at: string;
-      external_id: string | null; external_label: string | null; external_url: string | null;
-      pipeline: string; run_id: string | null; status: string;
-    };
-    const rows = this.db.prepare(
-      `SELECT id, integration_name, received_at, external_id, external_label, external_url, pipeline, run_id, status
-       FROM integration_triggers WHERE integration_name = ? ORDER BY received_at DESC LIMIT ?`
-    ).all(integrationName, limit) as Row[];
-
-    return rows.map(row => ({
-      id: row.id,
-      integration_name: row.integration_name,
-      received_at: row.received_at,
-      ...(row.external_id != null ? { external_id: row.external_id } : {}),
-      ...(row.external_label != null ? { external_label: row.external_label } : {}),
-      ...(row.external_url != null ? { external_url: row.external_url } : {}),
-      pipeline: row.pipeline,
-      ...(row.run_id != null ? { run_id: row.run_id } : {}),
-      status: row.status as 'success' | 'failed',
-    }));
-  }
-
-  close(): void {
-    this.db.close();
-  }
-}

package/src/integrations/linear/failure-handler.ts

@@ -1,93 +0,0 @@
-// api/src/integrations/linear/failure-handler.ts
-import type { FailureHandler, FailureHandlerContext } from '../types.js';
-
-const LINEAR_GRAPHQL_URL = 'https://api.linear.app/graphql';
-
-async function gql(query: string, variables: Record<string, unknown>, apiKey: string): Promise<Record<string, unknown>> {
-  const res = await fetch(LINEAR_GRAPHQL_URL, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', Authorization: apiKey },
-    body: JSON.stringify({ query, variables }),
-  });
-  if (!res.ok) throw new Error(`Linear GraphQL HTTP error: ${res.status} ${res.statusText}`);
-  return res.json() as Promise<Record<string, unknown>>;
-}
-
-function buildFailureComment(ctx: FailureHandlerContext): string {
-  const iterations = ctx.lastGroupFeedback?.iteration;
-  const iterLabel = iterations != null ? ` après ${iterations} itérations QA` : '';
-  const rejectionReason = ctx.lastGroupFeedback?.rejection_reason;
-  const rejectionDetails = ctx.lastGroupFeedback?.rejection_details;
-  const lines: string[] = [];
-  lines.push(`❌ **Code Builder échoué** —${iterLabel ? ` QA a rejeté${iterLabel}` : ' pipeline échoué'}`);
-  lines.push('');
-  if (rejectionReason) {
-    lines.push('**Dernière raison de rejet :**');
-    if (rejectionDetails && rejectionDetails.length > 0) {
-      for (const detail of rejectionDetails) lines.push(`- ${detail}`);
-    } else {
-      lines.push(`- ${rejectionReason}`);
-    }
-    lines.push('');
-  }
-  lines.push('**Action requise :** réviser le brief ou augmenter max_iterations');
-  lines.push('');
-  lines.push(`**Run ID :** ${ctx.runId}`);
-  return lines.join('\n');
-}
-
-export class LinearFailureHandler implements FailureHandler {
-  async handleFailure(ctx: FailureHandlerContext): Promise<void> {
-    const issueId = typeof ctx.meta['linear_issue_id'] === 'string' ? ctx.meta['linear_issue_id'] : undefined;
-    if (!issueId) return;
-
-    const apiKey = (ctx.integrationConfig['LINEAR_API_KEY'] as string | undefined)
-      ?? process.env['LINEAR_API_KEY'];
-    if (!apiKey) {
-      console.warn('[linear-failure-handler] LINEAR_API_KEY not set — skipping failure notification');
-      return;
-    }
-
-    const comment = buildFailureComment(ctx);
-    try {
-      await gql(
-        `mutation CreateComment($issueId: String!, $body: String!) {
-          commentCreate(input: { issueId: $issueId, body: $body }) { success }
-        }`,
-        { issueId, body: comment },
-        apiKey,
-      );
-
-      const statesResult = await gql(
-        `query GetWorkflowStates($issueId: String!) {
-          issue(id: $issueId) { team { states { nodes { id name } } } }
-        }`,
-        { issueId },
-        apiKey,
-      );
-
-      type StateNode = { id: string; name: string };
-      const nodes = (
-        (statesResult as { data?: { issue?: { team?: { states?: { nodes?: StateNode[] } } } } })
-          .data?.issue?.team?.states?.nodes
-      ) ?? [];
-      const backlogState = nodes.find((s: StateNode) => s.name === 'Backlog');
-
-      if (backlogState) {
-        await gql(
-          `mutation UpdateIssue($id: String!, $stateId: String!) {
-            issueUpdate(id: $id, input: { stateId: $stateId }) { success }
-          }`,
-          { id: issueId, stateId: backlogState.id },
-          apiKey,
-        );
-      } else {
-        console.warn(`[linear-failure-handler] "Backlog" state not found for issue ${issueId} — status not updated`);
-      }
-
-      console.log(`[linear-failure-handler] Failure notification posted for issue ${issueId}`);
-    } catch (err) {
-      console.error('[linear-failure-handler] Failed to notify Linear:', err);
-    }
-  }
-}

package/src/integrations/linear/webhook-handler.ts

@@ -1,156 +0,0 @@
-// LinearWebhookHandler — plugin class implementing WebhookHandler
-// Extracted from routes/linear-webhook.ts POST /integrations/linear/webhook
-// Receives all deps via WebhookHandlerContext instead of Fastify plugin closure.
-
-import { createHmac, timingSafeEqual, randomUUID } from 'node:crypto';
-import { join } from 'node:path';
-import type { FastifyReply } from 'fastify';
-import type { WebhookHandler, WebhookHandlerContext } from '../types.js';
-import { loadPipelineByName } from '@studio-foundation/engine';
-import { resolveRepoPath } from '../../utils/repo-resolver.js';
-
-interface LinearIssuePayload {
-  type?: string;
-  action?: string;
-  data?: {
-    id?: string;
-    identifier?: string;
-    title?: string;
-    description?: string;
-    state?: { name?: string };
-  };
-}
-
-function verifyHmac(rawBody: Buffer, signature: string, secret: string): boolean {
-  const computed = createHmac('sha256', secret).update(rawBody).digest('hex');
-  try {
-    const a = Buffer.from(computed, 'hex');
-    const b = Buffer.from(signature, 'hex');
-    if (a.length !== b.length) return false;
-    return timingSafeEqual(a, b);
-  } catch {
-    return false;
-  }
-}
-
-export class LinearWebhookHandler implements WebhookHandler {
-  async handle(ctx: WebhookHandlerContext, reply: FastifyReply): Promise<unknown> {
-    const { rawBody, headers, integration, store, launcher, configsDir, projectsDir, integrationConfig } = ctx;
-
-    // HMAC verification — only when hmac config is present in the integration def
-    const hmacConfig = integration.webhook?.hmac;
-    if (hmacConfig) {
-      const secret = integrationConfig[hmacConfig.secret_env] as string | undefined;
-      if (secret) {
-        const sig = headers[hmacConfig.header];
-        if (typeof sig !== 'string') {
-          return reply.status(401).send({ error: `Missing ${hmacConfig.header} header` });
-        }
-        if (!verifyHmac(rawBody, sig, secret)) {
-          return reply.status(401).send({ error: 'Invalid signature' });
-        }
-      }
-    }
-
-    let payload: LinearIssuePayload;
-    try {
-      payload = JSON.parse(rawBody.toString('utf-8')) as LinearIssuePayload;
-    } catch {
-      return reply.status(400).send({ error: 'Invalid JSON' });
-    }
-
-    // Only handle Issue update events
-    if (payload.type !== 'Issue' || payload.action !== 'update') {
-      return reply.status(200).send({ ignored: true, reason: 'not an issue update' });
-    }
-
-    const issue = payload.data ?? {};
-
-    // Only trigger on transitions to "In Progress"
-    if (issue.state?.name !== 'In Progress') {
-      return reply.status(200).send({ ignored: true, reason: `state is "${issue.state?.name ?? 'unknown'}"` });
-    }
-
-    // Check integration is active
-    const config = store.getConfig(integration.name);
-    if (!config.active) {
-      return reply.status(200).send({ ignored: true, reason: 'integration is inactive' });
-    }
-
-    const pipeline = config.pipeline ?? 'feature-builder';
-    const issueUrl = `https://linear.app/studioag/issue/${issue.identifier}`;
-
-    // Resolve repo path from pipeline YAML — mirrors CLI behaviour.
-    // If the pipeline file can't be loaded, fall back gracefully —
-    // launcher.launch() will surface the proper "pipeline not found" error afterwards.
-    let pipelineRepoUrl: string | undefined;
-    let pipelineRepoBranch: string | undefined;
-    try {
-      const pipelineDef = await loadPipelineByName(pipeline, join(configsDir, 'pipelines'));
-      pipelineRepoUrl = pipelineDef.repo?.url;
-      pipelineRepoBranch = pipelineDef.repo?.branch;
-    } catch {
-      // Pipeline not found or unparseable — launcher.launch() will handle the error
-    }
-
-    let repoPath: string;
-    try {
-      repoPath = await resolveRepoPath({
-        repoUrl: pipelineRepoUrl,
-        rawProjectsDir: projectsDir,
-        pipelineName: pipeline,
-        branch: pipelineRepoBranch,
-      });
-    } catch (err) {
-      return reply.status(400).send({ error: err instanceof Error ? err.message : String(err) });
-    }
-
-    // Construct structured input for the configured pipeline
-    const input: Record<string, unknown> = {
-      brief_summary: [issue.identifier, issue.title].filter(Boolean).join(' — '),
-      description: issue.description ?? '',
-      acceptance_criteria: [],
-    };
-
-    const meta: Record<string, unknown> = {
-      linear_issue_id: issue.id,
-      linear_issue_identifier: issue.identifier,
-      linear_issue_url: issueUrl,
-    };
-
-    const runId = randomUUID();
-    const triggerId = randomUUID();
-    const receivedAt = new Date().toISOString();
-
-    try {
-      await launcher.launch({ runId, pipeline, input, configsDir, repoPath, meta });
-
-      store.insertTrigger({
-        id: triggerId,
-        integration_name: integration.name,
-        received_at: receivedAt,
-        external_id: issue.id,
-        external_label: [issue.identifier, issue.title].filter(Boolean).join(' — '),
-        external_url: issueUrl,
-        pipeline,
-        run_id: runId,
-        status: 'success',
-      });
-    } catch (err) {
-      store.insertTrigger({
-        id: triggerId,
-        integration_name: integration.name,
-        received_at: receivedAt,
-        external_id: issue.id,
-        external_label: [issue.identifier, issue.title].filter(Boolean).join(' — '),
-        external_url: issueUrl,
-        pipeline,
-        run_id: runId,
-        status: 'failed',
-      });
-      throw err;
-    }
-
-    return reply.status(202).send({ run_id: runId, stream_url: `/api/runs/${runId}/stream` });
-  }
-}

package/src/integrations/registry.ts

@@ -1,12 +0,0 @@
-// api/src/integrations/registry.ts
-import type { WebhookHandler, FailureHandler } from './types.js';
-import { LinearWebhookHandler } from './linear/webhook-handler.js';
-import { LinearFailureHandler } from './linear/failure-handler.js';
-
-export const WEBHOOK_HANDLERS: Record<string, WebhookHandler> = {
-  'linear-webhook': new LinearWebhookHandler(),
-};
-
-export const FAILURE_HANDLERS: Record<string, FailureHandler> = {
-  'linear-failure': new LinearFailureHandler(),
-};

package/src/integrations/types.ts

@@ -1,37 +0,0 @@
-// api/src/integrations/types.ts
-import type { FastifyReply } from 'fastify';
-import type { IntegrationPluginDef } from '@studio-foundation/contracts';
-import type { GroupFeedbackEvent } from '@studio-foundation/engine';
-import type { IntegrationStore } from '../integration-store.js';
-import type { RunLauncher } from '../launcher.js';
-import type { ApiConfig } from '../server.js';
-
-export interface WebhookHandlerContext {
-  rawBody: Buffer;
-  headers: Record<string, string | string[] | undefined>;
-  integration: IntegrationPluginDef;
-  store: IntegrationStore;
-  launcher: RunLauncher;
-  configsDir: string;
-  projectsDir?: string;
-  apiConfig: ApiConfig;
-  integrationConfig: Record<string, unknown>;
-}
-
-export interface FailureHandlerContext {
-  runId: string;
-  durationMs: number;
-  status: string;
-  meta: Record<string, unknown>;
-  lastGroupFeedback?: GroupFeedbackEvent;
-  integration: IntegrationPluginDef;
-  integrationConfig: Record<string, unknown>;
-}
-
-export interface WebhookHandler {
-  handle(ctx: WebhookHandlerContext, reply: FastifyReply): Promise<unknown>;
-}
-
-export interface FailureHandler {
-  handleFailure(ctx: FailureHandlerContext): Promise<void>;
-}

package/src/launcher.ts

@@ -1,214 +0,0 @@
-// Run launcher — interface + InProcessLauncher implementation
-// InProcessLauncher creates a new PipelineEngine per run for event isolation.
-// Future: BullMQLauncher, etc.
-
-import type { PipelineRun } from '@studio-foundation/contracts';
-import type {
-  EngineConfig,
-  EngineEvents,
-  AnyRunStore,
-  PipelineStartEvent,
-  StageStartEvent,
-  StageCompleteEvent,
-  StageRetryEvent,
-  StageContextEvent,
-  GroupStartEvent,
-  GroupIterationEvent,
-  GroupFeedbackEvent,
-  GroupCompleteEvent,
-  PipelineCompleteEvent,
-  PipelineCancelledEvent,
-  StagedToolCallStartEvent,
-  StagedToolCallCompleteEvent,
-} from '@studio-foundation/engine';
-import { PipelineEngine } from '@studio-foundation/engine';
-import { loadProjectTools } from '@studio-foundation/runner';
-import { join } from 'node:path';
-import { createApiLogger } from './logger.js';
-import type { RunEventBus, BusListener, SseEventType } from './event-bus.js';
-import type { AnyUserStore } from './user-store-pg.js';
-import { getPlanLimits, DEFAULT_PLANS, type PlansConfig } from './plans.js';
-
-export interface LaunchConfig {
-  runId: string;
-  pipeline: string;
-  input: Record<string, unknown>;
-  configsDir: string;
-  /** Pre-resolved repo path (cloned or local). Overrides engineConfig.repoPath for this run. */
-  repoPath?: string;
-  providerOverride?: string;
-  depth?: number;
-  parentRunId?: string;
-  meta?: Record<string, unknown>;
-  userId?: string;
-}
-
-export type EngineFactory = (
-  config: EngineConfig,
-  events: EngineEvents,
-) => Pick<PipelineEngine, 'run'>;
-
-export interface RunLauncher {
-  launch(config: LaunchConfig): Promise<{ run_id: string }>;
-  cancel(run_id: string): Promise<void>;
-  subscribe(runId: string, listener: BusListener): () => void;
-}
-
-export class InProcessLauncher implements RunLauncher {
-  private active = new Map<string, AbortController>();
-  private activePerUser = new Map<string, Set<string>>(); // userId → Set<runId>
-
-  constructor(
-    private engineConfig: EngineConfig,
-    private store: AnyRunStore,
-    private runsDir: string,
-    private bus: RunEventBus,
-    private engineFactory: EngineFactory = (cfg, evts) => new PipelineEngine(cfg, evts),
-    private userStore?: AnyUserStore,
-    private plans: PlansConfig = DEFAULT_PLANS,
-  ) {}
-
-  subscribe(runId: string, listener: BusListener): () => void {
-    return this.bus.subscribe(runId, listener);
-  }
-
-  async launch(config: LaunchConfig): Promise<{ run_id: string }> {
-    const { runId, pipeline, input, meta, parentRunId, userId } = config;
-
-    // Quota enforcement (only if userId provided and userStore available)
-    if (userId && this.userStore) {
-      const user = await this.userStore.getUserById(userId);
-      if (user) {
-        const today = new Date().toISOString().slice(0, 10);
-        const limits = getPlanLimits(this.plans, user.plan);
-
-        // Check runs_per_day
-        if (limits.runs_per_day !== -1) {
-          const usage = await this.userStore.getDailyUsage(userId, today);
-          if (usage.runs_count >= limits.runs_per_day) {
-            throw Object.assign(
-              new Error('Daily run limit exceeded'),
-              { code: 'QUOTA_EXCEEDED', limit: limits.runs_per_day, used: usage.runs_count }
-            );
-          }
-        }
-
-        // Check max_concurrent
-        const activeForUser = this.activePerUser.get(userId)?.size ?? 0;
-        if (activeForUser >= limits.max_concurrent) {
-          throw Object.assign(
-            new Error('Concurrent run limit exceeded'),
-            { code: 'QUOTA_EXCEEDED', limit: limits.max_concurrent, used: activeForUser }
-          );
-        }
-
-        // Increment runs_count
-        await this.userStore.incrementRuns(userId, today);
-      }
-    }
-
-    // Track active run for user (before creating the controller)
-    if (userId) {
-      if (!this.activePerUser.has(userId)) this.activePerUser.set(userId, new Set());
-      this.activePerUser.get(userId)!.add(runId);
-    }
-
-    const controller = new AbortController();
-    this.active.set(runId, controller);
-
-    const logger = createApiLogger(this.runsDir, runId, pipeline);
-
-    // Pre-create the run in the store so GET /api/runs/:id/stream can find it immediately
-    // after launch() returns. The engine will upsert it again at onPipelineStart with the
-    // same id (savePipelineRun is ON CONFLICT DO UPDATE in all store implementations).
-    const stubRun: PipelineRun = {
-      id: runId,
-      pipeline_name: pipeline,
-      status: 'running',
-      started_at: new Date().toISOString(),
-      stages: [],
-      ...(input && typeof input === 'object' ? { input: input as Record<string, unknown> } : {}),
-      ...(parentRunId ? { parent_run_id: parentRunId } : {}),
-    };
-    await this.store.savePipelineRun(stubRun);
-
-    // Save log path immediately so callers can locate the log file right after launch().
-    // For InMemoryRunStore this is a simple Map.set() and works regardless of row existence.
-    // For SQLiteRunStore/PgRunStore the row now exists, so the UPDATE will take effect.
-    void this.store.saveLogPath(runId, logger.logPath);
-
-    const emit = (type: SseEventType, data: object) => {
-      this.bus.emit(runId, type, data);
-      logger.log({ event: type, ...(data as Record<string, unknown>) });
-    };
-
-    // Track last group feedback for inclusion in the pipeline_complete bus event
-    let lastGroupFeedback: GroupFeedbackEvent | undefined;
-
-    const perRunEvents: EngineEvents = {
-      onPipelineStart: (e: PipelineStartEvent) => {
-        // Row exists now — persist log_path for SQLiteRunStore (the call in launch() was a no-op there).
-        void this.store.saveLogPath(runId, logger.logPath);
-        emit('pipeline_start', e);
-      },
-      onStageStart:        (e: StageStartEvent) =>        emit('stage_start', e),
-      onStageComplete:     (e: StageCompleteEvent) =>     emit('stage_complete', e),
-      onTaskRetry:         (e: StageRetryEvent) =>        emit('stage_retry', e),
-      onGroupStart:        (e: GroupStartEvent) =>        emit('group_start', e),
-      onGroupIteration:    (e: GroupIterationEvent) =>    emit('group_iteration', e),
-      onGroupFeedback:     (e: GroupFeedbackEvent) => {
-        lastGroupFeedback = e;
-        emit('group_feedback', e);
-      },
-      onGroupComplete:     (e: GroupCompleteEvent) =>          emit('group_complete', e),
-      onStageContext:      (e: StageContextEvent) =>           emit('stage_context', e),
-      onToolCallStart:     (e: StagedToolCallStartEvent) =>    emit('tool_call_start', e),
-      onToolCallComplete:  (e: StagedToolCallCompleteEvent) => emit('tool_call_complete', e),
-      onPipelineComplete:  (e: PipelineCompleteEvent) => {
-        emit('pipeline_complete', { ...e, meta: meta ?? {}, last_group_feedback: lastGroupFeedback });
-        this.bus.close(runId);
-      },
-      onPipelineCancelled: (e: PipelineCancelledEvent) => {
-        emit('pipeline_cancelled', e);
-      },
-    };
-
-    let runEngineConfig: EngineConfig = this.engineConfig;
-    if (config.repoPath !== undefined) {
-      const toolsDir = join(this.engineConfig.configsDir, 'tools');
-      const freshPlugins = await loadProjectTools(toolsDir, config.repoPath);
-      // toolRegistry is always provided when using the API launcher
-      const freshRegistry = this.engineConfig.toolRegistry!.clone();
-      for (const plugin of freshPlugins) {
-        freshRegistry.registerPlugin(plugin.name, plugin.tools, plugin.promptSnippet);
-      }
-      runEngineConfig = { ...this.engineConfig, repoPath: config.repoPath, toolRegistry: freshRegistry };
-    }
-    const engine = this.engineFactory(runEngineConfig, perRunEvents);
-
-    void engine
-      .run({ pipeline, input, meta, signal: controller.signal, id: runId, depth: config.depth, parentRunId })
-      .then(async () => {
-        await logger.close();
-      })
-      .catch(async (err: unknown) => {
-        logger.log({ event: 'pipeline_error', error: String(err) });
-        this.bus.close(runId);
-        await logger.close();
-      })
-      .finally(() => {
-        this.active.delete(runId);
-        if (userId) {
-          this.activePerUser.get(userId)?.delete(runId);
-        }
-      });
-
-    return { run_id: runId };
-  }
-
-  async cancel(run_id: string): Promise<void> {
-    this.active.get(run_id)?.abort();
-  }
-}
-
-export { randomUUID as generateRunId } from 'node:crypto';

package/src/logger.ts

@@ -1,50 +0,0 @@
-// JSONL logger for API runs
-// Writes to <runsDir>/<date>-<pipeline>-<runId>.jsonl
-
-import { createWriteStream, mkdirSync } from 'node:fs';
-import { resolve } from 'node:path';
-
-function runIdShort(runId: string): string {
-  return runId.slice(0, 8);
-}
-
-function dateForFilename(): string {
-  const iso = new Date().toISOString();
-  return iso.slice(0, 16).replace(/(\d{2}):(\d{2})$/, '$1h$2m');
-}
-
-export interface ApiRunLogger {
-  logPath: string;
-  log(payload: Record<string, unknown>): void;
-  close(): Promise<void>;
-}
-
-export function createApiLogger(runsDir: string, runId: string, pipeline: string): ApiRunLogger {
-  const shortId = runIdShort(runId);
-  const date = dateForFilename();
-  const logPath = resolve(runsDir, `${date}-${pipeline}-${shortId}.jsonl`);
-
-  mkdirSync(runsDir, { recursive: true });
-  const stream = createWriteStream(logPath, { flags: 'a' });
-
-  return {
-    logPath,
-
-    log(payload: Record<string, unknown>): void {
-      const line = {
-        ts: new Date().toISOString(),
-        run_id: shortId,
-        ...payload,
-      };
-      if (stream.writable) {
-        stream.write(JSON.stringify(line) + '\n');
-      }
-    },
-
-    close(): Promise<void> {
-      return new Promise((resolve) => {
-        stream.end(() => resolve());
-      });
-    },
-  };
-}