@wopr-network/defcon 0.2.0

package/dist/repositories/drizzle/schema.js

@@ -0,0 +1,155 @@
+import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+// ─── Definition Tables ───
+export const flowDefinitions = sqliteTable("flow_definitions", {
+    id: text("id").primaryKey(),
+    name: text("name").notNull().unique(),
+    description: text("description"),
+    entitySchema: text("entity_schema", { mode: "json" }),
+    initialState: text("initial_state").notNull(),
+    maxConcurrent: integer("max_concurrent").default(0),
+    maxConcurrentPerRepo: integer("max_concurrent_per_repo").default(0),
+    affinityWindowMs: integer("affinity_window_ms").default(300000),
+    gateTimeoutMs: integer("gate_timeout_ms"),
+    version: integer("version").default(1),
+    createdBy: text("created_by"),
+    discipline: text("discipline"),
+    defaultModelTier: text("default_model_tier"),
+    timeoutPrompt: text("timeout_prompt"),
+    createdAt: integer("created_at"),
+    updatedAt: integer("updated_at"),
+});
+export const stateDefinitions = sqliteTable("state_definitions", {
+    id: text("id").primaryKey(),
+    flowId: text("flow_id")
+        .notNull()
+        .references(() => flowDefinitions.id),
+    name: text("name").notNull(),
+    agentRole: text("agent_role"),
+    modelTier: text("model_tier"),
+    mode: text("mode").default("passive"),
+    promptTemplate: text("prompt_template"),
+    constraints: text("constraints", { mode: "json" }),
+    onEnter: text("on_enter", { mode: "json" }),
+}, (table) => ({
+    flowNameUnique: uniqueIndex("state_definitions_flow_name_unique").on(table.flowId, table.name),
+}));
+export const gateDefinitions = sqliteTable("gate_definitions", {
+    id: text("id").primaryKey(),
+    name: text("name").notNull().unique(),
+    type: text("type").notNull(),
+    command: text("command"),
+    functionRef: text("function_ref"),
+    apiConfig: text("api_config", { mode: "json" }),
+    timeoutMs: integer("timeout_ms"),
+    failurePrompt: text("failure_prompt"),
+    timeoutPrompt: text("timeout_prompt"),
+});
+export const transitionRules = sqliteTable("transition_rules", {
+    id: text("id").primaryKey(),
+    flowId: text("flow_id")
+        .notNull()
+        .references(() => flowDefinitions.id),
+    fromState: text("from_state").notNull(),
+    toState: text("to_state").notNull(),
+    trigger: text("trigger").notNull(),
+    gateId: text("gate_id").references(() => gateDefinitions.id),
+    condition: text("condition"),
+    priority: integer("priority").default(0),
+    spawnFlow: text("spawn_flow"),
+    spawnTemplate: text("spawn_template"),
+    createdAt: integer("created_at"),
+});
+export const flowVersions = sqliteTable("flow_versions", {
+    id: text("id").primaryKey(),
+    flowId: text("flow_id")
+        .notNull()
+        .references(() => flowDefinitions.id),
+    version: integer("version").notNull(),
+    snapshot: text("snapshot", { mode: "json" }),
+    changedBy: text("changed_by"),
+    changeReason: text("change_reason"),
+    createdAt: integer("created_at"),
+}, (table) => ({
+    flowVersionUnique: uniqueIndex("flow_versions_flow_version_unique").on(table.flowId, table.version),
+}));
+// ─── Runtime Tables ───
+export const entities = sqliteTable("entities", {
+    id: text("id").primaryKey(),
+    flowId: text("flow_id")
+        .notNull()
+        .references(() => flowDefinitions.id),
+    state: text("state").notNull(),
+    refs: text("refs", { mode: "json" }),
+    artifacts: text("artifacts", { mode: "json" }),
+    claimedBy: text("claimed_by"),
+    claimedAt: integer("claimed_at"),
+    flowVersion: integer("flow_version"),
+    priority: integer("priority").default(0),
+    createdAt: integer("created_at"),
+    updatedAt: integer("updated_at"),
+    affinityWorkerId: text("affinity_worker_id"),
+    affinityRole: text("affinity_role"),
+    affinityExpiresAt: integer("affinity_expires_at"),
+}, (table) => ({
+    flowStateIdx: index("entities_flow_state_idx").on(table.flowId, table.state),
+    claimIdx: index("entities_claim_idx").on(table.flowId, table.state, table.claimedBy),
+    affinityIdx: index("entities_affinity_idx").on(table.affinityWorkerId, table.affinityRole, table.affinityExpiresAt),
+}));
+export const invocations = sqliteTable("invocations", {
+    id: text("id").primaryKey(),
+    entityId: text("entity_id")
+        .notNull()
+        .references(() => entities.id),
+    stage: text("stage").notNull(),
+    agentRole: text("agent_role"),
+    mode: text("mode").notNull(),
+    prompt: text("prompt").notNull(),
+    context: text("context", { mode: "json" }),
+    claimedBy: text("claimed_by"),
+    claimedAt: integer("claimed_at"),
+    startedAt: integer("started_at"),
+    completedAt: integer("completed_at"),
+    failedAt: integer("failed_at"),
+    signal: text("signal"),
+    artifacts: text("artifacts", { mode: "json" }),
+    error: text("error"),
+    ttlMs: integer("ttl_ms").default(1800000),
+    createdAt: integer("created_at"),
+}, (table) => ({
+    entityIdx: index("invocations_entity_idx").on(table.entityId),
+}));
+export const gateResults = sqliteTable("gate_results", {
+    id: text("id").primaryKey(),
+    entityId: text("entity_id")
+        .notNull()
+        .references(() => entities.id),
+    gateId: text("gate_id")
+        .notNull()
+        .references(() => gateDefinitions.id),
+    passed: integer("passed").notNull(),
+    output: text("output"),
+    evaluatedAt: integer("evaluated_at"),
+});
+export const entityHistory = sqliteTable("entity_history", {
+    id: text("id").primaryKey(),
+    entityId: text("entity_id")
+        .notNull()
+        .references(() => entities.id),
+    fromState: text("from_state"),
+    toState: text("to_state").notNull(),
+    trigger: text("trigger"),
+    invocationId: text("invocation_id").references(() => invocations.id),
+    timestamp: integer("timestamp").notNull(),
+}, (table) => ({
+    entityTimestampIdx: index("entity_history_entity_ts_idx").on(table.entityId, table.timestamp),
+}));
+export const events = sqliteTable("events", {
+    id: text("id").primaryKey(),
+    type: text("type").notNull(),
+    entityId: text("entity_id"),
+    flowId: text("flow_id"),
+    payload: text("payload", { mode: "json" }),
+    emittedAt: integer("emitted_at").notNull(),
+}, (table) => ({
+    typeEmittedIdx: index("events_type_emitted_idx").on(table.type, table.emittedAt),
+}));

package/dist/repositories/drizzle/transition-log.repo.d.ts

@@ -0,0 +1,11 @@
+import type { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
+import type { ITransitionLogRepository, TransitionLog } from "../interfaces.js";
+import type * as schema from "./schema.js";
+type Db = BetterSQLite3Database<typeof schema>;
+export declare class DrizzleTransitionLogRepository implements ITransitionLogRepository {
+    private db;
+    constructor(db: Db);
+    record(log: Omit<TransitionLog, "id">): Promise<TransitionLog>;
+    historyFor(entityId: string): Promise<TransitionLog[]>;
+}
+export {};

package/dist/repositories/drizzle/transition-log.repo.js

@@ -0,0 +1,42 @@
+import { randomUUID } from "node:crypto";
+import { asc, eq, sql } from "drizzle-orm";
+import { entityHistory } from "./schema.js";
+export class DrizzleTransitionLogRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async record(log) {
+        const id = randomUUID();
+        this.db
+            .insert(entityHistory)
+            .values({
+            id,
+            entityId: log.entityId,
+            fromState: log.fromState ?? null,
+            toState: log.toState,
+            trigger: log.trigger ?? null,
+            invocationId: log.invocationId ?? null,
+            timestamp: log.timestamp.getTime(),
+        })
+            .run();
+        return { id, ...log };
+    }
+    async historyFor(entityId) {
+        const rows = this.db
+            .select()
+            .from(entityHistory)
+            .where(eq(entityHistory.entityId, entityId))
+            .orderBy(asc(entityHistory.timestamp), sql `rowid`)
+            .all();
+        return rows.map((r) => ({
+            id: r.id,
+            entityId: r.entityId,
+            fromState: r.fromState,
+            toState: r.toState,
+            trigger: r.trigger,
+            invocationId: r.invocationId,
+            timestamp: new Date(r.timestamp),
+        }));
+    }
+}

package/dist/repositories/interfaces.d.ts

@@ -0,0 +1,321 @@
+/** External-system reference map keyed by adapter name */
+export type Refs = Record<string, {
+    adapter: string;
+    id: string;
+    [key: string]: unknown;
+}>;
+/** Freeform key-value artifact bag */
+export type Artifacts = Record<string, unknown>;
+/** Configuration for running a command when an entity enters a state */
+export interface OnEnterConfig {
+    command: string;
+    artifacts: string[];
+    timeout_ms?: number;
+}
+/** Invocation execution mode */
+export type Mode = "active" | "passive";
+/** Runtime entity tracked through a flow */
+export interface Entity {
+    id: string;
+    flowId: string;
+    state: string;
+    refs: Refs | null;
+    artifacts: Artifacts | null;
+    claimedBy: string | null;
+    claimedAt: Date | null;
+    flowVersion: number;
+    priority: number;
+    createdAt: Date;
+    updatedAt: Date;
+    affinityWorkerId: string | null;
+    affinityRole: string | null;
+    affinityExpiresAt: Date | null;
+}
+/** A single agent invocation tied to an entity */
+export interface Invocation {
+    id: string;
+    entityId: string;
+    stage: string;
+    mode: Mode;
+    prompt: string;
+    context: Record<string, unknown> | null;
+    claimedBy: string | null;
+    claimedAt: Date | null;
+    startedAt: Date | null;
+    completedAt: Date | null;
+    failedAt: Date | null;
+    signal: string | null;
+    artifacts: Artifacts | null;
+    error: string | null;
+    ttlMs: number;
+}
+/** Result of evaluating a gate against an entity */
+export interface GateResult {
+    id: string;
+    entityId: string;
+    gateId: string;
+    passed: boolean;
+    output: string | null;
+    evaluatedAt: Date | null;
+}
+/**
+ * Entity with pre-fetched related data for use in Handlebars template helpers.
+ * The `invocations` and `gateResults` fields are populated by the engine before
+ * rendering prompt templates; they are never present on raw DB rows.
+ */
+export interface EnrichedEntity extends Entity {
+    invocations?: Invocation[];
+    gateResults?: GateResult[];
+}
+/** Audit-log entry for an entity state transition */
+export interface TransitionLog {
+    id: string;
+    entityId: string;
+    fromState: string | null;
+    toState: string;
+    trigger: string | null;
+    invocationId: string | null;
+    timestamp: Date;
+}
+/** A state within a flow definition */
+export interface State {
+    id: string;
+    flowId: string;
+    name: string;
+    modelTier: string | null;
+    mode: Mode;
+    promptTemplate: string | null;
+    constraints: Record<string, unknown> | null;
+    onEnter: OnEnterConfig | null;
+}
+/** A transition rule between two states */
+export interface Transition {
+    id: string;
+    flowId: string;
+    fromState: string;
+    toState: string;
+    trigger: string;
+    gateId: string | null;
+    condition: string | null;
+    priority: number;
+    spawnFlow: string | null;
+    spawnTemplate: string | null;
+    createdAt: Date | null;
+}
+/** A gate definition (quality check) */
+export interface Gate {
+    id: string;
+    name: string;
+    type: string;
+    command: string | null;
+    functionRef: string | null;
+    apiConfig: Record<string, unknown> | null;
+    timeoutMs: number | null;
+    failurePrompt: string | null;
+    timeoutPrompt: string | null;
+}
+/** A complete flow definition with its states and transitions */
+export interface Flow {
+    id: string;
+    name: string;
+    description: string | null;
+    entitySchema: Record<string, unknown> | null;
+    initialState: string;
+    maxConcurrent: number;
+    maxConcurrentPerRepo: number;
+    affinityWindowMs: number;
+    gateTimeoutMs: number | null;
+    version: number;
+    createdBy: string | null;
+    discipline: string | null;
+    defaultModelTier: string | null;
+    timeoutPrompt: string | null;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    states: State[];
+    transitions: Transition[];
+}
+/** A versioned snapshot of a flow */
+export interface FlowVersion {
+    id: string;
+    flowId: string;
+    version: number;
+    snapshot: Record<string, unknown>;
+    changedBy: string | null;
+    changeReason: string | null;
+    createdAt: Date | null;
+}
+/** Input for creating a new flow */
+export interface CreateFlowInput {
+    name: string;
+    description?: string;
+    entitySchema?: Record<string, unknown>;
+    initialState: string;
+    maxConcurrent?: number;
+    maxConcurrentPerRepo?: number;
+    affinityWindowMs?: number;
+    gateTimeoutMs?: number;
+    createdBy?: string;
+    discipline?: string;
+    defaultModelTier?: string;
+    timeoutPrompt?: string;
+}
+/** Input for adding a state to a flow */
+export interface CreateStateInput {
+    name: string;
+    modelTier?: string;
+    mode?: Mode;
+    promptTemplate?: string;
+    constraints?: Record<string, unknown>;
+    onEnter?: OnEnterConfig;
+}
+/** Input for adding a transition rule */
+export interface CreateTransitionInput {
+    fromState: string;
+    toState: string;
+    trigger: string;
+    gateId?: string;
+    condition?: string;
+    priority?: number;
+    spawnFlow?: string;
+    spawnTemplate?: string;
+}
+/** Input for creating a gate definition */
+export interface CreateGateInput {
+    name: string;
+    type: string;
+    command?: string;
+    functionRef?: string;
+    apiConfig?: Record<string, unknown>;
+    timeoutMs?: number;
+    failurePrompt?: string;
+    timeoutPrompt?: string;
+}
+/** Data-access contract for entity lifecycle operations. */
+export interface IEntityRepository {
+    /** Create a new entity in the given flow's initial state. */
+    create(flowId: string, initialState: string, refs?: Refs): Promise<Entity>;
+    /** Get an entity by ID, or null if not found. */
+    get(id: string): Promise<Entity | null>;
+    /** Find entities in a given flow and state, up to an optional limit. */
+    findByFlowAndState(flowId: string, state: string, limit?: number): Promise<Entity[]>;
+    /** Return true if at least one entity exists in the given flow across any of the given states. */
+    hasAnyInFlowAndState(flowId: string, stateNames: string[]): Promise<boolean>;
+    /** Transition an entity to a new state, recording the trigger and optional artifacts. */
+    transition(id: string, toState: string, trigger: string, artifacts?: Partial<Artifacts>): Promise<Entity>;
+    /** Merge partial artifacts into an entity's existing artifact bag. Performs a shallow merge
+     *  ({ ...existing, ...artifacts }) — only the specified keys are updated; unspecified keys are preserved. */
+    updateArtifacts(id: string, artifacts: Partial<Artifacts>): Promise<void>;
+    /** Atomically claim one unclaimed entity in the given flow+state for the specified agent. Returns null if none available. Uses compare-and-swap (UPDATE WHERE claimedBy IS NULL). */
+    claim(flowId: string, state: string, agentId: string): Promise<Entity | null>;
+    /** Atomically claim a specific entity by ID for the specified agent. Returns null if already claimed. Uses compare-and-swap (UPDATE WHERE claimedBy IS NULL). */
+    claimById(entityId: string, agentId: string): Promise<Entity | null>;
+    /** Release a claimed entity, clearing claimedBy and claimedAt. */
+    release(entityId: string, agentId: string): Promise<void>;
+    /** Find entities whose claim has expired beyond ttlMs and release them. Returns the IDs of released entities. */
+    reapExpired(ttlMs: number): Promise<string[]>;
+    /** Set affinity metadata on an entity, recording the last worker that touched it. */
+    setAffinity(entityId: string, workerId: string, role: string, expiresAt: Date): Promise<void>;
+    /** Clear expired affinity records. Returns the IDs of entities whose affinity was cleared. */
+    clearExpiredAffinity(): Promise<string[]>;
+    /** Atomically append a spawned child entry to the parent entity's artifacts.spawnedChildren array.
+     *  Reads the current array and writes back in a single transaction to prevent TOCTOU races. */
+    appendSpawnedChild(parentId: string, entry: {
+        childId: string;
+        childFlow: string;
+        spawnedAt: string;
+    }): Promise<void>;
+}
+/** Fields that can be updated on a flow's top-level definition */
+export type UpdateFlowInput = Partial<Omit<Flow, "id" | "states" | "transitions" | "createdAt" | "updatedAt">>;
+/** Fields that can be updated on a state definition */
+export type UpdateStateInput = Partial<Omit<State, "id" | "flowId">>;
+/** Fields that can be updated on a transition rule */
+export type UpdateTransitionInput = Partial<Omit<Transition, "id" | "flowId">>;
+/** Data-access contract for flow definition CRUD and versioning. */
+export interface IFlowRepository {
+    /** Create a new flow definition. */
+    create(flow: CreateFlowInput): Promise<Flow>;
+    /** List all flow definitions. */
+    list(): Promise<Flow[]>;
+    /** Get a flow by ID, including its states and transitions. Returns null if not found. */
+    get(id: string): Promise<Flow | null>;
+    /** Get a flow by unique name. Returns null if not found. */
+    getByName(name: string): Promise<Flow | null>;
+    /** Update a flow's top-level fields. */
+    update(id: string, changes: UpdateFlowInput): Promise<Flow>;
+    /** Add a state definition to a flow. */
+    addState(flowId: string, state: CreateStateInput): Promise<State>;
+    /** Update an existing state definition. */
+    updateState(stateId: string, changes: UpdateStateInput): Promise<State>;
+    /** Add a transition rule to a flow. */
+    addTransition(flowId: string, transition: CreateTransitionInput): Promise<Transition>;
+    /** Update an existing transition rule. */
+    updateTransition(transitionId: string, changes: UpdateTransitionInput): Promise<Transition>;
+    /** Create a versioned snapshot of the current flow definition. */
+    snapshot(flowId: string): Promise<FlowVersion>;
+    /** Restore a flow definition to a previous version. */
+    restore(flowId: string, version: number): Promise<void>;
+    /** List all flow definitions. */
+    listAll(): Promise<Flow[]>;
+}
+/** Data-access contract for invocation lifecycle and claiming. */
+export interface IInvocationRepository {
+    /** Create a new invocation for an entity at a given stage. */
+    create(entityId: string, stage: string, prompt: string, mode: Mode, ttlMs?: number, context?: Record<string, unknown>): Promise<Invocation>;
+    /** Get an invocation by ID, or null if not found. */
+    get(id: string): Promise<Invocation | null>;
+    /** Atomically claim an unclaimed invocation for the specified agent. Uses compare-and-swap (UPDATE WHERE claimedBy IS NULL). Returns null if already claimed. */
+    claim(invocationId: string, agentId: string): Promise<Invocation | null>;
+    /** Mark an invocation as completed with a signal and optional artifacts. */
+    complete(id: string, signal: string, artifacts?: Artifacts): Promise<Invocation>;
+    /** Mark an invocation as failed with an error message. */
+    fail(id: string, error: string): Promise<Invocation>;
+    /** Release a claim on an invocation, making it available for another worker to claim. */
+    releaseClaim(id: string): Promise<void>;
+    /** Find all invocations for a given entity. */
+    findByEntity(entityId: string): Promise<Invocation[]>;
+    /** Find unclaimed invocations where the entity has unexpired affinity for the given worker and role. */
+    findUnclaimedWithAffinity(flowId: string, role: string, workerId: string): Promise<Invocation[]>;
+    /** Find all unclaimed invocations in a flow, regardless of agentRole. For discipline-based claiming. */
+    findUnclaimedByFlow(flowId: string): Promise<Invocation[]>;
+    /** Find all invocations for a given flow (across all entities). */
+    findByFlow(flowId: string): Promise<Invocation[]>;
+    /** Find and mark expired invocations (where now - claimedAt > row's ttlMs). Returns the expired invocations. */
+    reapExpired(): Promise<Invocation[]>;
+    /** Find unclaimed active-mode invocations, optionally filtered by flow. */
+    findUnclaimedActive(flowId?: string): Promise<Invocation[]>;
+    /** Count active invocations (claimed, not completed/failed) for a flow. */
+    countActiveByFlow(flowId: string): Promise<number>;
+    /** Count pending invocations (unclaimed, not completed/failed) for a flow. */
+    countPendingByFlow(flowId: string): Promise<number>;
+}
+/** Data-access contract for entity state-transition audit trails. */
+export interface ITransitionLogRepository {
+    /** Record a state transition for an entity. */
+    record(log: Omit<TransitionLog, "id">): Promise<TransitionLog>;
+    /** Get full transition history for an entity, ordered by timestamp. */
+    historyFor(entityId: string): Promise<TransitionLog[]>;
+}
+/** Data-access contract for emitting definition-change events. */
+export interface IEventRepository {
+    /** Emit a definition change event for a tool action. */
+    emitDefinitionChanged(flowId: string | null, tool: string, payload: Record<string, unknown>): Promise<void>;
+}
+/** Data-access contract for gate definitions and result recording. */
+export interface IGateRepository {
+    /** Create a new gate definition. */
+    create(gate: CreateGateInput): Promise<Gate>;
+    /** Get a gate by ID, or null if not found. */
+    get(id: string): Promise<Gate | null>;
+    /** Get a gate by unique name, or null if not found. */
+    getByName(name: string): Promise<Gate | null>;
+    /** List all gate definitions. */
+    listAll(): Promise<Gate[]>;
+    /** Record the result of evaluating a gate against an entity. */
+    record(entityId: string, gateId: string, passed: boolean, output: string): Promise<GateResult>;
+    /** Get all gate results for a given entity. */
+    resultsFor(entityId: string): Promise<GateResult[]>;
+    /** Update mutable fields on a gate definition. */
+    update(id: string, changes: Partial<Pick<Gate, "command" | "functionRef" | "apiConfig" | "timeoutMs" | "failurePrompt" | "timeoutPrompt">>): Promise<Gate>;
+}

package/dist/repositories/interfaces.js

@@ -0,0 +1,2 @@
+// Repository interfaces — I*Repository contracts
+export {};

package/dist/src/api/router.d.ts

@@ -0,0 +1,24 @@
+export interface ParsedRequest {
+    params: Record<string, string>;
+    query: URLSearchParams;
+    body: Record<string, unknown> | null;
+    authorization?: string;
+}
+export interface ApiResponse {
+    status: number;
+    body: unknown;
+}
+type Handler = (req: ParsedRequest) => Promise<ApiResponse>;
+interface MatchResult {
+    params: Record<string, string>;
+    handler: Handler;
+    longRunning?: boolean;
+}
+export declare class Router {
+    private routes;
+    add(method: string, path: string, handler: Handler, options?: {
+        longRunning?: boolean;
+    }): void;
+    match(method: string, pathname: string): MatchResult | null;
+}
+export {};

package/dist/src/api/router.js

@@ -0,0 +1,44 @@
+export class Router {
+    routes = [];
+    add(method, path, handler, options) {
+        const paramNames = [];
+        // Split on param segments, escape literal segments, then reassemble
+        const patternStr = path
+            .split(/(:([^/]+))/g)
+            .map((segment, i) => {
+            // Every 3rd token (i % 3 === 1) is the full ":name" match — replace with capture group
+            if (i % 3 === 1) {
+                paramNames.push(segment.slice(1));
+                return "([^/]+)";
+            }
+            // Every 3rd+1 token (i % 3 === 2) is the captured name — skip (already handled above)
+            if (i % 3 === 2)
+                return "";
+            // Literal segment — escape regex metacharacters
+            return segment.replace(/[.+*?^${}()|[\]\\]/g, "\\$&");
+        })
+            .join("");
+        this.routes.push({
+            method,
+            pattern: new RegExp(`^${patternStr}$`),
+            paramNames,
+            handler,
+            longRunning: options?.longRunning,
+        });
+    }
+    match(method, pathname) {
+        for (const route of this.routes) {
+            if (route.method !== method)
+                continue;
+            const m = pathname.match(route.pattern);
+            if (m) {
+                const params = {};
+                route.paramNames.forEach((name, i) => {
+                    params[name] = m[i + 1];
+                });
+                return { params, handler: route.handler, longRunning: route.longRunning };
+            }
+        }
+        return null;
+    }
+}

package/dist/src/api/server.d.ts

@@ -0,0 +1,13 @@
+import http from "node:http";
+import type { Engine } from "../engine/engine.js";
+import type { McpServerDeps } from "../execution/mcp-server.js";
+import type { Logger } from "../logger.js";
+export interface HttpServerDeps {
+    engine: Engine;
+    mcpDeps: McpServerDeps;
+    adminToken?: string;
+    workerToken?: string;
+    corsOrigin?: string;
+    logger?: Logger;
+}
+export declare function createHttpServer(deps: HttpServerDeps): http.Server;