@femtomc/mu-control-plane 26.2.28

package/dist/command_journal.js

@@ -0,0 +1,197 @@
+import { appendJsonl, readJsonl } from "@femtomc/mu-core/node";
+import { z } from "zod";
+import { CommandRecordSchema, correlationFromCommandRecord } from "./command_record.js";
+import { assertValidTransition, isTerminalCommandState, lifecycleEventTypeForState, } from "./command_state.js";
+import { CorrelationMetadataSchema } from "./models.js";
+export const CommandLifecycleJournalEntrySchema = z.object({
+    kind: z.literal("command.lifecycle"),
+    ts_ms: z.number().int(),
+    event_type: z.string().min(1),
+    command: CommandRecordSchema,
+    correlation: CorrelationMetadataSchema,
+});
+export const MutatingDomainJournalEntrySchema = z.object({
+    kind: z.literal("domain.mutating"),
+    ts_ms: z.number().int(),
+    event_type: z.string().min(1),
+    payload: z.record(z.string(), z.unknown()),
+    correlation: CorrelationMetadataSchema,
+});
+export const CommandJournalEntrySchema = z.discriminatedUnion("kind", [
+    CommandLifecycleJournalEntrySchema,
+    MutatingDomainJournalEntrySchema,
+]);
+function orderCommands(a, b) {
+    if (a.created_at_ms !== b.created_at_ms) {
+        return a.created_at_ms - b.created_at_ms;
+    }
+    return a.command_id.localeCompare(b.command_id);
+}
+function cloneCommandRecord(record) {
+    return CommandRecordSchema.parse(record);
+}
+function cloneLifecycleEntry(entry) {
+    return CommandLifecycleJournalEntrySchema.parse(entry);
+}
+function cloneMutatingEntry(entry) {
+    return MutatingDomainJournalEntrySchema.parse(entry);
+}
+export class CommandJournal {
+    #path;
+    #loaded = false;
+    #entries = [];
+    #latestByCommandId = new Map();
+    #lifecycleByCommandId = new Map();
+    #mutatingByCommandId = new Map();
+    constructor(path) {
+        this.#path = path;
+    }
+    get path() {
+        return this.#path;
+    }
+    async load() {
+        const rows = await readJsonl(this.#path);
+        const entries = [];
+        const latestByCommandId = new Map();
+        const lifecycleByCommandId = new Map();
+        const mutatingByCommandId = new Map();
+        for (let idx = 0; idx < rows.length; idx++) {
+            const parsed = CommandJournalEntrySchema.safeParse(rows[idx]);
+            if (!parsed.success) {
+                throw new Error(`invalid command journal row ${idx}: ${parsed.error.message}`);
+            }
+            const entry = parsed.data;
+            entries.push(entry);
+            if (entry.kind === "command.lifecycle") {
+                latestByCommandId.set(entry.command.command_id, entry.command);
+                const lifecycle = lifecycleByCommandId.get(entry.command.command_id) ?? [];
+                lifecycle.push(entry);
+                lifecycleByCommandId.set(entry.command.command_id, lifecycle);
+            }
+            else {
+                const arr = mutatingByCommandId.get(entry.correlation.command_id) ?? [];
+                arr.push(entry);
+                mutatingByCommandId.set(entry.correlation.command_id, arr);
+            }
+        }
+        this.#entries = entries;
+        this.#latestByCommandId.clear();
+        this.#lifecycleByCommandId.clear();
+        this.#mutatingByCommandId.clear();
+        for (const [key, value] of latestByCommandId.entries()) {
+            this.#latestByCommandId.set(key, cloneCommandRecord(value));
+        }
+        for (const [key, value] of lifecycleByCommandId.entries()) {
+            this.#lifecycleByCommandId.set(key, value.map((entry) => cloneLifecycleEntry(entry)));
+        }
+        for (const [key, value] of mutatingByCommandId.entries()) {
+            this.#mutatingByCommandId.set(key, value.map((entry) => cloneMutatingEntry(entry)));
+        }
+        this.#loaded = true;
+    }
+    async #ensureLoaded() {
+        if (!this.#loaded) {
+            await this.load();
+        }
+    }
+    get(commandId) {
+        const record = this.#latestByCommandId.get(commandId);
+        return record ? cloneCommandRecord(record) : null;
+    }
+    lifecycleEvents(commandId) {
+        const rows = this.#lifecycleByCommandId.get(commandId) ?? [];
+        return rows.map((entry) => cloneLifecycleEntry(entry));
+    }
+    hasMutatingEvents(commandId) {
+        const rows = this.#mutatingByCommandId.get(commandId);
+        return (rows?.length ?? 0) > 0;
+    }
+    mutatingEvents(commandId) {
+        const rows = this.#mutatingByCommandId.get(commandId) ?? [];
+        return rows.map((entry) => cloneMutatingEntry(entry));
+    }
+    nonTerminalCommands() {
+        const out = [];
+        for (const record of this.#latestByCommandId.values()) {
+            if (!isTerminalCommandState(record.state)) {
+                out.push(cloneCommandRecord(record));
+            }
+        }
+        out.sort(orderCommands);
+        return out;
+    }
+    snapshot() {
+        const latestByCommandId = new Map();
+        for (const [key, value] of this.#latestByCommandId.entries()) {
+            latestByCommandId.set(key, cloneCommandRecord(value));
+        }
+        const lifecycleByCommandId = new Map();
+        for (const [key, value] of this.#lifecycleByCommandId.entries()) {
+            lifecycleByCommandId.set(key, value.map((entry) => cloneLifecycleEntry(entry)));
+        }
+        const mutatingByCommandId = new Map();
+        for (const [key, value] of this.#mutatingByCommandId.entries()) {
+            mutatingByCommandId.set(key, value.map((entry) => cloneMutatingEntry(entry)));
+        }
+        return {
+            entries: this.#entries.map((entry) => CommandJournalEntrySchema.parse(entry)),
+            latestByCommandId,
+            lifecycleByCommandId,
+            mutatingByCommandId,
+        };
+    }
+    async appendLifecycle(command, opts = {}) {
+        await this.#ensureLoaded();
+        const parsed = CommandRecordSchema.parse(command);
+        const previous = this.#latestByCommandId.get(parsed.command_id);
+        if (previous) {
+            assertValidTransition(previous.state, parsed.state);
+            if (parsed.created_at_ms !== previous.created_at_ms) {
+                throw new Error(`command ${parsed.command_id} created_at_ms changed across transitions (${previous.created_at_ms} -> ${parsed.created_at_ms})`);
+            }
+            if (parsed.updated_at_ms < previous.updated_at_ms) {
+                throw new Error(`command ${parsed.command_id} updated_at_ms regressed (${previous.updated_at_ms} -> ${parsed.updated_at_ms})`);
+            }
+        }
+        const eventType = opts.eventType ?? lifecycleEventTypeForState(parsed.state);
+        const correlation = correlationFromCommandRecord(parsed);
+        const entry = CommandLifecycleJournalEntrySchema.parse({
+            kind: "command.lifecycle",
+            ts_ms: Math.trunc(opts.tsMs ?? parsed.updated_at_ms),
+            event_type: eventType,
+            command: parsed,
+            correlation,
+        });
+        await appendJsonl(this.#path, entry);
+        this.#entries.push(entry);
+        this.#latestByCommandId.set(parsed.command_id, cloneCommandRecord(parsed));
+        const lifecycle = this.#lifecycleByCommandId.get(parsed.command_id) ?? [];
+        lifecycle.push(cloneLifecycleEntry(entry));
+        this.#lifecycleByCommandId.set(parsed.command_id, lifecycle);
+    }
+    async appendMutatingDomainEvent(opts) {
+        await this.#ensureLoaded();
+        const parsedCommand = CommandRecordSchema.parse(opts.command);
+        const payload = opts.payload;
+        if (typeof payload !== "object" || payload == null || Array.isArray(payload)) {
+            throw new TypeError("payload must be an object");
+        }
+        const correlation = CorrelationMetadataSchema.parse({
+            ...correlationFromCommandRecord(parsedCommand),
+            state: opts.state ?? parsedCommand.state,
+            error_code: opts.errorCode ?? parsedCommand.error_code ?? null,
+        });
+        const entry = MutatingDomainJournalEntrySchema.parse({
+            kind: "domain.mutating",
+            ts_ms: Math.trunc(opts.tsMs ?? parsedCommand.updated_at_ms),
+            event_type: opts.eventType,
+            payload,
+            correlation,
+        });
+        await appendJsonl(this.#path, entry);
+        this.#entries.push(entry);
+        const rows = this.#mutatingByCommandId.get(correlation.command_id) ?? [];
+        rows.push(cloneMutatingEntry(entry));
+        this.#mutatingByCommandId.set(correlation.command_id, rows);
+    }
+}

package/dist/command_parser.d.ts

@@ -0,0 +1,31 @@
+export type CommandInvocation = "slash" | "mu_bang" | "mu_question";
+export type ParsedCommand = {
+    kind: "noop";
+    reason: "not_command" | "empty_input";
+    raw: string;
+} | {
+    kind: "invalid";
+    reason: "empty_command" | "missing_command_id";
+    raw: string;
+} | {
+    kind: "command";
+    invocation: CommandInvocation;
+    requestedMode: "auto" | "mutation" | "readonly";
+    commandKey: string;
+    args: string[];
+    normalized: string;
+} | {
+    kind: "confirm";
+    invocation: CommandInvocation;
+    requestedMode: "auto" | "mutation" | "readonly";
+    commandId: string;
+    normalized: string;
+} | {
+    kind: "cancel";
+    invocation: CommandInvocation;
+    requestedMode: "auto" | "mutation" | "readonly";
+    commandId: string;
+    normalized: string;
+};
+export declare function parseSeriousWorkCommand(raw: string): ParsedCommand;
+//# sourceMappingURL=command_parser.d.ts.map

package/dist/command_parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command_parser.d.ts","sourceRoot":"","sources":["../src/command_parser.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,SAAS,GAAG,aAAa,CAAC;AAEpE,MAAM,MAAM,aAAa,GACtB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,aAAa,GAAG,aAAa,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GACpE;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,eAAe,GAAG,oBAAoB,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAChF;IACA,IAAI,EAAE,SAAS,CAAC;IAChB,UAAU,EAAE,iBAAiB,CAAC;IAC9B,aAAa,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC;IAChD,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CAClB,GACD;IACA,IAAI,EAAE,SAAS,CAAC;IAChB,UAAU,EAAE,iBAAiB,CAAC;IAC9B,aAAa,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CAClB,GACD;IACA,IAAI,EAAE,QAAQ,CAAC;IACf,UAAU,EAAE,iBAAiB,CAAC;IAC9B,aAAa,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CAClB,CAAC;AA8FL,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAwDlE"}

package/dist/command_parser.js

@@ -0,0 +1,130 @@
+const KNOWN_THREE_TOKEN_COMMANDS = new Set([
+    "issue dep add",
+    "issue dep remove",
+    "kill-switch set",
+    "rate-limit override",
+]);
+const KNOWN_TWO_TOKEN_COMMANDS = new Set([
+    "issue get",
+    "issue list",
+    "issue create",
+    "issue update",
+    "issue claim",
+    "issue close",
+    "forum read",
+    "forum post",
+    "audit get",
+    "link begin",
+    "link finish",
+    "unlink self",
+    "grant scope",
+    "policy update",
+    "dlq list",
+    "dlq inspect",
+    "dlq replay",
+    "run start",
+    "run resume",
+]);
+const KNOWN_ONE_TOKEN_COMMANDS = new Set(["status", "ready", "revoke"]);
+function parseInvocation(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    const slashMatch = /^\/mu(?:\s+(.*))?$/.exec(trimmed);
+    if (slashMatch) {
+        return {
+            invocation: "slash",
+            requestedMode: "auto",
+            body: (slashMatch[1] ?? "").trim(),
+        };
+    }
+    const textMatch = /^mu([!?])(?:\s+(.*))?$/.exec(trimmed);
+    if (!textMatch) {
+        return null;
+    }
+    return {
+        invocation: textMatch[1] === "!" ? "mu_bang" : "mu_question",
+        requestedMode: textMatch[1] === "!" ? "mutation" : "readonly",
+        body: (textMatch[2] ?? "").trim(),
+    };
+}
+function splitTokens(body) {
+    return body
+        .split(/\s+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
+}
+function deriveCommandKey(tokensLower) {
+    if (tokensLower.length >= 3) {
+        const key = `${tokensLower[0]} ${tokensLower[1]} ${tokensLower[2]}`;
+        if (KNOWN_THREE_TOKEN_COMMANDS.has(key)) {
+            return { commandKey: key, tokenCount: 3 };
+        }
+    }
+    if (tokensLower.length >= 2) {
+        const key = `${tokensLower[0]} ${tokensLower[1]}`;
+        if (KNOWN_TWO_TOKEN_COMMANDS.has(key)) {
+            return { commandKey: key, tokenCount: 2 };
+        }
+    }
+    if (KNOWN_ONE_TOKEN_COMMANDS.has(tokensLower[0])) {
+        return { commandKey: tokensLower[0], tokenCount: 1 };
+    }
+    if (tokensLower.length >= 2) {
+        return { commandKey: `${tokensLower[0]} ${tokensLower[1]}`, tokenCount: 2 };
+    }
+    return { commandKey: tokensLower[0], tokenCount: 1 };
+}
+export function parseSeriousWorkCommand(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+        return { kind: "noop", reason: "empty_input", raw };
+    }
+    const invocation = parseInvocation(raw);
+    if (!invocation) {
+        return { kind: "noop", reason: "not_command", raw };
+    }
+    if (invocation.body.length === 0) {
+        return { kind: "invalid", reason: "empty_command", raw };
+    }
+    const tokens = splitTokens(invocation.body);
+    if (tokens.length === 0) {
+        return { kind: "invalid", reason: "empty_command", raw };
+    }
+    const lower = tokens.map((token) => token.toLowerCase());
+    if (lower[0] === "confirm") {
+        if (!tokens[1]) {
+            return { kind: "invalid", reason: "missing_command_id", raw };
+        }
+        return {
+            kind: "confirm",
+            invocation: invocation.invocation,
+            requestedMode: invocation.requestedMode,
+            commandId: tokens[1],
+            normalized: `confirm ${tokens[1]}`,
+        };
+    }
+    if (lower[0] === "cancel") {
+        if (!tokens[1]) {
+            return { kind: "invalid", reason: "missing_command_id", raw };
+        }
+        return {
+            kind: "cancel",
+            invocation: invocation.invocation,
+            requestedMode: invocation.requestedMode,
+            commandId: tokens[1],
+            normalized: `cancel ${tokens[1]}`,
+        };
+    }
+    const { commandKey, tokenCount } = deriveCommandKey(lower);
+    const args = tokens.slice(tokenCount);
+    return {
+        kind: "command",
+        invocation: invocation.invocation,
+        requestedMode: invocation.requestedMode,
+        commandKey,
+        args,
+        normalized: [commandKey, ...args].join(" ").trim(),
+    };
+}

package/dist/command_pipeline.d.ts

@@ -0,0 +1,100 @@
+import { CommandContextResolver } from "./command_context.js";
+import { type CommandRecord, type CommandRecordTraceUpdate } from "./command_record.js";
+import { ConfirmationManager } from "./confirmation_manager.js";
+import { IdentityStore } from "./identity_store.js";
+import type { MessagingMetaAgentRuntime } from "./meta_agent.js";
+import { type InboundEnvelope } from "./models.js";
+import { MuCliCommandSurface, type MuCliRunnerLike } from "./mu_cli_runner.js";
+import { PolicyEngine } from "./policy.js";
+import type { ControlPlaneRuntime } from "./runtime.js";
+export type CommandPipelineResult = {
+    kind: "noop";
+    reason: string;
+} | {
+    kind: "invalid";
+    reason: string;
+} | {
+    kind: "meta_response";
+    message: string;
+} | {
+    kind: "denied";
+    reason: string;
+} | {
+    kind: "awaiting_confirmation";
+    command: CommandRecord;
+} | {
+    kind: "completed";
+    command: CommandRecord;
+} | {
+    kind: "cancelled";
+    command: CommandRecord;
+} | {
+    kind: "expired";
+    command: CommandRecord;
+} | {
+    kind: "deferred";
+    command: CommandRecord;
+} | {
+    kind: "failed";
+    command: CommandRecord;
+    reason: string;
+};
+export type MutationCommandExecutionEvent = {
+    eventType: string;
+    payload: Record<string, unknown>;
+};
+export type CommandExecutionTrace = Pick<CommandRecordTraceUpdate, "metaSessionId" | "metaTurnId" | "cliInvocationId" | "cliCommandKind" | "runRootId">;
+export type MutationCommandExecutionResult = {
+    terminalState: "completed";
+    result?: Record<string, unknown> | null;
+    errorCode?: string | null;
+    mutatingEvents?: readonly MutationCommandExecutionEvent[];
+    trace?: CommandExecutionTrace;
+} | {
+    terminalState: "failed";
+    errorCode: string;
+    mutatingEvents?: readonly MutationCommandExecutionEvent[];
+    trace?: CommandExecutionTrace;
+} | {
+    terminalState: "cancelled";
+    errorCode?: string | null;
+    mutatingEvents?: readonly MutationCommandExecutionEvent[];
+    trace?: CommandExecutionTrace;
+} | {
+    terminalState: "deferred";
+    retryAtMs: number;
+    errorCode?: string | null;
+    mutatingEvents?: readonly MutationCommandExecutionEvent[];
+    trace?: CommandExecutionTrace;
+};
+export type MutationCommandExecutor = (record: CommandRecord) => Promise<MutationCommandExecutionResult | null>;
+export type ReadonlyCommandExecutor = (record: CommandRecord) => Promise<Record<string, unknown> | null>;
+export type ControlPlaneCommandPipelineOpts = {
+    runtime: ControlPlaneRuntime;
+    identityStore?: IdentityStore;
+    policyEngine?: PolicyEngine;
+    policyPath?: string;
+    confirmationTtlMs?: number;
+    nowMs?: () => number;
+    commandIdFactory?: () => string;
+    cliInvocationIdFactory?: () => string;
+    mutationExecutor?: MutationCommandExecutor;
+    readonlyExecutor?: ReadonlyCommandExecutor;
+    metaAgent?: MessagingMetaAgentRuntime | null;
+    contextResolver?: CommandContextResolver;
+    cliCommandSurface?: MuCliCommandSurface | null;
+    cliRunner?: MuCliRunnerLike | null;
+};
+export declare class ControlPlaneCommandPipeline {
+    #private;
+    readonly runtime: ControlPlaneRuntime;
+    readonly identities: IdentityStore;
+    readonly policy: PolicyEngine;
+    readonly confirmations: ConfirmationManager;
+    constructor(opts: ControlPlaneCommandPipelineOpts);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    handleInbound(inboundInput: InboundEnvelope): Promise<CommandPipelineResult>;
+    expirePendingConfirmations(nowMs?: number): Promise<CommandRecord[]>;
+}
+//# sourceMappingURL=command_pipeline.d.ts.map

package/dist/command_pipeline.d.ts.map

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