@tacuchi/agent-workflow-cli 22.4.2 → 24.0.0

package/dist/application/claims-recovery.js

@@ -0,0 +1,338 @@
+/**
+ * Recovering a reservation whose owner never came back.
+ *
+ * The normal cycle needs none of this: completing, closing and cancelling all
+ * resolve a reservation through its owner. What is left is the run that simply
+ * died — no publication, no close, nothing terminal — and left a correlative held
+ * by a session that is never going to finish it. There is deliberately NO clock
+ * here: a reservation does not expire, because "it has been a while" is not
+ * evidence that nobody is coming, and a timer that frees a slot somebody is still
+ * writing into would be worse than the stranded number it fixes.
+ *
+ * So the release is explicit, authorized, and ORDERED. The order is the whole
+ * safety argument and it runs one way only:
+ *
+ *   1. the reservation is still exactly its own intact marker — otherwise the
+ *      bytes are somebody's work and this is not a recovery;
+ *   2. a revocation is SEALED, durably and irrevocably, scoped to that one claim;
+ *   3. and only then is the slot released.
+ *
+ * Step 2 before step 3 is not a preference. Once the file is gone the correlative
+ * is eligible again, so a late sealed proposal from the dead owner — one that was
+ * approved before the recovery and lands after it — would write a document onto a
+ * number somebody else may already hold. The fence is what makes that publication
+ * fail instead of collide, and a fence written after the release is a window. If
+ * the seal cannot be written, the recovery FAILS and releases nothing: a released
+ * slot with no fence is the one outcome this must never produce.
+ *
+ * The revocation belongs to the CLAIM, never to the session. The owner may be
+ * alive and working on other things, and revoking its whole session to reclaim
+ * one number would destroy work to tidy up a correlative.
+ */
+import { join } from "node:path";
+import { leadingCorrelative } from "../domain/correlative.js";
+import { reservationOwnerOf } from "../domain/reservation.js";
+import { appendClaimEvent, claimKey, isRevoked, openOwnerOfSlot, readClaimEvents, wasPublished, } from "./claims-ledger.js";
+import { withCwdLock } from "./lock-service.js";
+import { semanticDigest } from "./semantic-operation/protocol.js";
+import { CLOSED_MARKER, listSessionFolders } from "./session-resolver.js";
+/** The identity a reservation's slot maps to, or `null` for an unattributable one. */
+function claimOfSlot(slot) {
+    if (slot.owner === null)
+        return null;
+    return {
+        category: slot.category,
+        correlative: slot.correlative,
+        name: slot.name,
+        owner: slot.owner,
+    };
+}
+/**
+ * The slot a numbered file is, or `null` when it is a document.
+ *
+ * The LEDGER decides before the bytes do, and the order is the fix for a real
+ * defect: classifying from bytes alone made every empty numbered file an
+ * ownerless legacy placeholder — releasable with no fence — including a published
+ * document whose content happens to be empty, and including a reservation whose
+ * marker somebody emptied. In the first case a recovery deleted a published
+ * document; in the second it gave a correlative back while its real owner still
+ * held an open claim on it. Both times the record held the answer and only the
+ * bytes were consulted.
+ */
+function slotOf(category, fileName, text, events, activeOwners) {
+    const correlative = leadingCorrelative(fileName);
+    if (correlative === null)
+        return null;
+    const name = fileName.slice(correlative.length + 1);
+    const slot = { category, correlative, name };
+    // Published is terminal and terminal means "a document lives here": whatever
+    // its bytes look like, it is not a slot anybody may free.
+    if (wasPublished(events, slot))
+        return null;
+    const markerOwner = reservationOwnerOf(text);
+    const base = { path: `docs/${category}/${fileName}`, category, correlative, name };
+    if (markerOwner !== null) {
+        return {
+            ...base,
+            kind: "reservation",
+            owner: markerOwner,
+            ownerActive: activeOwners.has(markerOwner),
+            revoked: false,
+            intact: true,
+        };
+    }
+    // Real content and no marker: a document, by its bytes this time.
+    if (text.trim().length > 0)
+        return null;
+    // Empty. If the ledger still holds an open claim on this slot, it is that
+    // owner's reservation with damaged bytes — not nobody's placeholder.
+    const open = openOwnerOfSlot(events, slot);
+    if (open !== null) {
+        return {
+            ...base,
+            kind: "reservation",
+            owner: open.owner,
+            ownerActive: activeOwners.has(open.owner),
+            revoked: false,
+            intact: false,
+        };
+    }
+    return {
+        ...base,
+        kind: "legacy-placeholder",
+        owner: null,
+        ownerActive: null,
+        revoked: false,
+        intact: false,
+    };
+}
+/**
+ * Walk `docs/` into `into`, throwing on the first unreadable thing.
+ *
+ * The accumulator is the caller's so a failure still reports what it managed to
+ * see: an unreadable category is a different fact from an empty one, and folding
+ * the two would let the board say "no reservations" about a directory nobody
+ * could open.
+ */
+async function walkSlots(fs, docs, events, activeOwners, into) {
+    for (const category of await fs.list(docs)) {
+        if (category.type !== "dir")
+            continue;
+        for (const entry of await fs.list(category.path)) {
+            // The filename decides whether the bytes are worth reading at all. Reading
+            // every file in every docs/ subdirectory to then discard most of them on the
+            // first line of `slotOf` made a scan that runs on EVERY board projection pay
+            // for the whole corpus.
+            if (entry.type !== "file" || leadingCorrelative(entry.name) === null)
+                continue;
+            const slot = slotOf(category.name, entry.name, await fs.readText(entry.path), events, activeOwners);
+            if (slot === null)
+                continue;
+            const claim = claimOfSlot(slot);
+            slot.revoked = claim !== null && isRevoked(events, claim);
+            into.push(slot);
+        }
+    }
+}
+/**
+ * The session folders that are still open.
+ *
+ * Read once per scan, because the sanctioned action for a slot depends on it: a
+ * reservation of a live session is that session's to finish or close, and only a
+ * slot nobody is finishing may be recovered.
+ */
+async function activeSessionFolders(fs, paths) {
+    const active = new Set();
+    try {
+        for (const folder of await listSessionFolders(fs, paths.cwdSessionsDir())) {
+            if (await fs.exists(join(folder.path, CLOSED_MARKER)))
+                continue;
+            active.add(folder.name);
+        }
+    }
+    catch {
+        // An unreadable sessions dir means nobody can be proven alive. The fallback is
+        // the conservative one: with no owner known to be active, no slot is offered
+        // for recovery on the strength of liveness it could not check.
+    }
+    return active;
+}
+/**
+ * Every reservation and legacy placeholder under `docs/`.
+ *
+ * Walks each immediate subdirectory rather than a list of categories, for the
+ * same reason the close's sweep does: the claim mechanism is category-agnostic,
+ * and a hardcoded list is a second place to update the day something else claims
+ * a number.
+ *
+ * A failure comes back WITH its reason and with whatever was already seen. An
+ * unreadable `docs/` is not an empty one, and swallowing the difference would let
+ * the board answer "no reservations" about a directory nobody could open.
+ */
+export async function scanSlots(fs, paths) {
+    const docs = join(paths.workspaceDir(), "docs");
+    const slots = [];
+    const ledger = await readClaimEvents(fs, paths);
+    const activeOwners = await activeSessionFolders(fs, paths);
+    const sorted = () => slots.sort((a, b) => a.path.localeCompare(b.path));
+    if (!(await fs.exists(docs)))
+        return { slots };
+    try {
+        await walkSlots(fs, docs, ledger.events, activeOwners, slots);
+    }
+    catch (error) {
+        return {
+            slots: sorted(),
+            error: `no se pudo revisar docs/ en busca de reservas: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    return { slots: sorted() };
+}
+function sealRecovery(body) {
+    return { ...body, digest: semanticDigest(body) };
+}
+/** The proposal for one slot, or why there is none. */
+export async function previewRecovery(fs, paths, target) {
+    const scan = await scanSlots(fs, paths);
+    const slot = scan.slots.find((candidate) => candidate.path === target);
+    if (slot === undefined) {
+        return {
+            error: `'${target}' no es una reserva ni un placeholder legacy de este workspace`,
+            action: scan.error ??
+                "corré 'aw claims' para ver los correlativos recuperables; un documento publicado no se recupera",
+        };
+    }
+    return {
+        proposal: sealRecovery({
+            version: 1,
+            target: slot.path,
+            kind: slot.kind,
+            claim: claimOfSlot(slot),
+            requires_no_producer_confirmation: !slot.intact,
+            resuming: slot.revoked,
+        }),
+    };
+}
+/**
+ * Seal the fence, then release — and never the other way round.
+ *
+ * The whole thing runs under the workspace lock, which is not decoration: the
+ * check that the slot is still what the preview saw, the seal and the removal are
+ * three separate awaits, and without the lock a sanctioned publication could pass
+ * its own fence, take the lock, write its document and have this function delete
+ * it a moment later — leaving the correlative recorded as both spent-forever and
+ * eligible-again, with the published document silently gone. Its two siblings hold
+ * the lock across exactly this span for exactly this reason.
+ *
+ * It also re-derives its own proposal inside the lock instead of trusting the
+ * digest it was handed: the approval proves a person authorized THIS recovery, not
+ * that the world still looks the way it did when they read it.
+ */
+export async function applyRecovery(fs, paths, input) {
+    const outcome = await withCwdLock(fs, paths, () => recoverUnderLock(fs, paths, input));
+    if ("error" in outcome && "action" in outcome)
+        return outcome;
+    if ("error" in outcome) {
+        return {
+            error: `no se pudo tomar el candado del workspace: ${outcome.error}`,
+            action: "esperá a que otro flujo lo libere y volvé a aplicar la recuperación",
+        };
+    }
+    return outcome;
+}
+async function recoverUnderLock(fs, paths, input) {
+    const preview = await previewRecovery(fs, paths, input.target);
+    if ("error" in preview)
+        return preview;
+    const proposal = preview.proposal;
+    if (proposal.digest !== input.approval) {
+        return {
+            error: "la aprobación no corresponde a la recuperación vigente",
+            action: `volvé a mirarla con 'aw claims recover ${input.target}' y aprobá el digest que devuelve`,
+        };
+    }
+    if (proposal.requires_no_producer_confirmation && input.noProducerConfirmed !== true) {
+        return {
+            error: proposal.kind === "legacy-placeholder"
+                ? `'${input.target}' es un placeholder legacy ambiguo: sus bytes no prueban que nadie vaya a escribirlo`
+                : `'${input.target}' ya no tiene el marcador intacto de su dueño: alguien escribió ahí`,
+            action: "confirmá explícitamente que no queda productor capaz de escribir ese destino antes de liberar su correlativo",
+        };
+    }
+    const claim = proposal.claim;
+    if (claim !== null && !proposal.resuming) {
+        // The fence FIRST. If this throws, nothing was released and the slot is
+        // exactly as it was: the recovery failed, which is the correct outcome.
+        // Releasing first would leave a window where the correlative is eligible and
+        // a late sealed publication can still land on it.
+        await appendClaimEvent(fs, paths, {
+            at: new Date().toISOString(),
+            event: "revoked",
+            claim,
+            cause: `aw claims recover: recuperación autorizada de ${proposal.target}`,
+        });
+    }
+    // Recorded before the file goes, same reason as the close's release: a slot
+    // freed with no line saying so is the state this ledger exists to end. The
+    // identity is the SLOT's, so it joins to its own history by claimKey — an
+    // ownerless placeholder still records the category, correlative and name it
+    // gave back, and only its owner field says nobody held it.
+    await appendClaimEvent(fs, paths, {
+        at: new Date().toISOString(),
+        event: "released",
+        claim: claim ?? {
+            category: slotIdentityOf(proposal.target).category,
+            correlative: slotIdentityOf(proposal.target).correlative,
+            name: slotIdentityOf(proposal.target).name,
+            owner: LEGACY_OWNERLESS,
+        },
+        cause: claim === null
+            ? "aw claims recover: placeholder legacy liberado con confirmación explícita de que no queda productor"
+            : `aw claims recover: liberado tras revocar ${claimKey(claim)}`,
+    });
+    await fs.remove(join(paths.workspaceDir(), proposal.target));
+    return {
+        applied: {
+            target: proposal.target,
+            revoked: claim,
+            released: true,
+            resumed: proposal.resuming,
+            digest: proposal.digest,
+        },
+    };
+}
+/** The owner field of a slot that never had one. Never a session folder. */
+const LEGACY_OWNERLESS = "(placeholder legacy sin dueño)";
+/** `docs/<cat>/<NNN>-<name>` split the same way every ledger record splits it. */
+function slotIdentityOf(target) {
+    const parts = target.split("/");
+    const category = parts[1] ?? "";
+    const file = parts[2] ?? "";
+    const correlative = leadingCorrelative(file) ?? "";
+    return {
+        category,
+        correlative,
+        name: correlative.length > 0 ? file.slice(correlative.length + 1) : file,
+    };
+}
+/**
+ * The one action this slot sanctions, named per slot.
+ *
+ * A reservation of a live session is resumed or closed by its owner; only a slot
+ * nobody is finishing gets recovered. And a slot whose bytes are not its own
+ * intact marker carries the confirmation flag in the command itself, so the
+ * operator sees the extra assertion being asked of them before they type it.
+ */
+export function sanctionedActionFor(slot) {
+    // A live owner's reservation is NOT a recovery candidate. Naming the recovery
+    // here was destructive: the board handed the running session the one command
+    // that revokes its own slot irrevocably, and the flow reads this very field as
+    // "the sanctioned next command". Closing the owner releases an intact
+    // reservation as part of closing, which is the action that actually resolves it.
+    if (slot.ownerActive === true && slot.owner !== null) {
+        return `aw session-close --code ${slot.owner}`;
+    }
+    const confirm = slot.intact ? "" : " --confirm-no-producer";
+    return `aw claims recover ${slot.path}${confirm}`;
+}
+//# sourceMappingURL=claims-recovery.js.map

package/dist/application/claims-recovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claims-recovery.js","sourceRoot":"","sources":["../../src/application/claims-recovery.ts"],"names":[],"mappings":"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"}

package/dist/application/database-mcp-server.js

@@ -0,0 +1,168 @@
+import { encodeToolResponse, toolFailure } from "../domain/database-tools.js";
+const PROTOCOL_VERSION = "2025-06-18";
+/** JSON-RPC adapter over the shared catalog. It owns no tool rules. */
+export function createDatabaseMcpServer(deps) {
+    let lifecycle = "new";
+    const activeCalls = new Map();
+    const cancelledBeforeStart = new Set();
+    function reply(id, result) {
+        if (!isJsonRpcResponseId(id))
+            return;
+        deps.send({ jsonrpc: "2.0", id, result });
+    }
+    function replyError(id, code, message) {
+        if (!isJsonRpcResponseId(id))
+            return;
+        deps.send({ jsonrpc: "2.0", id, error: { code, message } });
+    }
+    function toolResult(response) {
+        return {
+            content: [{ type: "text", text: encodeToolResponse(response), mimeType: "application/json" }],
+            ...(response.success ? {} : { isError: true }),
+        };
+    }
+    async function dispatchToolCall(message) {
+        const params = isRecord(message.params) ? message.params : {};
+        const name = typeof params.name === "string" ? params.name : "";
+        const requestKey = requestIdKey(message.id);
+        // tools/call is a request, not a notification. Rejecting an id-less call
+        // prevents an untracked database operation that the client cannot cancel.
+        if (requestKey === undefined) {
+            replyError(message.id, -32600, "tools/call requiere un id de solicitud válido");
+            return true;
+        }
+        if (cancelledBeforeStart.delete(requestKey)) {
+            reply(message.id, toolResult(toolFailure("QUERY_CANCELLED", "La consulta fue cancelada.")));
+            return true;
+        }
+        const controller = new AbortController();
+        activeCalls.set(requestKey, controller);
+        try {
+            const outcome = await deps.catalog.call({
+                tool: name,
+                connection: deps.connection,
+                input: params.arguments,
+                signal: controller.signal,
+            });
+            reply(message.id, toolResult(outcome.response));
+        }
+        catch {
+            reply(message.id, toolResult(toolFailure("TOOL_EXECUTION_FAILED", "La tool no pudo completar la solicitud.")));
+        }
+        finally {
+            if (activeCalls.get(requestKey) === controller) {
+                activeCalls.delete(requestKey);
+            }
+        }
+        return true;
+    }
+    async function cancelToolCall(message) {
+        const params = isRecord(message.params) ? message.params : {};
+        const key = requestIdKey(params.requestId);
+        if (key === undefined)
+            return true;
+        const active = activeCalls.get(key);
+        if (active !== undefined) {
+            active.abort();
+            return true;
+        }
+        // A stdio transport may receive cancellation while an earlier call keeps a
+        // later request queued. Retain bounded intent so that later call never
+        // reaches PostgreSQL once it starts.
+        cancelledBeforeStart.add(key);
+        if (cancelledBeforeStart.size > 1_000) {
+            const oldest = cancelledBeforeStart.values().next().value;
+            if (oldest !== undefined)
+                cancelledBeforeStart.delete(oldest);
+        }
+        return true;
+    }
+    async function initialize(message) {
+        if (lifecycle !== "new") {
+            replyError(message.id, -32600, "initialize sólo puede llamarse una vez por sesión");
+            return true;
+        }
+        lifecycle = "awaiting-initialized";
+        reply(message.id, {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: { tools: {} },
+            serverInfo: { name: "agent-workflow-db", version: "1" },
+        });
+        return true;
+    }
+    async function initialized() {
+        if (lifecycle === "awaiting-initialized") {
+            lifecycle = "ready";
+            await deps.onHostLoadObserved?.();
+        }
+        return true;
+    }
+    function readyOrReply(message) {
+        if (lifecycle === "ready")
+            return true;
+        replyError(message.id, -32002, "Server not initialized");
+        return false;
+    }
+    async function listTools(message) {
+        if (!readyOrReply(message))
+            return true;
+        try {
+            const list = deps.catalog.list(deps.connection);
+            reply(message.id, "tools" in list.payload ? list.payload : toolResult(list.payload));
+        }
+        catch {
+            reply(message.id, toolResult(toolFailure("MCP_CONNECTION_INVALID", "No se pudo resolver la conexión solicitada.")));
+        }
+        return true;
+    }
+    async function callTool(message) {
+        if (!readyOrReply(message))
+            return true;
+        return await dispatchToolCall(message);
+    }
+    const handlers = {
+        initialize,
+        "notifications/initialized": async () => await initialized(),
+        "notifications/cancelled": async (message) => await cancelToolCall(message),
+        "tools/list": listTools,
+        "tools/call": callTool,
+    };
+    return {
+        async handle(message) {
+            if (!isJsonRpcEnvelope(message))
+                return false;
+            const handler = handlers[message.method];
+            if (handler !== undefined)
+                return await handler(message);
+            replyError(message.id, -32601, "Method not found");
+            return true;
+        },
+    };
+}
+/** Accept only envelopes for which every response remains valid JSON-RPC. */
+function isJsonRpcEnvelope(value) {
+    return (isRecord(value) &&
+        value.jsonrpc === "2.0" &&
+        typeof value.method === "string" &&
+        isJsonRpcId(value.id));
+}
+function isJsonRpcId(value) {
+    return value === undefined || isJsonRpcResponseId(value);
+}
+function isJsonRpcResponseId(value) {
+    return value === null || typeof value === "string" || isFiniteId(value);
+}
+function isFiniteId(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function requestIdKey(value) {
+    if (typeof value === "string")
+        return `string:${value}`;
+    if (typeof value === "number" && Number.isFinite(value))
+        return `number:${value}`;
+    return undefined;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+//# sourceMappingURL=database-mcp-server.js.map

package/dist/application/database-mcp-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-mcp-server.js","sourceRoot":"","sources":["../../src/application/database-mcp-server.ts"],"names":[],"mappings":"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"}

package/dist/application/database-mcp-stdio.js

@@ -0,0 +1,137 @@
+import { StringDecoder } from "node:string_decoder";
+import { MAX_TOOL_TRANSPORT_INPUT_BYTES } from "../domain/database-tools.js";
+import { createDatabaseMcpServer } from "./database-mcp-server.js";
+// The RPC envelope is allowed a small fixed overhead beyond the canonical 1
+// MiB tool input. The shared catalog still makes the exact input decision.
+const MAX_MCP_INPUT_FRAME_BYTES = MAX_TOOL_TRANSPORT_INPUT_BYTES;
+/**
+ * Line-framed stdio transport. stdout is exclusively JSON-RPC; malformed input
+ * is diagnosed on stderr and cannot corrupt a later valid request.
+ */
+export function runDatabaseMcpStdio(deps) {
+    const server = createDatabaseMcpServer({
+        send: (message) => deps.output.write(`${JSON.stringify(message)}\n`),
+        catalog: deps.catalog,
+        connection: deps.connection,
+        ...(deps.onHostLoadObserved === undefined
+            ? {}
+            : { onHostLoadObserved: deps.onHostLoadObserved }),
+    });
+    const frames = {
+        buffer: "",
+        bufferedBytes: 0,
+        discardingOversizedLine: false,
+        decoder: new StringDecoder("utf8"),
+    };
+    let queue = Promise.resolve();
+    function enqueue(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            deps.diagnostics.write("aw mcp serve-db: línea JSON-RPC inválida descartada\n");
+            return;
+        }
+        // Cancellation must not wait behind a running database call in the serial
+        // queue. All other frames retain order, including the lifecycle sequence.
+        if (isCancellationNotification(message)) {
+            void server.handle(message).catch(() => {
+                deps.diagnostics.write("aw mcp serve-db: línea JSON-RPC inválida descartada\n");
+            });
+            return;
+        }
+        queue = queue.then(async () => {
+            try {
+                await server.handle(message);
+            }
+            catch {
+                deps.diagnostics.write("aw mcp serve-db: línea JSON-RPC inválida descartada\n");
+            }
+        });
+    }
+    return new Promise((resolve) => {
+        let ended = false;
+        const finish = () => {
+            if (ended)
+                return;
+            ended = true;
+            // An unterminated tail is not a JSON-RPC frame. Do not enqueue it, but
+            // flush the decoder so no multibyte bytes remain retained by the stream.
+            if (!frames.discardingOversizedLine)
+                frames.buffer += frames.decoder.end();
+            void queue.then(() => resolve());
+        };
+        deps.input.on("data", (chunk) => {
+            const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            enqueueConsumption(consumeChunk(frames, bytes), deps, enqueue);
+        });
+        deps.input.on("end", finish);
+        deps.input.on("close", finish);
+    });
+}
+function isCancellationNotification(message) {
+    return (message !== null &&
+        typeof message === "object" &&
+        !Array.isArray(message) &&
+        message.method === "notifications/cancelled");
+}
+/**
+ * Splits raw bytes at newline boundaries before decoding. This matters for an
+ * oversized frame already terminated in the same chunk: appending/splitting a
+ * decoded 100 MiB string merely to reject it would defeat the input bound.
+ */
+function consumeChunk(state, bytes) {
+    const frames = [];
+    let oversizedFrames = 0;
+    let offset = 0;
+    while (offset < bytes.length) {
+        const newline = bytes.indexOf(0x0a, offset);
+        const end = newline < 0 ? bytes.length : newline + 1;
+        const segment = bytes.subarray(offset, end);
+        if (state.discardingOversizedLine) {
+            if (newline >= 0) {
+                state.discardingOversizedLine = false;
+                state.decoder = new StringDecoder("utf8");
+            }
+            offset = end;
+            continue;
+        }
+        if (state.bufferedBytes + segment.length > MAX_MCP_INPUT_FRAME_BYTES) {
+            state.buffer = "";
+            state.bufferedBytes = 0;
+            state.decoder = new StringDecoder("utf8");
+            state.discardingOversizedLine = newline < 0;
+            oversizedFrames += 1;
+            offset = end;
+            continue;
+        }
+        state.bufferedBytes += segment.length;
+        state.buffer += state.decoder.write(segment);
+        if (newline >= 0)
+            consumeCompleteLine(state, frames);
+        offset = end;
+    }
+    return { frames, oversizedFrames };
+}
+function consumeCompleteLine(state, frames) {
+    const newline = state.buffer.indexOf("\n");
+    if (newline < 0)
+        return;
+    const trimmed = state.buffer.slice(0, newline).replace(/\r$/, "").trim();
+    state.buffer = state.buffer.slice(newline + 1);
+    state.bufferedBytes = 0;
+    if (trimmed.length > 0)
+        frames.push(trimmed);
+}
+function reportOversizedFrames(output, count) {
+    for (let index = 0; index < count; index += 1) {
+        output.write("aw mcp serve-db: frame JSON-RPC demasiado grande descartado\n");
+    }
+}
+function enqueueConsumption(consumed, deps, enqueue) {
+    reportOversizedFrames(deps.diagnostics, consumed.oversizedFrames);
+    for (const frame of consumed.frames)
+        enqueue(frame);
+}
+//# sourceMappingURL=database-mcp-stdio.js.map