@femtomc/mu-control-plane 26.2.28

package/dist/identity_store.js

@@ -0,0 +1,323 @@
+import { appendJsonl, readJsonl } from "@femtomc/mu-core/node";
+import { z } from "zod";
+import { AssuranceTierSchema } from "./models.js";
+export const ChannelSchema = z.enum(["slack", "discord", "telegram"]);
+export const DeprecatedChannelSchema = z.enum(["imessage"]);
+export const CHANNEL_ASSURANCE_TIERS = {
+    slack: "tier_a",
+    discord: "tier_a",
+    telegram: "tier_b",
+};
+export function assuranceTierForChannel(channel) {
+    return CHANNEL_ASSURANCE_TIERS[channel];
+}
+export const IdentityBindingStatusSchema = z.enum(["active", "unlinked", "revoked"]);
+export const IdentityBindingSchema = z.object({
+    binding_id: z.string().min(1),
+    operator_id: z.string().min(1),
+    channel: ChannelSchema,
+    channel_tenant_id: z.string().min(1),
+    channel_actor_id: z.string().min(1),
+    assurance_tier: AssuranceTierSchema,
+    scopes: z.array(z.string().min(1)).default([]),
+    status: IdentityBindingStatusSchema,
+    linked_at_ms: z.number().int(),
+    updated_at_ms: z.number().int(),
+    unlinked_at_ms: z.number().int().nullable().default(null),
+    revoked_at_ms: z.number().int().nullable().default(null),
+    revoked_by_binding_id: z.string().min(1).nullable().default(null),
+    revoke_reason: z.string().nullable().default(null),
+});
+export const IdentityLinkEntrySchema = z.object({
+    kind: z.literal("link"),
+    ts_ms: z.number().int(),
+    binding: IdentityBindingSchema,
+});
+export const IdentityUnlinkEntrySchema = z.object({
+    kind: z.literal("unlink"),
+    ts_ms: z.number().int(),
+    binding_id: z.string().min(1),
+    actor_binding_id: z.string().min(1),
+    reason: z.string().nullable().default(null),
+});
+export const IdentityRevokeEntrySchema = z.object({
+    kind: z.literal("revoke"),
+    ts_ms: z.number().int(),
+    binding_id: z.string().min(1),
+    actor_binding_id: z.string().min(1),
+    reason: z.string().nullable().default(null),
+});
+export const IdentityStoreEntrySchema = z.discriminatedUnion("kind", [
+    IdentityLinkEntrySchema,
+    IdentityUnlinkEntrySchema,
+    IdentityRevokeEntrySchema,
+]);
+const DeprecatedIdentityLinkEntrySchema = z
+    .object({
+    kind: z.literal("link"),
+    ts_ms: z.number().int(),
+    binding: z
+        .object({
+        binding_id: z.string().min(1),
+        channel: DeprecatedChannelSchema,
+    })
+        .passthrough(),
+})
+    .passthrough();
+function bindingPrincipalKey(binding) {
+    return `${binding.channel}::${binding.channel_tenant_id}::${binding.channel_actor_id}`;
+}
+function resolvePrincipalKey(opts) {
+    return `${opts.channel}::${opts.channelTenantId}::${opts.channelActorId}`;
+}
+function cloneBinding(binding) {
+    return IdentityBindingSchema.parse(binding);
+}
+function assertBindingTier(binding) {
+    const expected = assuranceTierForChannel(binding.channel);
+    if (binding.assurance_tier !== expected) {
+        throw new Error(`binding ${binding.binding_id} has invalid assurance tier ${binding.assurance_tier} for channel ${binding.channel} (expected ${expected})`);
+    }
+}
+export class IdentityStore {
+    #path;
+    #loaded = false;
+    #bindingsById = new Map();
+    #activeByPrincipal = new Map();
+    #deprecatedBindingIds = new Set();
+    #deprecations = [];
+    constructor(path) {
+        this.#path = path;
+    }
+    get path() {
+        return this.#path;
+    }
+    listDeprecations() {
+        return this.#deprecations.map((entry) => ({ ...entry }));
+    }
+    async load() {
+        const rows = await readJsonl(this.#path);
+        this.#bindingsById.clear();
+        this.#activeByPrincipal.clear();
+        this.#deprecatedBindingIds.clear();
+        this.#deprecations.length = 0;
+        for (let idx = 0; idx < rows.length; idx++) {
+            const parsed = IdentityStoreEntrySchema.safeParse(rows[idx]);
+            if (!parsed.success) {
+                const deprecated = DeprecatedIdentityLinkEntrySchema.safeParse(rows[idx]);
+                if (deprecated.success) {
+                    this.#recordDeprecatedChannelBinding({
+                        bindingId: deprecated.data.binding.binding_id,
+                        channel: deprecated.data.binding.channel,
+                        tsMs: deprecated.data.ts_ms,
+                    });
+                    continue;
+                }
+                throw new Error(`invalid identity row ${idx}: ${parsed.error.message}`);
+            }
+            this.#applyEntry(parsed.data, { replay: true });
+        }
+        this.#loaded = true;
+    }
+    async #ensureLoaded() {
+        if (!this.#loaded) {
+            await this.load();
+        }
+    }
+    #recordDeprecatedChannelBinding(opts) {
+        this.#deprecatedBindingIds.add(opts.bindingId);
+        this.#deprecations.push({
+            reason: "channel_deprecated",
+            bindingId: opts.bindingId,
+            channel: opts.channel,
+            tsMs: opts.tsMs,
+        });
+    }
+    #applyEntry(entry, opts) {
+        switch (entry.kind) {
+            case "link": {
+                assertBindingTier(entry.binding);
+                this.#bindingsById.set(entry.binding.binding_id, cloneBinding(entry.binding));
+                if (entry.binding.status === "active") {
+                    this.#activeByPrincipal.set(bindingPrincipalKey(entry.binding), entry.binding.binding_id);
+                }
+                break;
+            }
+            case "unlink": {
+                const current = this.#bindingsById.get(entry.binding_id);
+                if (!current) {
+                    if (this.#deprecatedBindingIds.has(entry.binding_id)) {
+                        break;
+                    }
+                    if (opts.replay) {
+                        throw new Error(`identity unlink references unknown binding: ${entry.binding_id}`);
+                    }
+                    break;
+                }
+                const next = IdentityBindingSchema.parse({
+                    ...current,
+                    status: "unlinked",
+                    updated_at_ms: entry.ts_ms,
+                    unlinked_at_ms: entry.ts_ms,
+                });
+                this.#bindingsById.set(next.binding_id, next);
+                this.#activeByPrincipal.delete(bindingPrincipalKey(current));
+                break;
+            }
+            case "revoke": {
+                const current = this.#bindingsById.get(entry.binding_id);
+                if (!current) {
+                    if (this.#deprecatedBindingIds.has(entry.binding_id)) {
+                        break;
+                    }
+                    if (opts.replay) {
+                        throw new Error(`identity revoke references unknown binding: ${entry.binding_id}`);
+                    }
+                    break;
+                }
+                const next = IdentityBindingSchema.parse({
+                    ...current,
+                    status: "revoked",
+                    updated_at_ms: entry.ts_ms,
+                    revoked_at_ms: entry.ts_ms,
+                    revoked_by_binding_id: entry.actor_binding_id,
+                    revoke_reason: entry.reason,
+                });
+                this.#bindingsById.set(next.binding_id, next);
+                this.#activeByPrincipal.delete(bindingPrincipalKey(current));
+                break;
+            }
+        }
+    }
+    get(bindingId) {
+        const binding = this.#bindingsById.get(bindingId);
+        return binding ? cloneBinding(binding) : null;
+    }
+    resolveActive(opts) {
+        const principal = resolvePrincipalKey(opts);
+        const bindingId = this.#activeByPrincipal.get(principal);
+        if (!bindingId) {
+            return null;
+        }
+        const binding = this.#bindingsById.get(bindingId);
+        if (!binding || binding.status !== "active") {
+            return null;
+        }
+        return cloneBinding(binding);
+    }
+    listBindings(opts = {}) {
+        const includeInactive = opts.includeInactive ?? false;
+        const out = [];
+        for (const binding of this.#bindingsById.values()) {
+            if (!includeInactive && binding.status !== "active") {
+                continue;
+            }
+            out.push(cloneBinding(binding));
+        }
+        out.sort((a, b) => {
+            if (a.linked_at_ms !== b.linked_at_ms) {
+                return a.linked_at_ms - b.linked_at_ms;
+            }
+            return a.binding_id.localeCompare(b.binding_id);
+        });
+        return out;
+    }
+    async link(opts) {
+        await this.#ensureLoaded();
+        const channel = ChannelSchema.parse(opts.channel);
+        const nowMs = Math.trunc(opts.nowMs ?? Date.now());
+        const existingById = this.#bindingsById.get(opts.bindingId);
+        if (existingById) {
+            return { kind: "binding_exists", binding: cloneBinding(existingById) };
+        }
+        const principal = resolvePrincipalKey({
+            channel,
+            channelTenantId: opts.channelTenantId,
+            channelActorId: opts.channelActorId,
+        });
+        const existingPrincipalBindingId = this.#activeByPrincipal.get(principal);
+        if (existingPrincipalBindingId) {
+            const existing = this.#bindingsById.get(existingPrincipalBindingId);
+            if (existing) {
+                return { kind: "principal_already_linked", binding: cloneBinding(existing) };
+            }
+        }
+        const binding = IdentityBindingSchema.parse({
+            binding_id: opts.bindingId,
+            operator_id: opts.operatorId,
+            channel,
+            channel_tenant_id: opts.channelTenantId,
+            channel_actor_id: opts.channelActorId,
+            assurance_tier: assuranceTierForChannel(channel),
+            scopes: [...(opts.scopes ?? [])],
+            status: "active",
+            linked_at_ms: nowMs,
+            updated_at_ms: nowMs,
+            unlinked_at_ms: null,
+            revoked_at_ms: null,
+            revoked_by_binding_id: null,
+            revoke_reason: null,
+        });
+        const entry = IdentityLinkEntrySchema.parse({
+            kind: "link",
+            ts_ms: nowMs,
+            binding,
+        });
+        await appendJsonl(this.#path, entry);
+        this.#applyEntry(entry, { replay: false });
+        return { kind: "linked", binding: cloneBinding(binding) };
+    }
+    async unlinkSelf(opts) {
+        await this.#ensureLoaded();
+        const current = this.#bindingsById.get(opts.bindingId);
+        if (!current) {
+            return { kind: "not_found" };
+        }
+        if (current.status !== "active") {
+            return { kind: "already_inactive", binding: cloneBinding(current) };
+        }
+        if (opts.actorBindingId !== opts.bindingId) {
+            return { kind: "invalid_actor" };
+        }
+        const nowMs = Math.trunc(opts.nowMs ?? Date.now());
+        const entry = IdentityUnlinkEntrySchema.parse({
+            kind: "unlink",
+            ts_ms: nowMs,
+            binding_id: opts.bindingId,
+            actor_binding_id: opts.actorBindingId,
+            reason: opts.reason ?? null,
+        });
+        await appendJsonl(this.#path, entry);
+        this.#applyEntry(entry, { replay: false });
+        const updated = this.#bindingsById.get(opts.bindingId);
+        if (!updated) {
+            throw new Error(`identity binding missing after unlink: ${opts.bindingId}`);
+        }
+        return { kind: "unlinked", binding: cloneBinding(updated) };
+    }
+    async revoke(opts) {
+        await this.#ensureLoaded();
+        const current = this.#bindingsById.get(opts.bindingId);
+        if (!current) {
+            return { kind: "not_found" };
+        }
+        if (current.status !== "active") {
+            return { kind: "already_inactive", binding: cloneBinding(current) };
+        }
+        const nowMs = Math.trunc(opts.nowMs ?? Date.now());
+        const entry = IdentityRevokeEntrySchema.parse({
+            kind: "revoke",
+            ts_ms: nowMs,
+            binding_id: opts.bindingId,
+            actor_binding_id: opts.actorBindingId,
+            reason: opts.reason ?? null,
+        });
+        await appendJsonl(this.#path, entry);
+        this.#applyEntry(entry, { replay: false });
+        const updated = this.#bindingsById.get(opts.bindingId);
+        if (!updated) {
+            throw new Error(`identity binding missing after revoke: ${opts.bindingId}`);
+        }
+        return { kind: "revoked", binding: cloneBinding(updated) };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export * from "./adapter_audit.js";
+export * from "./channel_adapters.js";
+export * from "./command_context.js";
+export * from "./command_journal.js";
+export * from "./command_parser.js";
+export * from "./command_pipeline.js";
+export * from "./command_record.js";
+export * from "./command_state.js";
+export * from "./confirmation_manager.js";
+export * from "./idempotency_ledger.js";
+export * from "./identity_store.js";
+export * from "./meta_agent.js";
+export * from "./models.js";
+export * from "./mu_cli_runner.js";
+export * from "./operator_tooling.js";
+export * from "./outbox.js";
+export * from "./paths.js";
+export * from "./policy.js";
+export * from "./runtime.js";
+export * from "./serialized_mutation_executor.js";
+export * from "./writer_lock.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,mCAAmC,CAAC;AAClD,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,21 @@
+export * from "./adapter_audit.js";
+export * from "./channel_adapters.js";
+export * from "./command_context.js";
+export * from "./command_journal.js";
+export * from "./command_parser.js";
+export * from "./command_pipeline.js";
+export * from "./command_record.js";
+export * from "./command_state.js";
+export * from "./confirmation_manager.js";
+export * from "./idempotency_ledger.js";
+export * from "./identity_store.js";
+export * from "./meta_agent.js";
+export * from "./models.js";
+export * from "./mu_cli_runner.js";
+export * from "./operator_tooling.js";
+export * from "./outbox.js";
+export * from "./paths.js";
+export * from "./policy.js";
+export * from "./runtime.js";
+export * from "./serialized_mutation_executor.js";
+export * from "./writer_lock.js";

package/dist/meta_agent.d.ts

@@ -0,0 +1,127 @@
+import { z } from "zod";
+import { CommandContextResolver } from "./command_context.js";
+import type { IdentityBinding } from "./identity_store.js";
+import type { InboundEnvelope } from "./models.js";
+export declare const MetaApprovedCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"status">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"ready">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"issue_get">;
+    issue_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"forum_read">;
+    topic: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"run_resume">;
+    root_issue_id: z.ZodOptional<z.ZodString>;
+    max_steps: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"run_start">;
+    prompt: z.ZodString;
+    max_steps: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>], "kind">;
+export type MetaApprovedCommand = z.infer<typeof MetaApprovedCommandSchema>;
+export declare const MetaAgentBackendTurnResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"respond">;
+    message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"command">;
+    command: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"status">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"ready">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"issue_get">;
+        issue_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"forum_read">;
+        topic: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"run_resume">;
+        root_issue_id: z.ZodOptional<z.ZodString>;
+        max_steps: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"run_start">;
+        prompt: z.ZodString;
+        max_steps: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>], "kind">;
+export type MetaAgentBackendTurnResult = z.infer<typeof MetaAgentBackendTurnResultSchema>;
+export type MetaAgentBackendTurnInput = {
+    sessionId: string;
+    turnId: string;
+    inbound: InboundEnvelope;
+    binding: IdentityBinding;
+};
+export interface MessagingMetaAgentBackend {
+    runTurn(input: MetaAgentBackendTurnInput): Promise<MetaAgentBackendTurnResult>;
+}
+export type MetaAgentDecision = {
+    kind: "response";
+    message: string;
+    metaSessionId: string;
+    metaTurnId: string;
+} | {
+    kind: "command";
+    commandText: string;
+    metaSessionId: string;
+    metaTurnId: string;
+} | {
+    kind: "reject";
+    reason: "meta_agent_disabled" | "meta_agent_action_disallowed" | "meta_agent_invalid_output" | "context_missing" | "context_ambiguous" | "context_unauthorized" | "cli_validation_failed";
+    details?: string;
+    metaSessionId: string;
+    metaTurnId: string;
+};
+export type ApprovedCommandBrokerOpts = {
+    contextResolver?: CommandContextResolver;
+    runTriggersEnabled?: boolean;
+};
+export declare class ApprovedCommandBroker {
+    #private;
+    constructor(opts?: ApprovedCommandBrokerOpts);
+    approve(opts: {
+        proposal: MetaApprovedCommand;
+        inbound: InboundEnvelope;
+    }): {
+        kind: "approved";
+        commandText: string;
+    } | {
+        kind: "reject";
+        reason: "meta_agent_action_disallowed" | "context_missing" | "context_ambiguous" | "context_unauthorized" | "cli_validation_failed";
+        details?: string;
+    };
+}
+export type MessagingMetaAgentRuntimeOpts = {
+    backend: MessagingMetaAgentBackend;
+    broker?: ApprovedCommandBroker;
+    enabled?: boolean;
+    enabledChannels?: readonly string[];
+    sessionIdFactory?: () => string;
+    turnIdFactory?: () => string;
+};
+export declare class MessagingMetaAgentRuntime {
+    #private;
+    constructor(opts: MessagingMetaAgentRuntimeOpts);
+    handleInbound(opts: {
+        inbound: InboundEnvelope;
+        binding: IdentityBinding;
+    }): Promise<MetaAgentDecision>;
+}
+export type PiMessagingMetaAgentBackendOpts = {
+    provider?: string;
+    model?: string;
+    thinking?: string;
+    systemPrompt?: string;
+    timeoutMs?: number;
+    piBinary?: string;
+};
+export declare class PiMessagingMetaAgentBackend implements MessagingMetaAgentBackend {
+    #private;
+    constructor(opts?: PiMessagingMetaAgentBackendOpts);
+    runTurn(input: MetaAgentBackendTurnInput): Promise<MetaAgentBackendTurnResult>;
+}
+//# sourceMappingURL=meta_agent.d.ts.map

package/dist/meta_agent.d.ts.map

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