@wopr-network/defcon 0.2.0

package/dist/api/wire-types.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Wire types for defcon's REST and MCP APIs.
+ * Exported for consumers (e.g. norad) to import instead of duplicating.
+ */
+export type ClaimResponse = {
+    next_action: "check_back";
+    retry_after_ms: number;
+    message: string;
+} | {
+    worker_id?: string;
+    entity_id: string;
+    invocation_id: string;
+    flow: string | null;
+    stage: string;
+    prompt: string;
+    context: Record<string, unknown> | null;
+    worker_notice?: string;
+};
+export type ReportResponse = {
+    next_action: "continue";
+    new_state: string;
+    gates_passed?: string[];
+    prompt: string | null;
+    context: Record<string, unknown> | null;
+} | {
+    next_action: "waiting";
+    new_state: null;
+    gated: true;
+    gate_output: string;
+    gateName: string;
+    failure_prompt: string | null;
+} | {
+    next_action: "check_back";
+    message: string;
+    retry_after_ms: number;
+    timeout_prompt?: string;
+} | {
+    next_action: "completed";
+    new_state: string;
+    gates_passed?: string[];
+    prompt: null;
+    context: null;
+};
+export interface CreateEntityResponse {
+    id: string;
+}

package/dist/api/wire-types.js

@@ -0,0 +1,5 @@
+/**
+ * Wire types for defcon's REST and MCP APIs.
+ * Exported for consumers (e.g. norad) to import instead of duplicating.
+ */
+export {};

package/dist/config/db-path.d.ts

@@ -0,0 +1 @@
+export declare const DB_PATH = "./agentic-flow.db";

package/dist/config/db-path.js

@@ -0,0 +1 @@
+export const DB_PATH = "./agentic-flow.db";

package/dist/config/exporter.d.ts

@@ -0,0 +1,3 @@
+import type { IFlowRepository, IGateRepository } from "../repositories/interfaces.js";
+import type { SeedFile } from "./zod-schemas.js";
+export declare function exportSeed(flowRepo: IFlowRepository, gateRepo: IGateRepository): Promise<SeedFile>;

package/dist/config/exporter.js

@@ -0,0 +1,87 @@
+export async function exportSeed(flowRepo, gateRepo) {
+    const flows = await flowRepo.listAll();
+    // Fetch all gates once, build ID->name map (no N+1)
+    const allGates = await gateRepo.listAll();
+    const gateIdToName = new Map(allGates.map((g) => [g.id, g.name]));
+    const gateById = new Map(allGates.map((g) => [g.id, g]));
+    const exportedFlows = flows.filter((f) => f.discipline !== null);
+    // Collect gate IDs referenced by transitions of exported flows only
+    const referencedGateIds = new Set();
+    for (const flow of exportedFlows) {
+        for (const t of flow.transitions) {
+            if (t.gateId)
+                referencedGateIds.add(t.gateId);
+        }
+    }
+    // Build gates array from referenced gates (already loaded)
+    const gateEntries = [];
+    for (const gateId of referencedGateIds) {
+        const gate = gateById.get(gateId);
+        if (!gate)
+            continue;
+        if (gate.type === "command" && gate.command) {
+            gateEntries.push({
+                name: gate.name,
+                type: "command",
+                command: gate.command,
+                timeoutMs: gate.timeoutMs ?? undefined,
+            });
+        }
+        else if (gate.type === "function" && gate.functionRef) {
+            gateEntries.push({
+                name: gate.name,
+                type: "function",
+                functionRef: gate.functionRef,
+                timeoutMs: gate.timeoutMs ?? undefined,
+            });
+        }
+        else if (gate.type === "api" && gate.apiConfig) {
+            gateEntries.push({
+                name: gate.name,
+                type: "api",
+                apiConfig: gate.apiConfig,
+                timeoutMs: gate.timeoutMs ?? undefined,
+            });
+        }
+    }
+    const seedFlows = exportedFlows.map((f) => ({
+        name: f.name,
+        description: f.description ?? undefined,
+        entitySchema: f.entitySchema ?? undefined,
+        initialState: f.initialState,
+        maxConcurrent: f.maxConcurrent,
+        maxConcurrentPerRepo: f.maxConcurrentPerRepo,
+        affinityWindowMs: f.affinityWindowMs,
+        gateTimeoutMs: f.gateTimeoutMs ?? undefined,
+        version: f.version,
+        createdBy: f.createdBy ?? undefined,
+        discipline: f.discipline,
+        defaultModelTier: f.defaultModelTier ?? undefined,
+        timeoutPrompt: f.timeoutPrompt ?? undefined,
+    }));
+    const seedStates = exportedFlows.flatMap((f) => f.states.map((s) => ({
+        name: s.name,
+        flowName: f.name,
+        modelTier: s.modelTier ?? undefined,
+        mode: s.mode,
+        promptTemplate: s.promptTemplate ?? undefined,
+        constraints: s.constraints ?? undefined,
+    })));
+    const seedTransitions = exportedFlows.flatMap((f) => f.transitions.map((t) => ({
+        flowName: f.name,
+        fromState: t.fromState,
+        toState: t.toState,
+        trigger: t.trigger,
+        gateName: t.gateId ? gateIdToName.get(t.gateId) : undefined,
+        condition: t.condition ?? undefined,
+        priority: t.priority,
+        spawnFlow: t.spawnFlow ?? undefined,
+        spawnTemplate: t.spawnTemplate ?? undefined,
+    })));
+    return {
+        flows: seedFlows,
+        states: seedStates,
+        gates: gateEntries,
+        transitions: seedTransitions,
+    };
+}

package/dist/config/index.d.ts

@@ -0,0 +1,4 @@
+export { exportSeed } from "./exporter.js";
+export type { LoadSeedOptions, LoadSeedResult } from "./seed-loader.js";
+export { loadSeed } from "./seed-loader.js";
+export * from "./zod-schemas.js";

package/dist/config/index.js

@@ -0,0 +1,4 @@
+// Config module — seed loader, Zod schemas
+export { exportSeed } from "./exporter.js";
+export { loadSeed } from "./seed-loader.js";
+export * from "./zod-schemas.js";

package/dist/config/seed-loader.d.ts

@@ -0,0 +1,10 @@
+import type Database from "better-sqlite3";
+import type { IFlowRepository, IGateRepository } from "../repositories/interfaces.js";
+export interface LoadSeedOptions {
+    allowedRoot?: string;
+}
+export interface LoadSeedResult {
+    flows: number;
+    gates: number;
+}
+export declare function loadSeed(seedPath: string, flowRepo: IFlowRepository, gateRepo: IGateRepository, sqlite: InstanceType<typeof Database>, options?: LoadSeedOptions): Promise<LoadSeedResult>;

package/dist/config/seed-loader.js

@@ -0,0 +1,108 @@
+import { readFileSync, realpathSync } from "node:fs";
+import { relative, resolve, sep } from "node:path";
+import { SeedFileSchema } from "./zod-schemas.js";
+export async function loadSeed(seedPath, flowRepo, gateRepo, sqlite, options) {
+    const allowedRoot = options?.allowedRoot ?? process.cwd();
+    const resolvedRoot = resolve(allowedRoot);
+    const resolvedSeed = resolve(seedPath);
+    const lexicalRel = relative(resolvedRoot, resolvedSeed);
+    if (lexicalRel === ".." || lexicalRel.startsWith(`..${sep}`)) {
+        throw new Error(`Seed path escapes allowed root: ${resolvedSeed} is not under ${resolvedRoot}`);
+    }
+    const realSeed = realpathSync(resolvedSeed);
+    let realRoot;
+    try {
+        realRoot = realpathSync(resolvedRoot);
+    }
+    catch {
+        realRoot = resolvedRoot;
+    }
+    const realRel = relative(realRoot, realSeed);
+    if (realRel === ".." || realRel.startsWith(`..${sep}`)) {
+        throw new Error(`Seed path escapes allowed root: resolved symlink ${realSeed} is not under ${realRoot}`);
+    }
+    const raw = readFileSync(realSeed, "utf-8");
+    return parseSeedAndLoad(parseJson(raw, realSeed), flowRepo, gateRepo, sqlite);
+}
+function parseJson(raw, path) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`Invalid JSON in seed file: ${path}: ${msg}`, { cause: e });
+    }
+}
+async function parseSeedAndLoad(json, flowRepo, gateRepo, sqlite) {
+    const parsed = SeedFileSchema.parse(json);
+    sqlite.exec("BEGIN");
+    try {
+        // 1. Create gates first (transitions reference them by name)
+        const gateNameToId = new Map();
+        for (const g of parsed.gates) {
+            const gate = await gateRepo.create({
+                name: g.name,
+                type: g.type,
+                command: "command" in g ? g.command : undefined,
+                functionRef: "functionRef" in g ? g.functionRef : undefined,
+                apiConfig: "apiConfig" in g ? g.apiConfig : undefined,
+                timeoutMs: g.timeoutMs,
+                failurePrompt: g.failurePrompt,
+                timeoutPrompt: g.timeoutPrompt,
+            });
+            gateNameToId.set(g.name, gate.id);
+        }
+        // 2. Create flows, states, and transitions
+        for (const f of parsed.flows) {
+            const flow = await flowRepo.create({
+                name: f.name,
+                description: f.description,
+                entitySchema: f.entitySchema,
+                initialState: f.initialState,
+                maxConcurrent: f.maxConcurrent,
+                maxConcurrentPerRepo: f.maxConcurrentPerRepo,
+                gateTimeoutMs: f.gateTimeoutMs,
+                createdBy: f.createdBy,
+                discipline: f.discipline,
+                defaultModelTier: f.defaultModelTier,
+                timeoutPrompt: f.timeoutPrompt,
+            });
+            const flowStates = parsed.states.filter((s) => s.flowName === f.name);
+            for (const s of flowStates) {
+                await flowRepo.addState(flow.id, {
+                    name: s.name,
+                    modelTier: s.modelTier,
+                    mode: s.mode,
+                    promptTemplate: s.promptTemplate,
+                    constraints: s.constraints,
+                    onEnter: s.onEnter,
+                });
+            }
+            const flowTransitions = parsed.transitions.filter((t) => t.flowName === f.name);
+            for (const t of flowTransitions) {
+                if (t.gateName && !gateNameToId.has(t.gateName)) {
+                    throw new Error(`Transition from "${t.fromState}" to "${t.toState}" in flow "${f.name}" references unknown gate "${t.gateName}"`);
+                }
+                await flowRepo.addTransition(flow.id, {
+                    fromState: t.fromState,
+                    toState: t.toState,
+                    trigger: t.trigger,
+                    gateId: t.gateName ? gateNameToId.get(t.gateName) : undefined,
+                    condition: t.condition,
+                    priority: t.priority,
+                    spawnFlow: t.spawnFlow,
+                    spawnTemplate: t.spawnTemplate,
+                });
+            }
+        }
+        sqlite.exec("COMMIT");
+    }
+    catch (err) {
+        sqlite.exec("ROLLBACK");
+        throw err;
+    }
+    return {
+        flows: parsed.flows.length,
+        gates: parsed.gates.length,
+    };
+}

package/dist/config/zod-schemas.d.ts

@@ -0,0 +1,165 @@
+import { z } from "zod/v4";
+export declare const FlowDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    entitySchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    initialState: z.ZodString;
+    maxConcurrent: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxConcurrentPerRepo: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    affinityWindowMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    gateTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    version: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    discipline: z.ZodString;
+    defaultModelTier: z.ZodOptional<z.ZodString>;
+    timeoutPrompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const OnEnterSchema: z.ZodObject<{
+    command: z.ZodString;
+    artifacts: z.ZodArray<z.ZodString>;
+    timeout_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const StateDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    flowName: z.ZodString;
+    modelTier: z.ZodOptional<z.ZodString>;
+    mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        passive: "passive";
+        active: "active";
+    }>>>;
+    promptTemplate: z.ZodOptional<z.ZodString>;
+    constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    onEnter: z.ZodOptional<z.ZodObject<{
+        command: z.ZodString;
+        artifacts: z.ZodArray<z.ZodString>;
+        timeout_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const CommandGateSchema: z.ZodObject<{
+    name: z.ZodString;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    failurePrompt: z.ZodOptional<z.ZodString>;
+    timeoutPrompt: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"command">;
+    command: z.ZodString;
+}, z.core.$strip>;
+export declare const FunctionGateSchema: z.ZodObject<{
+    name: z.ZodString;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    failurePrompt: z.ZodOptional<z.ZodString>;
+    timeoutPrompt: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"function">;
+    functionRef: z.ZodString;
+}, z.core.$strip>;
+export declare const ApiGateSchema: z.ZodObject<{
+    name: z.ZodString;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    failurePrompt: z.ZodOptional<z.ZodString>;
+    timeoutPrompt: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"api">;
+    apiConfig: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const GateDefinitionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    name: z.ZodString;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    failurePrompt: z.ZodOptional<z.ZodString>;
+    timeoutPrompt: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"command">;
+    command: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodString;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    failurePrompt: z.ZodOptional<z.ZodString>;
+    timeoutPrompt: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"function">;
+    functionRef: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodString;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    failurePrompt: z.ZodOptional<z.ZodString>;
+    timeoutPrompt: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"api">;
+    apiConfig: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>], "type">;
+export declare const TransitionRuleSchema: z.ZodObject<{
+    flowName: z.ZodString;
+    fromState: z.ZodString;
+    toState: z.ZodString;
+    trigger: z.ZodString;
+    gateName: z.ZodOptional<z.ZodString>;
+    condition: z.ZodOptional<z.ZodString>;
+    priority: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    spawnFlow: z.ZodOptional<z.ZodString>;
+    spawnTemplate: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const SeedFileSchema: z.ZodObject<{
+    flows: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        entitySchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        initialState: z.ZodString;
+        maxConcurrent: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        maxConcurrentPerRepo: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        affinityWindowMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        gateTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        version: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        createdBy: z.ZodOptional<z.ZodString>;
+        discipline: z.ZodString;
+        defaultModelTier: z.ZodOptional<z.ZodString>;
+        timeoutPrompt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    states: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        flowName: z.ZodString;
+        modelTier: z.ZodOptional<z.ZodString>;
+        mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            passive: "passive";
+            active: "active";
+        }>>>;
+        promptTemplate: z.ZodOptional<z.ZodString>;
+        constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        onEnter: z.ZodOptional<z.ZodObject<{
+            command: z.ZodString;
+            artifacts: z.ZodArray<z.ZodString>;
+            timeout_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    gates: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        name: z.ZodString;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        failurePrompt: z.ZodOptional<z.ZodString>;
+        timeoutPrompt: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"command">;
+        command: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodString;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        failurePrompt: z.ZodOptional<z.ZodString>;
+        timeoutPrompt: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"function">;
+        functionRef: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodString;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        failurePrompt: z.ZodOptional<z.ZodString>;
+        timeoutPrompt: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"api">;
+        apiConfig: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>], "type">>>>;
+    transitions: z.ZodArray<z.ZodObject<{
+        flowName: z.ZodString;
+        fromState: z.ZodString;
+        toState: z.ZodString;
+        trigger: z.ZodString;
+        gateName: z.ZodOptional<z.ZodString>;
+        condition: z.ZodOptional<z.ZodString>;
+        priority: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        spawnFlow: z.ZodOptional<z.ZodString>;
+        spawnTemplate: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type FlowDefinition = z.infer<typeof FlowDefinitionSchema>;
+export type StateDefinition = z.infer<typeof StateDefinitionSchema>;
+export type GateDefinition = z.infer<typeof GateDefinitionSchema>;
+export type TransitionRule = z.infer<typeof TransitionRuleSchema>;
+export type SeedFile = z.infer<typeof SeedFileSchema>;