@femtomc/mu-agent 26.2.70 → 26.2.72

package/dist/extensions/messaging-setup/index.js

@@ -0,0 +1,261 @@
+/**
+ * mu-messaging-setup — Adapter configuration diagnostics + guided setup.
+ *
+ * Goals:
+ * - Make `/mu setup <adapter>` hand setup context to the active mu agent.
+ * - Keep configuration in `.mu/config.json` (no process.env mutations).
+ * - Support plan/apply/verify workflow with in-process control-plane reload.
+ */
+import { StringEnum } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { registerMuSubcommand } from "../mu-command-dispatcher.js";
+import { textResult, toJsonText } from "../shared.js";
+import { ADAPTERS, normalizeAdapterId } from "./adapters.js";
+import { applyAdapterConfig, buildVerifyOutcome, reloadOutcomeSummary } from "./actions.js";
+import { buildAgentSetupPrompt, checksForAdapter, findCheckByAdapter, maybeDispatchAgentSetupBrief, parseSetupCommandArgs, runInteractiveApply, } from "./parser.js";
+import { collectChecksCached, refreshMessagingStatus } from "./runtime.js";
+import { buildPlan, planSummary, preflightSummary, setupGuide, summarizeChecks, verifyText } from "./ui.js";
+export function messagingSetupExtension(pi, opts = {}) {
+    const allowApply = opts.allowApply ?? true;
+    pi.on("before_agent_start", async (event) => {
+        const { checks } = await collectChecksCached();
+        const summary = summarizeChecks(checks);
+        const lines = [
+            "",
+            "[MU MESSAGING]",
+            summary.length > 0 ? summary : "no adapter status available",
+            allowApply
+                ? "Use mu_messaging_setup(action=preflight|plan|apply|verify|guide) for operator workflow."
+                : "Use mu_messaging_setup(action=preflight|plan|verify|guide) for query workflow.",
+        ];
+        return {
+            systemPrompt: `${event.systemPrompt}${lines.join("\n")}`,
+        };
+    });
+    pi.on("session_start", async (_event, ctx) => {
+        await refreshMessagingStatus(ctx);
+    });
+    const setupActions = allowApply
+        ? ["check", "preflight", "guide", "plan", "apply", "verify"]
+        : ["check", "preflight", "guide", "plan", "verify"];
+    const SetupParams = Type.Object({
+        action: StringEnum(setupActions),
+        adapter: Type.Optional(Type.String({ description: "Adapter name: slack, discord, telegram" })),
+        public_base_url: Type.Optional(Type.String({
+            description: "Optional public base URL used to compute expected webhook endpoints (e.g. https://example.ngrok.app)",
+        })),
+        fields: Type.Optional(Type.Record(Type.String(), Type.String(), {
+            description: "Config field overrides for apply action. Keys are field names (e.g. bot_token, webhook_secret), values are the secrets/tokens to write.",
+        })),
+    });
+    pi.registerTool({
+        name: "mu_messaging_setup",
+        label: "Messaging Setup",
+        description: allowApply
+            ? "Messaging setup workflow. Actions: check/preflight/guide/plan/apply/verify. For apply, pass field values via the fields parameter (e.g. fields={bot_token:'...', webhook_secret:'...'})."
+            : "Messaging setup query workflow. Actions: check/preflight/guide/plan/verify. Apply is disabled in query-only mode.",
+        parameters: SetupParams,
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const adapterId = params.adapter ? normalizeAdapterId(params.adapter) : null;
+            if (params.adapter && !adapterId) {
+                return textResult(`Unknown adapter: ${params.adapter}. Available: ${ADAPTERS.map((adapter) => adapter.id).join(", ")}`);
+            }
+            switch (params.action) {
+                case "check": {
+                    const { checks, runtime } = await collectChecksCached();
+                    const filteredChecks = checksForAdapter(checks, adapterId);
+                    return textResult(toJsonText({
+                        checks: filteredChecks,
+                        runtime: { ...runtime, routesByAdapter: Object.fromEntries(runtime.routesByAdapter) },
+                    }), {
+                        checks: filteredChecks,
+                        runtime,
+                        adapter: adapterId,
+                    });
+                }
+                case "preflight": {
+                    const { checks, runtime } = await collectChecksCached();
+                    const filteredChecks = checksForAdapter(checks, adapterId);
+                    return textResult(preflightSummary(filteredChecks, runtime), {
+                        checks: filteredChecks,
+                        runtime,
+                        adapter: adapterId,
+                    });
+                }
+                case "guide":
+                case "plan": {
+                    const { checks, runtime } = await collectChecksCached();
+                    if (adapterId) {
+                        const check = findCheckByAdapter(checks, adapterId);
+                        if (!check) {
+                            return textResult(`Unknown adapter: ${adapterId}`);
+                        }
+                        const plan = buildPlan(check, params.public_base_url);
+                        const brief = buildAgentSetupPrompt({
+                            check,
+                            plan,
+                            configPath: runtime.configPath,
+                            publicBaseUrl: params.public_base_url,
+                        });
+                        return textResult(brief, { checks, runtime, adapter: adapterId, plan });
+                    }
+                    if (params.action === "guide") {
+                        return textResult(setupGuide(checks), { checks, runtime, adapter: null });
+                    }
+                    const plans = checks.map((check) => buildPlan(check, params.public_base_url));
+                    return textResult(planSummary(plans), { plans, runtime, adapter: null });
+                }
+                case "apply": {
+                    if (!allowApply) {
+                        return textResult("apply is disabled in query-only mode. Use plan/guide/verify actions.", {
+                            blocked: true,
+                            reason: "messaging_setup_query_only_mode",
+                        });
+                    }
+                    if (!adapterId) {
+                        return textResult("apply requires adapter (slack|discord|telegram)");
+                    }
+                    const { runtime, checks } = await collectChecksCached(0);
+                    if (!runtime.configPresence) {
+                        return textResult(`Cannot read config presence: ${runtime.fetchError ?? "unknown error"}`);
+                    }
+                    const check = findCheckByAdapter(checks, adapterId);
+                    if (!check) {
+                        return textResult(`Unknown adapter: ${adapterId}`);
+                    }
+                    const overrides = params.fields ?? {};
+                    const stillMissing = check.missing.filter((field) => !(field in overrides));
+                    if (stillMissing.length > 0) {
+                        return textResult(`Cannot apply ${adapterId}: missing required config fields (${stillMissing.join(", ")}). Pass them via the fields parameter or use /mu setup apply ${adapterId} for guided input.`, { adapter: adapterId, missing_required_fields: stillMissing });
+                    }
+                    const outcome = await applyAdapterConfig({
+                        adapterId,
+                        overrides,
+                        presence: runtime.configPresence,
+                    });
+                    if (!outcome.ok) {
+                        return textResult(`Apply failed: ${outcome.reason} (${outcome.missing_required_fields.join(", ")}).`, outcome);
+                    }
+                    const { checks: refreshed } = await collectChecksCached(0);
+                    const verify = buildVerifyOutcome(refreshed, { adapterId, publicBaseUrl: params.public_base_url });
+                    const lines = [
+                        `Updated config fields: ${outcome.updated_fields.join(", ") || "(none)"}`,
+                        `Config path: ${outcome.config_path ?? runtime.configPath ?? "(unknown)"}`,
+                        reloadOutcomeSummary(outcome.reload),
+                        "",
+                        verifyText(verify),
+                    ];
+                    return textResult(lines.join("\n"), { outcome, verify });
+                }
+                case "verify": {
+                    const { checks } = await collectChecksCached(0);
+                    const verify = buildVerifyOutcome(checks, {
+                        adapterId: adapterId ?? undefined,
+                        publicBaseUrl: params.public_base_url,
+                    });
+                    return textResult(verifyText(verify), { verify });
+                }
+                default:
+                    return textResult(`Unknown action: ${params.action}`);
+            }
+        },
+    });
+    registerMuSubcommand(pi, {
+        subcommand: "setup",
+        summary: "Messaging adapter setup workflow (preflight/guide/plan/apply/verify)",
+        usage: "/mu setup [preflight|guide|plan|apply|verify] [adapter] [--public-base-url URL] [--agent|--no-agent]",
+        handler: async (args, ctx) => {
+            const parsed = parseSetupCommandArgs(args);
+            if (parsed.error) {
+                ctx.ui.notify(`${parsed.error}. Usage: /mu setup [preflight|guide|plan|apply|verify] [adapter] [--public-base-url URL] [--agent|--no-agent]`, "error");
+                return;
+            }
+            switch (parsed.action) {
+                case "check": {
+                    const { checks, runtime } = await collectChecksCached(0);
+                    const filteredChecks = checksForAdapter(checks, parsed.adapterId);
+                    ctx.ui.notify(toJsonText({
+                        checks: filteredChecks,
+                        runtime: { ...runtime, routesByAdapter: Object.fromEntries(runtime.routesByAdapter) },
+                    }), "info");
+                    await refreshMessagingStatus(ctx);
+                    return;
+                }
+                case "preflight": {
+                    const { checks, runtime } = await collectChecksCached(0);
+                    if (await maybeDispatchAgentSetupBrief({ pi, ctx, parsed, checks, runtime })) {
+                        if (runtime.fetchError) {
+                            ctx.ui.notify(`runtime note: ${runtime.fetchError}`, "warning");
+                        }
+                        await refreshMessagingStatus(ctx);
+                        return;
+                    }
+                    const filteredChecks = checksForAdapter(checks, parsed.adapterId);
+                    ctx.ui.notify(preflightSummary(filteredChecks, runtime), "info");
+                    await refreshMessagingStatus(ctx);
+                    return;
+                }
+                case "guide": {
+                    const { checks, runtime } = await collectChecksCached(0);
+                    if (await maybeDispatchAgentSetupBrief({ pi, ctx, parsed, checks, runtime })) {
+                        if (runtime.fetchError) {
+                            ctx.ui.notify(`runtime note: ${runtime.fetchError}`, "warning");
+                        }
+                        await refreshMessagingStatus(ctx);
+                        return;
+                    }
+                    ctx.ui.notify(setupGuide(checks, parsed.adapterId ?? undefined), "info");
+                    if (runtime.fetchError) {
+                        ctx.ui.notify(`runtime note: ${runtime.fetchError}`, "warning");
+                    }
+                    await refreshMessagingStatus(ctx);
+                    return;
+                }
+                case "plan": {
+                    const { checks, runtime } = await collectChecksCached(0);
+                    if (await maybeDispatchAgentSetupBrief({ pi, ctx, parsed, checks, runtime })) {
+                        await refreshMessagingStatus(ctx);
+                        return;
+                    }
+                    const plans = parsed.adapterId
+                        ? checks
+                            .filter((check) => check.id === parsed.adapterId)
+                            .map((check) => buildPlan(check, parsed.publicBaseUrl))
+                        : checks.map((check) => buildPlan(check, parsed.publicBaseUrl));
+                    ctx.ui.notify(planSummary(plans), "info");
+                    await refreshMessagingStatus(ctx);
+                    return;
+                }
+                case "apply": {
+                    if (!allowApply) {
+                        ctx.ui.notify("apply is disabled in query-only mode. Use /mu setup plan and /mu setup verify.", "warning");
+                        return;
+                    }
+                    if (!parsed.adapterId) {
+                        ctx.ui.notify("apply requires adapter. Example: /mu setup apply slack", "error");
+                        return;
+                    }
+                    const text = await runInteractiveApply(ctx, parsed.adapterId);
+                    ctx.ui.notify(text, "info");
+                    await refreshMessagingStatus(ctx);
+                    return;
+                }
+                case "verify": {
+                    const { checks, runtime } = await collectChecksCached(0);
+                    if (await maybeDispatchAgentSetupBrief({ pi, ctx, parsed, checks, runtime })) {
+                        await refreshMessagingStatus(ctx);
+                        return;
+                    }
+                    const verify = buildVerifyOutcome(checks, {
+                        adapterId: parsed.adapterId ?? undefined,
+                        publicBaseUrl: parsed.publicBaseUrl,
+                    });
+                    ctx.ui.notify(verifyText(verify), verify.ok ? "info" : "warning");
+                    await refreshMessagingStatus(ctx);
+                    return;
+                }
+            }
+        },
+    });
+}
+export default messagingSetupExtension;

package/dist/extensions/messaging-setup/parser.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Command argument parsing and agent dispatch for mu-messaging-setup.
+ */
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type { AdapterCheck, AdapterConfig, AdapterId, AdapterPlan, RuntimeState, SetupAction } from "./types.js";
+export type ParsedSetupCommand = {
+    action: SetupAction;
+    adapterId: AdapterId | null;
+    publicBaseUrl: string | undefined;
+    dispatchToAgent: "auto" | "force" | "off";
+    error: string | null;
+};
+export declare function parseSetupCommandArgs(args: string): ParsedSetupCommand;
+export declare function shouldDispatchSetupToAgent(parsed: ParsedSetupCommand): boolean;
+export declare function adapterFieldStatusLines(adapter: AdapterConfig, check: AdapterCheck): string[];
+export declare function buildAgentSetupPrompt(opts: {
+    check: AdapterCheck;
+    plan: AdapterPlan;
+    configPath: string | null;
+    publicBaseUrl?: string;
+}): string;
+export declare function dispatchSetupPromptToAgent(pi: ExtensionAPI, ctx: ExtensionCommandContext, prompt: string): void;
+export declare function findCheckByAdapter(checks: AdapterCheck[], adapterId: AdapterId): AdapterCheck | null;
+export declare function checksForAdapter(checks: AdapterCheck[], adapterId: AdapterId | null): AdapterCheck[];
+export declare function maybeDispatchAgentSetupBrief(opts: {
+    pi: ExtensionAPI;
+    ctx: ExtensionCommandContext;
+    parsed: ParsedSetupCommand;
+    checks: AdapterCheck[];
+    runtime: RuntimeState;
+}): Promise<boolean>;
+export declare function runInteractiveApply(ctx: ExtensionCommandContext, adapterId: AdapterId): Promise<string>;
+//# sourceMappingURL=parser.d.ts.map

package/dist/extensions/messaging-setup/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/extensions/messaging-setup/parser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAW3F,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAQjH,MAAM,MAAM,kBAAkB,GAAG;IAChC,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;IAC5B,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,eAAe,EAAE,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;IAC1C,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAmHtE;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAM9E;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,YAAY,GAAG,MAAM,EAAE,CAK7F;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC3C,KAAK,EAAE,YAAY,CAAC;IACpB,IAAI,EAAE,WAAW,CAAC;IAClB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG,MAAM,CAiBT;AAED,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,YAAY,EAAE,GAAG,EAAE,uBAAuB,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAM/G;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,SAAS,EAAE,SAAS,GAAG,YAAY,GAAG,IAAI,CAEpG;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI,GAAG,YAAY,EAAE,CAMpG;AAED,wBAAsB,4BAA4B,CAAC,IAAI,EAAE;IACxD,EAAE,EAAE,YAAY,CAAC;IACjB,GAAG,EAAE,uBAAuB,CAAC;IAC7B,MAAM,EAAE,kBAAkB,CAAC;IAC3B,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,OAAO,EAAE,YAAY,CAAC;CACtB,GAAG,OAAO,CAAC,OAAO,CAAC,CAenB;AAED,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,uBAAuB,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAyD7G"}

package/dist/extensions/messaging-setup/parser.js

@@ -0,0 +1,240 @@
+/**
+ * Command argument parsing and agent dispatch for mu-messaging-setup.
+ */
+import { loadBundledPrompt } from "../../default_prompts.js";
+import { adapterById, isSetupAction, normalizeAdapterId, normalizePublicBaseUrl, } from "./adapters.js";
+import { applyAdapterConfig, buildVerifyOutcome, reloadOutcomeSummary } from "./actions.js";
+import { collectChecksCached } from "./runtime.js";
+import { buildPlan, verifyText } from "./ui.js";
+const MESSAGING_SETUP_BRIEF_TEMPLATE = loadBundledPrompt("skills/messaging-setup-brief.md");
+function interpolateTemplate(template, vars) {
+    return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => vars[key] ?? `{{${key}}}`);
+}
+export function parseSetupCommandArgs(args) {
+    const tokens = args
+        .trim()
+        .split(/\s+/)
+        .filter((token) => token.length > 0);
+    const positional = [];
+    let publicBaseUrl;
+    let dispatchToAgent = "auto";
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token === "--agent") {
+            dispatchToAgent = "force";
+            continue;
+        }
+        if (token === "--no-agent") {
+            dispatchToAgent = "off";
+            continue;
+        }
+        if (token === "--public-base-url") {
+            const next = tokens[i + 1];
+            if (!next) {
+                return {
+                    action: "preflight",
+                    adapterId: null,
+                    publicBaseUrl: undefined,
+                    dispatchToAgent,
+                    error: "Missing value for --public-base-url",
+                };
+            }
+            publicBaseUrl = next;
+            i += 1;
+            continue;
+        }
+        if (token.startsWith("--public-base-url=")) {
+            publicBaseUrl = token.slice("--public-base-url=".length);
+            continue;
+        }
+        if (token.startsWith("--")) {
+            return {
+                action: "preflight",
+                adapterId: null,
+                publicBaseUrl: undefined,
+                dispatchToAgent,
+                error: `Unknown option: ${token}`,
+            };
+        }
+        positional.push(token);
+    }
+    if (positional.length === 0) {
+        return { action: "preflight", adapterId: null, publicBaseUrl, dispatchToAgent, error: null };
+    }
+    const first = positional[0].toLowerCase();
+    if (isSetupAction(first)) {
+        const action = first;
+        const adapterId = positional[1] ? normalizeAdapterId(positional[1]) : null;
+        if (positional[1] && !adapterId) {
+            return {
+                action,
+                adapterId: null,
+                publicBaseUrl,
+                dispatchToAgent,
+                error: `Unknown adapter: ${positional[1]}`,
+            };
+        }
+        if (positional.length > 2) {
+            return {
+                action,
+                adapterId,
+                publicBaseUrl,
+                dispatchToAgent,
+                error: `Unexpected extra arguments: ${positional.slice(2).join(" ")}`,
+            };
+        }
+        return { action, adapterId, publicBaseUrl, dispatchToAgent, error: null };
+    }
+    const adapterId = normalizeAdapterId(first);
+    if (!adapterId) {
+        return {
+            action: "preflight",
+            adapterId: null,
+            publicBaseUrl,
+            dispatchToAgent,
+            error: `Unknown adapter or action: ${positional[0]}`,
+        };
+    }
+    if (positional.length === 1) {
+        return { action: "guide", adapterId, publicBaseUrl, dispatchToAgent, error: null };
+    }
+    const second = positional[1].toLowerCase();
+    if (!isSetupAction(second)) {
+        return {
+            action: "guide",
+            adapterId,
+            publicBaseUrl,
+            dispatchToAgent,
+            error: `Unknown action: ${positional[1]}`,
+        };
+    }
+    if (positional.length > 2) {
+        return {
+            action: second,
+            adapterId,
+            publicBaseUrl,
+            dispatchToAgent,
+            error: `Unexpected extra arguments: ${positional.slice(2).join(" ")}`,
+        };
+    }
+    return { action: second, adapterId, publicBaseUrl, dispatchToAgent, error: null };
+}
+export function shouldDispatchSetupToAgent(parsed) {
+    if (parsed.dispatchToAgent === "force")
+        return true;
+    if (parsed.dispatchToAgent === "off")
+        return false;
+    if (!parsed.adapterId)
+        return false;
+    if (parsed.action === "apply" || parsed.action === "check")
+        return false;
+    return true;
+}
+export function adapterFieldStatusLines(adapter, check) {
+    return adapter.fields.map((field) => {
+        const status = check.missing.includes(field.key) ? "MISSING" : "SET";
+        return `- ${field.key}: ${status} (${field.required ? "required" : "optional"})`;
+    });
+}
+export function buildAgentSetupPrompt(opts) {
+    const adapter = adapterById(opts.check.id);
+    const normalizedBase = normalizePublicBaseUrl(opts.publicBaseUrl);
+    const webhookUrl = normalizedBase ? `${normalizedBase}${opts.plan.route}` : opts.plan.webhook_url;
+    const verifyFlag = normalizedBase ? ` --public-base-url ${normalizedBase}` : "";
+    return interpolateTemplate(MESSAGING_SETUP_BRIEF_TEMPLATE, {
+        adapter_name: adapter.name,
+        adapter_id: adapter.id,
+        state: opts.check.state,
+        config_path: opts.configPath ?? ".mu/config.json",
+        route: opts.plan.route,
+        webhook_url: webhookUrl ?? "(need public base URL)",
+        missing_fields: opts.check.missing.join(", ") || "(none)",
+        provider_steps: adapter.providerSetupSteps.map((step, index) => `${index + 1}. ${step}`).join("\n"),
+        field_status: adapterFieldStatusLines(adapter, opts.check).join("\n"),
+        verify_command: `/mu setup verify ${adapter.id}${verifyFlag}`,
+    });
+}
+export function dispatchSetupPromptToAgent(pi, ctx, prompt) {
+    if (ctx.isIdle()) {
+        pi.sendUserMessage(prompt);
+        return;
+    }
+    pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+}
+export function findCheckByAdapter(checks, adapterId) {
+    return checks.find((check) => check.id === adapterId) ?? null;
+}
+export function checksForAdapter(checks, adapterId) {
+    if (!adapterId) {
+        return checks;
+    }
+    const match = checks.find((check) => check.id === adapterId);
+    return match ? [match] : [];
+}
+export async function maybeDispatchAgentSetupBrief(opts) {
+    if (!opts.parsed.adapterId)
+        return false;
+    if (!shouldDispatchSetupToAgent(opts.parsed))
+        return false;
+    const check = findCheckByAdapter(opts.checks, opts.parsed.adapterId);
+    if (!check)
+        return false;
+    const plan = buildPlan(check, opts.parsed.publicBaseUrl);
+    const prompt = buildAgentSetupPrompt({
+        check,
+        plan,
+        configPath: opts.runtime.configPath,
+        publicBaseUrl: opts.parsed.publicBaseUrl,
+    });
+    dispatchSetupPromptToAgent(opts.pi, opts.ctx, prompt);
+    opts.ctx.ui.notify(`Sent ${check.name} setup brief to mu agent.`, "info");
+    return true;
+}
+export async function runInteractiveApply(ctx, adapterId) {
+    const adapter = adapterById(adapterId);
+    if (adapter.support === "planned") {
+        return `${adapter.name} is currently planned and not runtime-available.`;
+    }
+    const { checks, runtime } = await collectChecksCached(0);
+    if (!runtime.configPresence) {
+        return `Cannot read config presence: ${runtime.fetchError ?? "unknown error"}`;
+    }
+    const check = findCheckByAdapter(checks, adapterId);
+    if (!check) {
+        return `Unknown adapter: ${adapterId}`;
+    }
+    const overrides = {};
+    for (const key of check.missing) {
+        const entered = await ctx.ui.input(`${adapter.name}: enter value for ${key}`);
+        if (entered == null) {
+            return "Cancelled apply flow.";
+        }
+        const value = entered.trim();
+        if (value.length === 0) {
+            return `Cancelled: empty value for ${key}.`;
+        }
+        overrides[key] = value;
+    }
+    const applyConfirmed = await ctx.ui.confirm(`Apply ${adapter.name} configuration?`, `This writes to .mu/config.json and triggers in-process control-plane reload.`);
+    if (!applyConfirmed) {
+        return "Apply cancelled.";
+    }
+    const outcome = await applyAdapterConfig({
+        adapterId,
+        overrides,
+        presence: runtime.configPresence,
+    });
+    if (!outcome.ok) {
+        return `Apply failed: ${outcome.reason} (${outcome.missing_required_fields.join(", ")}).`;
+    }
+    const { checks: refreshedChecks } = await collectChecksCached(0);
+    const verify = buildVerifyOutcome(refreshedChecks, { adapterId });
+    const lines = [
+        `Updated config fields: ${outcome.updated_fields.join(", ") || "(none)"}`,
+        `Config path: ${outcome.config_path ?? runtime.configPath ?? "(unknown)"}`,
+        reloadOutcomeSummary(outcome.reload),
+        "",
+        verifyText(verify),
+    ];
+    return lines.join("\n");
+}

package/dist/extensions/messaging-setup/runtime.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Runtime state fetching and adapter check collection for mu-messaging-setup.
+ */
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { AdapterCheck, RuntimeState } from "./types.js";
+import type { ConfigReadResponse } from "./types.js";
+export declare function fetchConfigPresence(): Promise<ConfigReadResponse>;
+export declare function fetchRuntimeState(): Promise<RuntimeState>;
+export declare function collectChecks(): Promise<{
+    checks: AdapterCheck[];
+    runtime: RuntimeState;
+}>;
+export declare function collectChecksCached(ttlMs?: number): Promise<Awaited<ReturnType<typeof collectChecks>>>;
+export declare function resetChecksCache(): void;
+export declare function refreshMessagingStatus(ctx: ExtensionContext): Promise<void>;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/extensions/messaging-setup/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/extensions/messaging-setup/runtime.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAEtE,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAEvE;AAED,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,YAAY,CAAC,CA8C/D;AAED,wBAAsB,aAAa,IAAI,OAAO,CAAC;IAAE,MAAM,EAAE,YAAY,EAAE,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC,CA6BhG;AAID,wBAAsB,mBAAmB,CAAC,KAAK,GAAE,MAAc,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC,CAAC,CAcnH;AAED,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC;AAED,wBAAsB,sBAAsB,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAIjF"}

package/dist/extensions/messaging-setup/runtime.js

@@ -0,0 +1,110 @@
+/**
+ * Runtime state fetching and adapter check collection for mu-messaging-setup.
+ */
+import { ADAPTERS, configured, deriveState, missingRequiredFields, nextStepForState } from "./adapters.js";
+import { summarizeChecks } from "./ui.js";
+import { fetchMuJson, fetchMuStatus, muServerUrl } from "../shared.js";
+export async function fetchConfigPresence() {
+    return await fetchMuJson("/api/config", { timeoutMs: 4_000 });
+}
+export async function fetchRuntimeState() {
+    if (!muServerUrl()) {
+        return {
+            repoRoot: null,
+            configPath: null,
+            runtimeActive: false,
+            routesByAdapter: new Map(),
+            configPresence: null,
+            fetchError: "MU_SERVER_URL not set",
+        };
+    }
+    try {
+        const [status, config] = await Promise.all([fetchMuStatus(2_000), fetchConfigPresence()]);
+        const cp = status.control_plane ?? {
+            active: false,
+            adapters: [],
+            routes: [],
+        };
+        const routesByAdapter = new Map();
+        for (const route of cp.routes ?? []) {
+            routesByAdapter.set(route.name, route.route);
+        }
+        for (const adapter of cp.adapters) {
+            if (!routesByAdapter.has(adapter)) {
+                routesByAdapter.set(adapter, `/webhooks/${adapter}`);
+            }
+        }
+        return {
+            repoRoot: status.repo_root,
+            configPath: config.config_path,
+            runtimeActive: cp.active,
+            routesByAdapter,
+            configPresence: config.presence,
+            fetchError: null,
+        };
+    }
+    catch (err) {
+        return {
+            repoRoot: null,
+            configPath: null,
+            runtimeActive: false,
+            routesByAdapter: new Map(),
+            configPresence: null,
+            fetchError: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export async function collectChecks() {
+    const runtime = await fetchRuntimeState();
+    const checks = ADAPTERS.map((adapter) => {
+        const missing = missingRequiredFields(adapter, runtime.configPresence);
+        const isConfigured = configured(adapter, runtime.configPresence);
+        const active = runtime.routesByAdapter.has(adapter.id);
+        const route = runtime.routesByAdapter.get(adapter.id) ?? null;
+        const state = deriveState({ adapter, configured: isConfigured, active });
+        const notes = [...(adapter.notes ?? [])];
+        if (runtime.fetchError && runtime.fetchError !== "MU_SERVER_URL not set") {
+            notes.push(`Runtime/config status unavailable: ${runtime.fetchError}`);
+        }
+        if (runtime.configPath) {
+            notes.push(`Config path: ${runtime.configPath}`);
+        }
+        return {
+            id: adapter.id,
+            name: adapter.name,
+            support: adapter.support,
+            configured: isConfigured,
+            missing,
+            active,
+            route,
+            state,
+            next_step: nextStepForState({ state, missing }),
+            notes,
+        };
+    });
+    return { checks, runtime };
+}
+let checksCache = null;
+export async function collectChecksCached(ttlMs = 4_000) {
+    if (ttlMs <= 0) {
+        const value = await collectChecks();
+        checksCache = { tsMs: Date.now(), value };
+        return value;
+    }
+    const now = Date.now();
+    if (checksCache && now - checksCache.tsMs <= ttlMs) {
+        return checksCache.value;
+    }
+    const value = await collectChecks();
+    checksCache = { tsMs: now, value };
+    return value;
+}
+export function resetChecksCache() {
+    checksCache = null;
+}
+export async function refreshMessagingStatus(ctx) {
+    if (!ctx.hasUI)
+        return;
+    const { checks } = await collectChecksCached();
+    ctx.ui.setStatus("mu-messaging", ctx.ui.theme.fg("dim", summarizeChecks(checks)));
+}