@xdelivered/emberflow 0.2.0

package/dist/server/agents/runManager.js

@@ -0,0 +1,259 @@
+import { randomUUID } from 'node:crypto';
+import { changedFiles, diffSince, isGitRepo, revert as gitRevert, snapshot } from './gitScope.js';
+import { buildPrompt } from './prompt.js';
+import { spawnCodex } from './codexAdapter.js';
+import { spawnClaude } from './claudeAdapter.js';
+import { isPathWithin } from '../pathSafety.js';
+/** Thrown by `start()`; `status` maps directly onto the HTTP status the endpoint should return. */
+export class AgentStartError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = 'AgentStartError';
+    }
+}
+/** Max number of terminal (done/error) runs kept around for diff/revert/replay before eviction. */
+const MAX_TERMINAL_RUNS = 20;
+/**
+ * Rejects anything that isn't a safe flow id. Operation ids are path-style
+ * (e.g. `"billing/charge"`, the on-disk relative path), so a slash-separated
+ * id is legitimate and must be allowed — only traversal (`..` segments),
+ * absolute ids, backslashes, and empty segments are rejected, and the file it
+ * resolves to must stay inside `apisDir`. Defense in depth — the agent
+ * sandbox already confines actual writes — but it keeps a bogus flowId like
+ * `"../../etc/passwd"` from ever becoming an existence-probe against paths
+ * outside apisDir.
+ */
+function isSafeFlowId(flowId, apisDir) {
+    if (!flowId)
+        return false;
+    return isPathWithin(apisDir, `${flowId}.json`);
+}
+/**
+ * Resolves a `new-operation` intent's user-supplied `location` (a folder path
+ * under `apisDir`, e.g. `"billing"` or `"billing/charges"`) to the directory
+ * the new operation file should be created in. An empty string or `"default"`
+ * both mean "the default API".
+ */
+function resolveLocationDir(location) {
+    const trimmed = location.trim();
+    return trimmed === '' ? 'default' : trimmed;
+}
+/** Same defense-in-depth as `isSafeFlowId`, but for a target *directory* rather than a flow file. */
+function isSafeLocationDir(dir, apisDir) {
+    return isPathWithin(apisDir, dir);
+}
+/**
+ * Owns in-flight coding-agent runs for a single project: spawns the adapter,
+ * buffers its events for SSE replay + live subscribers, and exposes
+ * git-scoped diff/revert against the snapshot taken at run start. One active
+ * run per project at a time.
+ */
+export class AgentRunManager {
+    projectDir;
+    apisDir;
+    pathOf;
+    availableNodes;
+    projectLanguage;
+    infrastructure;
+    runs = new Map();
+    activeRunId = null;
+    constructor(projectDir, apisDir, pathOf, 
+    /**
+     * Getter (not a static list) so the prompt always reflects the
+     * currently-registered node types, even if the registry is populated or
+     * changes after this manager is constructed.
+     */
+    availableNodes = () => [], 
+    /** The loaded project's authored language (`ProjectConfig.language`,
+     *  explicit-or-inferred), threaded into every prompt this manager builds.
+     *  Defaults to 'typescript' — the Emberflow repo itself, when constructed
+     *  without a loaded consumer project. */
+    projectLanguage = 'typescript', 
+    /**
+     * Getter (not a static value) for the loaded `emberflow/infrastructure.json`
+     * manifest, so every prompt reflects the manifest currently on disk — a scout
+     * run mid-session updates what later runs see. Returns null when the project
+     * hasn't been scouted or the file is malformed. Injected as a prompt preamble
+     * so agents REUSE known infrastructure instead of inventing parallel config.
+     */
+    infrastructure = () => null) {
+        this.projectDir = projectDir;
+        this.apisDir = apisDir;
+        this.pathOf = pathOf;
+        this.availableNodes = availableNodes;
+        this.projectLanguage = projectLanguage;
+        this.infrastructure = infrastructure;
+    }
+    /** Validates the project + flow, snapshots git, spawns the adapter, and returns the new run's id. */
+    start(intent, opts = {}) {
+        if (this.activeRunId) {
+            throw new AgentStartError('An agent run is already active for this project', 409);
+        }
+        if (!isGitRepo(this.projectDir)) {
+            throw new AgentStartError(`${this.projectDir} is not a git repository`, 400);
+        }
+        // `new-operation` creates a brand-new flow, so there's no existing
+        // flowId to validate against pathOf — it validates `location` instead.
+        // `setup-auth` targets an environment, not a flow file, and
+        // `setup-environments` targets the environments file itself, so
+        // neither has a relPath to resolve.
+        let relPath;
+        if (intent.action === 'new-operation') {
+            const dir = resolveLocationDir(intent.location);
+            if (!isSafeLocationDir(dir, this.apisDir)) {
+                throw new AgentStartError('Invalid location', 400);
+            }
+            relPath = dir;
+        }
+        else if (intent.action === 'setup-auth' ||
+            intent.action === 'setup-environments' ||
+            intent.action === 'scout-infrastructure') {
+            // No flow file: setup-auth targets an environment, setup-environments the
+            // environments file, and scout-infrastructure reads the whole project and
+            // writes emberflow/infrastructure.json — none has a relPath to resolve.
+            relPath = '';
+        }
+        else if (intent.action === 'ask') {
+            // `ask`'s flowId is optional: with one, resolve the op's relPath like
+            // edit-flow does; without, resolve to the apis root (empty relPath) —
+            // there's no specific operation file to point the prompt at.
+            if (intent.flowId) {
+                if (!isSafeFlowId(intent.flowId, this.apisDir)) {
+                    throw new AgentStartError('Invalid flowId', 400);
+                }
+                const found = this.pathOf(intent.flowId);
+                if (!found) {
+                    throw new AgentStartError(`Unknown flow: ${intent.flowId}`, 400);
+                }
+                relPath = found;
+            }
+            else {
+                relPath = '';
+            }
+        }
+        else {
+            if (!isSafeFlowId(intent.flowId, this.apisDir)) {
+                throw new AgentStartError('Invalid flowId', 400);
+            }
+            const found = this.pathOf(intent.flowId);
+            if (!found) {
+                throw new AgentStartError(`Unknown flow: ${intent.flowId}`, 400);
+            }
+            relPath = found;
+        }
+        this.pruneTerminalRuns();
+        const snap = snapshot(this.projectDir);
+        const prompt = buildPrompt(intent, this.apisDir, relPath, this.availableNodes(), this.projectLanguage, this.infrastructure());
+        const adapter = opts.agent === 'claude'
+            ? spawnClaude(prompt, this.projectDir, {
+                model: opts.model,
+                bin: process.env.EMBERFLOW_CLAUDE_BIN,
+            })
+            : spawnCodex(prompt, this.projectDir, {
+                model: opts.model,
+                reasoning: opts.reasoning ?? 'medium',
+                bin: process.env.EMBERFLOW_CODEX_BIN,
+            });
+        const id = randomUUID();
+        const run = { id, snapshot: snap, adapter, buffer: [], listeners: new Set(), status: 'running' };
+        this.runs.set(id, run);
+        this.activeRunId = id;
+        void this.consume(run);
+        return id;
+    }
+    /** Drains the adapter's events into the run's buffer, fanning each out to live subscribers. */
+    async consume(run) {
+        const emit = (event) => {
+            run.buffer.push(event);
+            for (const listener of run.listeners)
+                listener(event);
+        };
+        try {
+            for await (const event of run.adapter.events) {
+                // Clear the busy slot as soon as a terminal event is *observed*, not
+                // once the adapter's generator fully drains — a subscriber reacting
+                // synchronously to `done`/`error` (e.g. by starting a new run) must
+                // not race against this loop's own bookkeeping.
+                if (event.type === 'done') {
+                    run.status = 'done';
+                    this.clearActive(run.id);
+                }
+                else if (event.type === 'error') {
+                    run.status = 'error';
+                    this.clearActive(run.id);
+                }
+                emit(event);
+            }
+        }
+        catch (err) {
+            run.status = 'error';
+            this.clearActive(run.id);
+            emit({ type: 'error', text: err instanceof Error ? err.message : String(err) });
+        }
+        finally {
+            this.clearActive(run.id);
+        }
+    }
+    clearActive(id) {
+        if (this.activeRunId === id)
+            this.activeRunId = null;
+    }
+    /** Replay the buffer to the listener, then stream live events. Returns an unsubscribe fn. */
+    subscribe(id, listener) {
+        const run = this.runs.get(id);
+        if (!run)
+            return undefined;
+        for (const event of run.buffer)
+            listener(event);
+        run.listeners.add(listener);
+        return () => run.listeners.delete(listener);
+    }
+    has(id) {
+        return this.runs.has(id);
+    }
+    diff(id) {
+        const run = this.runs.get(id);
+        if (!run)
+            return undefined;
+        return {
+            diff: diffSince(this.projectDir, run.snapshot),
+            files: changedFiles(this.projectDir, run.snapshot),
+        };
+    }
+    revert(id) {
+        const run = this.runs.get(id);
+        if (!run)
+            return undefined;
+        const files = changedFiles(this.projectDir, run.snapshot);
+        gitRevert(this.projectDir, run.snapshot, files);
+        return { reverted: files };
+    }
+    cancel(id) {
+        const run = this.runs.get(id);
+        if (!run)
+            return false;
+        run.adapter.cancel();
+        return true;
+    }
+    /**
+     * Evicts oldest terminal (done|error) runs beyond MAX_TERMINAL_RUNS so the
+     * `runs` map — and each run's full event buffer — doesn't grow unbounded
+     * over a long-lived server process. The active run (if any) is never
+     * evicted; insertion order on the Map gives us oldest-first for free.
+     */
+    pruneTerminalRuns() {
+        const terminalIds = [];
+        for (const [id, run] of this.runs) {
+            if (run.status === 'done' || run.status === 'error')
+                terminalIds.push(id);
+        }
+        const excess = terminalIds.length - MAX_TERMINAL_RUNS;
+        if (excess <= 0)
+            return;
+        for (const id of terminalIds.slice(0, excess)) {
+            this.runs.delete(id);
+        }
+    }
+}

package/dist/server/agents/types.d.ts

@@ -0,0 +1,15 @@
+export type AgentKind = 'codex' | 'claude';
+export interface AgentEvent {
+    type: 'started' | 'message' | 'command' | 'mcp' | 'approval-request' | 'done' | 'error';
+    text?: string;
+    command?: string;
+    commandStatus?: 'in_progress' | 'completed' | 'failed';
+    exitCode?: number | null;
+    output?: string;
+    toolUseId?: string;
+    approvalId?: string;
+    usage?: Record<string, number>;
+    mcpServer?: string;
+    mcpTool?: string;
+    mcpStatus?: 'in_progress' | 'completed' | 'failed';
+}

package/dist/server/agents/types.js

@@ -0,0 +1 @@
+export {};

package/dist/server/apiStore.d.ts

@@ -0,0 +1,60 @@
+import type { AuthPolicy, HttpTrigger, WorkflowDefinition } from '../src/engine/index.js';
+export interface OpSummary {
+    id: string;
+    name: string;
+    path: string;
+    http?: HttpTrigger;
+}
+export interface FolderNode {
+    name: string;
+    folders: FolderNode[];
+    operations: OpSummary[];
+}
+export interface ApiNode {
+    name: string;
+    folders: FolderNode[];
+    operations: OpSummary[];
+}
+export interface ApiTree {
+    apis: ApiNode[];
+}
+/** File-backed store over an `apis/<api>/<folder…>/<op>.json` tree. Keys ops by
+ *  their in-file `id`; tracks each op's relative path (POSIX, no `.json`). */
+export declare class ApiStore {
+    readonly dir: string;
+    /** id → relative path (POSIX, no extension). Rebuilt on every scan. */
+    private index;
+    constructor(dir: string);
+    private sidecarFor;
+    /** Sidecar files come in two shapes: the legacy bare array (scenarios only —
+     *  still written when an op has no mocks, for human-editability/back-compat)
+     *  and `{ scenarios?, mocks? }`, used once an op carries op-level mocks. */
+    private withSidecar;
+    /** Reads just the sidecar's top-level `mocks`, ignoring `scenarios` — used
+     *  by `save` to preserve mocks when the incoming flow doesn't carry them. */
+    private readSidecarMocks;
+    /** Recursively collect operation files as { flow, relPath }. */
+    private scan;
+    list(): WorkflowDefinition[];
+    /** One entry per operation with its on-disk relative path and `http` metadata
+     *  (id/name/http from the file itself), for the studio's tree view. */
+    listSummaries(): OpSummary[];
+    /** True when an operation file already sits at `relPath` — used by
+     *  POST /operations to refuse to silently overwrite an existing op with a
+     *  brand-new one saved at the same path. */
+    existsAt(relPath: string): boolean;
+    load(id: string): WorkflowDefinition | undefined;
+    /** id → relative path. Always rescans so it reflects the current on-disk state
+     *  (files may be added/renamed/deleted out-of-band by a coding agent). */
+    pathOf(id: string): string | undefined;
+    tree(): ApiTree;
+    save(flow: WorkflowDefinition, relPath: string): void;
+    remove(id: string): boolean;
+    /** Resolves the effective auth policy for an operation: walks the op's path
+     *  from the API root down through each folder, reading `_meta.json`'s `auth`
+     *  (nearest ancestor default), then applies the op's own `http.auth`
+     *  override — `'none'` -> explicitly public (null), a policy object -> that
+     *  policy, `'inherit'`/absent -> the inherited default. Returns the
+     *  effective policy or null (no auth — public by default). */
+    resolveAuth(id: string): AuthPolicy | null;
+}

package/dist/server/apiStore.js

@@ -0,0 +1,249 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+/** File-backed store over an `apis/<api>/<folder…>/<op>.json` tree. Keys ops by
+ *  their in-file `id`; tracks each op's relative path (POSIX, no `.json`). */
+export class ApiStore {
+    dir;
+    /** id → relative path (POSIX, no extension). Rebuilt on every scan. */
+    index = new Map();
+    constructor(dir) {
+        this.dir = dir;
+        mkdirSync(this.dir, { recursive: true });
+    }
+    sidecarFor(relPath) {
+        return join(this.dir, ...relPath.split('/')) + '.scenarios.json';
+    }
+    /** Sidecar files come in two shapes: the legacy bare array (scenarios only —
+     *  still written when an op has no mocks, for human-editability/back-compat)
+     *  and `{ scenarios?, mocks? }`, used once an op carries op-level mocks. */
+    withSidecar(flow, relPath) {
+        const path = this.sidecarFor(relPath);
+        if (!existsSync(path))
+            return flow;
+        try {
+            const raw = JSON.parse(readFileSync(path, 'utf8'));
+            if (Array.isArray(raw)) {
+                return raw.length > 0 ? { ...flow, scenarios: raw } : flow;
+            }
+            if (raw && typeof raw === 'object') {
+                const { scenarios, mocks } = raw;
+                let out = flow;
+                if (Array.isArray(scenarios) && scenarios.length > 0)
+                    out = { ...out, scenarios };
+                if (mocks && typeof mocks === 'object')
+                    out = { ...out, mocks };
+                return out;
+            }
+            return flow;
+        }
+        catch (err) {
+            console.warn(`[apiStore] skipping unparseable ${relPath}.scenarios.json: ${String(err)}`);
+            return flow;
+        }
+    }
+    /** Reads just the sidecar's top-level `mocks`, ignoring `scenarios` — used
+     *  by `save` to preserve mocks when the incoming flow doesn't carry them. */
+    readSidecarMocks(relPath) {
+        const path = this.sidecarFor(relPath);
+        if (!existsSync(path))
+            return undefined;
+        try {
+            const raw = JSON.parse(readFileSync(path, 'utf8'));
+            if (Array.isArray(raw) || !raw || typeof raw !== 'object')
+                return undefined;
+            const { mocks } = raw;
+            return mocks && typeof mocks === 'object' ? mocks : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** Recursively collect operation files as { flow, relPath }. */
+    scan() {
+        const out = [];
+        this.index = new Map();
+        const walk = (absDir, relParts) => {
+            for (const entry of readdirSync(absDir)) {
+                const abs = join(absDir, entry);
+                if (statSync(abs).isDirectory()) {
+                    walk(abs, [...relParts, entry]);
+                    continue;
+                }
+                if (entry === '_meta.json')
+                    continue;
+                if (!entry.endsWith('.json') || entry.endsWith('.scenarios.json'))
+                    continue;
+                const relPath = [...relParts, entry.slice(0, -'.json'.length)].join('/');
+                try {
+                    const flow = JSON.parse(readFileSync(abs, 'utf8'));
+                    const existing = this.index.get(flow.id);
+                    if (existing !== undefined && existing !== relPath) {
+                        console.warn(`[apiStore] duplicate operation id "${flow.id}" at ${existing} and ${relPath} — only one is reachable`);
+                    }
+                    else {
+                        this.index.set(flow.id, relPath);
+                    }
+                    out.push({ flow, relPath });
+                }
+                catch (err) {
+                    console.warn(`[apiStore] skipping unparseable ${relPath}.json: ${String(err)}`);
+                }
+            }
+        };
+        walk(this.dir, []);
+        return out;
+    }
+    list() {
+        return this.scan().map(({ flow, relPath }) => this.withSidecar(flow, relPath));
+    }
+    /** One entry per operation with its on-disk relative path and `http` metadata
+     *  (id/name/http from the file itself), for the studio's tree view. */
+    listSummaries() {
+        return this.scan().map(({ flow, relPath }) => ({ id: flow.id, name: flow.name, path: relPath, http: flow.http }));
+    }
+    /** True when an operation file already sits at `relPath` — used by
+     *  POST /operations to refuse to silently overwrite an existing op with a
+     *  brand-new one saved at the same path. */
+    existsAt(relPath) {
+        const abs = join(this.dir, ...relPath.split('/')) + '.json';
+        return existsSync(abs);
+    }
+    load(id) {
+        const relPath = this.pathOf(id);
+        if (!relPath)
+            return undefined;
+        const abs = join(this.dir, ...relPath.split('/')) + '.json';
+        if (!existsSync(abs))
+            return undefined;
+        try {
+            const flow = JSON.parse(readFileSync(abs, 'utf8'));
+            return this.withSidecar(flow, relPath);
+        }
+        catch (err) {
+            console.warn(`[apiStore] skipping unparseable ${relPath}.json: ${String(err)}`);
+            return undefined;
+        }
+    }
+    /** id → relative path. Always rescans so it reflects the current on-disk state
+     *  (files may be added/renamed/deleted out-of-band by a coding agent). */
+    pathOf(id) {
+        this.scan();
+        return this.index.get(id);
+    }
+    tree() {
+        const ops = this.scan();
+        const apis = new Map();
+        const folderAt = (parent, name) => {
+            let f = parent.folders.find((x) => x.name === name);
+            if (!f) {
+                f = { name, folders: [], operations: [] };
+                parent.folders.push(f);
+            }
+            return f;
+        };
+        for (const { flow, relPath } of ops) {
+            const parts = relPath.split('/'); // [api, ...folders, opName]
+            const apiName = parts[0];
+            let api = apis.get(apiName);
+            if (!api) {
+                api = { name: apiName, folders: [], operations: [] };
+                apis.set(apiName, api);
+            }
+            const folderParts = parts.slice(1, -1);
+            let container = api;
+            for (const fp of folderParts)
+                container = folderAt(container, fp);
+            container.operations.push({ id: flow.id, name: flow.name, path: relPath, http: flow.http });
+        }
+        return { apis: [...apis.values()] };
+    }
+    save(flow, relPath) {
+        const abs = join(this.dir, ...relPath.split('/')) + '.json';
+        if (existsSync(abs)) {
+            try {
+                const existing = JSON.parse(readFileSync(abs, 'utf8'));
+                if (existing.id !== undefined && existing.id !== flow.id) {
+                    console.warn(`[apiStore] overwriting ${relPath} which held a different op id "${existing.id}"`);
+                }
+            }
+            catch {
+                // unparseable existing file — nothing sensible to compare, proceed with the write.
+            }
+        }
+        mkdirSync(dirname(abs), { recursive: true });
+        const { scenarios, mocks, ...rest } = flow;
+        writeFileSync(abs, `${JSON.stringify(rest, null, 2)}\n`, 'utf8');
+        const sidecar = this.sidecarFor(relPath);
+        // A flow argument that doesn't carry `mocks` at all (undefined — not an
+        // empty object) means the caller never touched op-level mocks (e.g. a
+        // scenario-only edit round-tripped through a client that doesn't forward
+        // unknown fields) — preserve whatever is already on disk rather than
+        // silently dropping it.
+        const effectiveMocks = mocks !== undefined ? mocks : this.readSidecarMocks(relPath);
+        const hasScenarios = scenarios !== undefined && scenarios.length > 0;
+        const hasMocks = effectiveMocks !== undefined && Object.keys(effectiveMocks).length > 0;
+        if (hasMocks) {
+            writeFileSync(sidecar, `${JSON.stringify({ ...(hasScenarios ? { scenarios } : {}), mocks: effectiveMocks }, null, 2)}\n`, 'utf8');
+        }
+        else if (hasScenarios) {
+            writeFileSync(sidecar, `${JSON.stringify(scenarios, null, 2)}\n`, 'utf8');
+        }
+        else if (existsSync(sidecar)) {
+            rmSync(sidecar);
+        }
+        this.index.set(flow.id, relPath);
+    }
+    remove(id) {
+        const relPath = this.pathOf(id);
+        if (!relPath)
+            return false;
+        const abs = join(this.dir, ...relPath.split('/')) + '.json';
+        if (!existsSync(abs))
+            return false;
+        rmSync(abs);
+        const sidecar = this.sidecarFor(relPath);
+        if (existsSync(sidecar))
+            rmSync(sidecar);
+        this.index.delete(id);
+        return true;
+    }
+    /** Resolves the effective auth policy for an operation: walks the op's path
+     *  from the API root down through each folder, reading `_meta.json`'s `auth`
+     *  (nearest ancestor default), then applies the op's own `http.auth`
+     *  override — `'none'` -> explicitly public (null), a policy object -> that
+     *  policy, `'inherit'`/absent -> the inherited default. Returns the
+     *  effective policy or null (no auth — public by default). */
+    resolveAuth(id) {
+        const relPath = this.pathOf(id);
+        if (!relPath)
+            return null;
+        const parts = relPath.split('/'); // [api, ...folders, opName]
+        let inherited = null;
+        for (let depth = 1; depth < parts.length; depth++) {
+            const metaPath = join(this.dir, ...parts.slice(0, depth), '_meta.json');
+            if (!existsSync(metaPath))
+                continue;
+            try {
+                const meta = JSON.parse(readFileSync(metaPath, 'utf8'));
+                if (meta.auth)
+                    inherited = meta.auth;
+            }
+            catch (err) {
+                // A present-but-corrupt _meta.json (partial write, typo, etc.) must
+                // never silently resolve to `null` (= public) — that's a fail-open
+                // security hole. Fail closed: throw and let the caller deny the op
+                // rather than mount it open. A merely ABSENT _meta.json is fine (see
+                // the `existsSync` check above) — only a broken one throws.
+                const metaRelPath = `${parts.slice(0, depth).join('/')}/_meta.json`;
+                throw new Error(`unparseable _meta.json at ${metaRelPath} — refusing to resolve auth (fail closed): ${String(err)}`);
+            }
+        }
+        const op = this.load(id);
+        const override = op?.http?.auth;
+        if (override === 'none')
+            return null;
+        if (override && override !== 'inherit')
+            return override;
+        return inherited;
+    }
+}

package/dist/server/auth/enforce.d.ts

@@ -0,0 +1 @@
+export { enforceAuth } from '../../src/engine/index.js';

package/dist/server/auth/enforce.js

@@ -0,0 +1,6 @@
+// Re-exports the shared enforceAuth from src/engine/authVerify.ts. Kept as its
+// own module (rather than importing src/engine directly at call sites) so the
+// server-side auth call path has a stable, server-scoped entry point mirroring
+// the file map in the plan; the underlying logic is shared with the
+// requireAuth node (src/nodes/requireAuth.ts) to avoid divergence.
+export { enforceAuth } from '../../src/engine/index.js';

package/dist/server/auth/types.d.ts

@@ -0,0 +1 @@
+export type { AuthPolicy, VerifyResult, Verifier } from '../../src/engine/index.js';

package/dist/server/auth/types.js

@@ -0,0 +1 @@
+export {};

package/dist/server/auth/verifiers.d.ts

@@ -0,0 +1 @@
+export { bearerVerifier, apiKeyVerifier, VerifierRegistry, createDefaultVerifierRegistry, } from '../../src/engine/index.js';

package/dist/server/auth/verifiers.js

@@ -0,0 +1,4 @@
+// Re-exports the shared, browser-safe implementation from src/engine/authVerify.ts
+// so server-side auth enforcement and the requireAuth node (bundled into the
+// studio browser build) share one implementation instead of two diverging copies.
+export { bearerVerifier, apiKeyVerifier, VerifierRegistry, createDefaultVerifierRegistry, } from '../../src/engine/index.js';

package/dist/server/authAttach.d.ts

@@ -0,0 +1,19 @@
+import type { EnvAuth } from './environments.js';
+type LoginCapture = NonNullable<EnvAuth['login']>['capture'];
+/**
+ * Attaches a captured credential value onto a headers object for a run.
+ * Pure and non-mutating: returns a NEW headers object.
+ * Additive + non-destructive — if the target header/cookie-name is already
+ * present, the input is returned unchanged (caller-explicit wins).
+ */
+export declare function attachCredential(headers: Record<string, unknown>, attach: EnvAuth['attach'], value: string): Record<string, unknown>;
+/**
+ * Extracts a captured credential value from a login response.
+ * Pure with respect to its inputs (no I/O of its own) — the caller performs
+ * the actual fetch and passes in the response-like object.
+ */
+export declare function captureCredential(res: {
+    headers: Headers;
+    json: () => Promise<any>;
+}, capture: LoginCapture): Promise<string | null>;
+export {};