@a5c-ai/tasks-mux 5.0.1-staging.a2e883985f51

package/dist/cli/commands/responder-loop.js

@@ -0,0 +1,78 @@
+import { Command } from "commander";
+import { ResponderClient, } from "../../client/index.js";
+import { formatTable, printError } from "../output.js";
+import { createCliServerClient } from "../client-config.js";
+export function createResponderLoopCommand() {
+    const cmd = new Command("responder-loop")
+        .description("Start a polling loop to check for new breakpoints")
+        .requiredOption("-e, --responder <responderId>", "Responder ID")
+        .option("-i, --interval <seconds>", "Polling interval in seconds", "30")
+        .option("--once", "Check once and exit (for agent integration)", false)
+        .action(async (opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const localOpts = opts;
+        const jsonMode = allOpts.json === true;
+        try {
+            const client = await createCliServerClient({
+                serverUrl: allOpts.serverUrl,
+                authToken: allOpts.authToken,
+            });
+            const responderClient = new ResponderClient(client, localOpts.responder);
+            const intervalMs = parseInt(localOpts.interval ?? "30", 10) * 1000;
+            if (localOpts.once) {
+                // Single check mode
+                const breakpoints = await responderClient.fetchPendingBreakpoints();
+                displayBreakpoints(breakpoints, jsonMode);
+                return;
+            }
+            // Continuous polling mode
+            if (!jsonMode) {
+                console.log(`Starting responder loop for ${localOpts.responder} (interval: ${localOpts.interval ?? "30"}s)`);
+                console.log("Press Ctrl+C to stop.\n");
+            }
+            const stop = responderClient.startPollingLoop((breakpoints) => {
+                displayBreakpoints(breakpoints, jsonMode);
+            }, intervalMs);
+            // Handle graceful shutdown
+            const shutdown = () => {
+                stop();
+                if (!jsonMode) {
+                    console.log("\nResponder loop stopped.");
+                }
+                process.exit(0);
+            };
+            process.on("SIGTERM", shutdown);
+            process.on("SIGINT", shutdown);
+            // Keep the process alive
+            await new Promise(() => {
+                // This promise never resolves; the process is kept alive
+                // until SIGTERM/SIGINT is received.
+            });
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    return cmd;
+}
+function displayBreakpoints(breakpoints, jsonMode) {
+    if (jsonMode) {
+        console.log(JSON.stringify(breakpoints, null, 2));
+        return;
+    }
+    if (breakpoints.length === 0) {
+        console.log("No pending breakpoints.");
+        return;
+    }
+    console.log(`Found ${breakpoints.length} pending breakpoint(s):\n`);
+    const rows = breakpoints.map((b) => [
+        b.id,
+        b.status,
+        b.text.length > 60 ? b.text.substring(0, 57) + "..." : b.text,
+        b.routing.strategy,
+        b.createdAt,
+    ]);
+    console.log(formatTable(rows, ["ID", "Status", "Breakpoint", "Strategy", "Created"]));
+    console.log("");
+}

package/dist/cli/commands/responders.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createRespondersCommand(): Command;
+//# sourceMappingURL=responders.d.ts.map

package/dist/cli/commands/responders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responders.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/responders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgBpC,wBAAgB,uBAAuB,IAAI,OAAO,CA6EjD"}

package/dist/cli/commands/responders.js

@@ -0,0 +1,74 @@
+import { Command } from "commander";
+import { ResponderMatcher } from "../../client/index.js";
+import { formatResponder, formatTable, printError } from "../output.js";
+export function createRespondersCommand() {
+    const cmd = new Command("responders").description("Manage and view responder profiles");
+    cmd
+        .command("list")
+        .description("List available responders")
+        .option("-d, --domain <domain>", "Filter by domain")
+        .action(async (opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const localOpts = opts;
+        const jsonMode = allOpts.json === true;
+        try {
+            const matcher = new ResponderMatcher({
+                responderDir: allOpts.responderDir,
+                repoRoot: allOpts.repoRoot,
+                configRoot: allOpts.configRoot,
+            });
+            const responders = await matcher.loadResponders();
+            let filtered = responders;
+            if (localOpts.domain) {
+                const domain = localOpts.domain.toLowerCase();
+                filtered = responders.filter((r) => r.domains.some((d) => d.toLowerCase().includes(domain)));
+            }
+            if (jsonMode) {
+                console.log(JSON.stringify(filtered, null, 2));
+            }
+            else if (filtered.length === 0) {
+                console.log("No responders found.");
+            }
+            else {
+                const rows = filtered.map((r) => [
+                    r.id,
+                    r.name,
+                    r.title,
+                    r.availability ? "yes" : "no",
+                    r.domains.join(", "),
+                ]);
+                console.log(formatTable(rows, ["ID", "Name", "Title", "Available", "Domains"]));
+            }
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("show")
+        .description("Show responder profile details")
+        .argument("<responderId>", "Responder ID")
+        .action(async (responderId, _opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            const matcher = new ResponderMatcher({
+                responderDir: allOpts.responderDir,
+                repoRoot: allOpts.repoRoot,
+                configRoot: allOpts.configRoot,
+            });
+            const responders = await matcher.loadResponders();
+            const responder = responders.find((r) => r.id === responderId);
+            if (!responder) {
+                throw new Error(`Responder not found: ${responderId}`);
+            }
+            console.log(formatResponder(responder, jsonMode));
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    return cmd;
+}

package/dist/cli/commands/server.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createServerCommand(): Command;
+//# sourceMappingURL=server.d.ts.map

package/dist/cli/commands/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWpC,wBAAgB,mBAAmB,IAAI,OAAO,CAoC7C"}

package/dist/cli/commands/server.js

@@ -0,0 +1,34 @@
+import { Command } from "commander";
+import { printError } from "../output.js";
+export function createServerCommand() {
+    const cmd = new Command("server").description("Server management commands");
+    cmd
+        .command("start")
+        .description("Start the tasks-mux MCP server (stdio)")
+        .action(async (_opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            if (allOpts.responderDir) {
+                process.env.BMUX_RESPONDER_DIR = allOpts.responderDir;
+            }
+            if (allOpts.repoRoot) {
+                process.env.BMUX_REPO_ROOT = allOpts.repoRoot;
+            }
+            if (allOpts.configRoot) {
+                process.env.BMUX_CONFIG_ROOT = allOpts.configRoot;
+            }
+            // Dynamically import the MCP server to avoid heavy dependency at load time
+            const { startBreakpointMcpServer } = await import("../../mcp/index.js");
+            if (!jsonMode) {
+                console.error("Starting tasks-mux MCP server on stdio...");
+            }
+            await startBreakpointMcpServer();
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    return cmd;
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+export { createProgram } from "./program.js";
+export declare const CLI_VERSION = "5.0.0";
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":";AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,eAAO,MAAM,WAAW,UAAU,CAAC"}

package/dist/cli/index.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { createProgram } from "./program.js";
+export { createProgram } from "./program.js";
+export const CLI_VERSION = "5.0.0";
+const program = createProgram();
+program.parseAsync(process.argv).catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/cli/output.d.ts

@@ -0,0 +1,26 @@
+import type { Breakpoint, BreakpointAnswer, ResponderProfile } from "../types.js";
+/**
+ * Format a breakpoint for display.
+ */
+export declare function formatBreakpoint(breakpoint: Breakpoint, jsonMode: boolean): string;
+/**
+ * Format an answer for display.
+ */
+export declare function formatAnswer(answer: BreakpointAnswer, jsonMode: boolean): string;
+/**
+ * Format a responder profile for display.
+ */
+export declare function formatResponder(responder: ResponderProfile, jsonMode: boolean): string;
+/**
+ * Format data as a simple table.
+ */
+export declare function formatTable(rows: string[][], headers: string[]): string;
+/**
+ * Print output, handling JSON mode.
+ */
+export declare function printOutput(data: unknown, jsonMode: boolean): void;
+/**
+ * Print an error, handling JSON mode.
+ */
+export declare function printError(error: unknown, jsonMode: boolean): void;
+//# sourceMappingURL=output.d.ts.map

package/dist/cli/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../src/cli/output.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAmBlF;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,CAuBlF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,CA8BhF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,CAqBtF;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CA2BvE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAQlE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAQlE"}

package/dist/cli/output.js

@@ -0,0 +1,143 @@
+/**
+ * Format a duration in milliseconds as a human-readable string.
+ */
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes < 60) {
+        return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
+}
+/**
+ * Format a breakpoint for display.
+ */
+export function formatBreakpoint(breakpoint, jsonMode) {
+    if (jsonMode) {
+        return JSON.stringify(breakpoint, null, 2);
+    }
+    const lines = [];
+    lines.push(`Breakpoint: ${breakpoint.id}`);
+    lines.push(`Status:     ${breakpoint.status}`);
+    lines.push(`Text:       ${breakpoint.text}`);
+    lines.push(`Strategy:   ${breakpoint.routing.strategy}`);
+    lines.push(`Responders: ${breakpoint.routing.targetResponders.join(", ") || "(none)"}`);
+    lines.push(`Created:    ${breakpoint.createdAt}`);
+    lines.push(`Expires:    ${breakpoint.expiresAt}`);
+    if (breakpoint.context.tags.length > 0) {
+        lines.push(`Tags:       ${breakpoint.context.tags.join(", ")}`);
+    }
+    if (breakpoint.answers.length > 0) {
+        lines.push(`Answers:    ${breakpoint.answers.length}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format an answer for display.
+ */
+export function formatAnswer(answer, jsonMode) {
+    if (jsonMode) {
+        return JSON.stringify(answer, null, 2);
+    }
+    const lines = [];
+    lines.push(`Answer:     ${answer.id}`);
+    lines.push(`Breakpoint: ${answer.breakpointId}`);
+    lines.push(`Responder:  ${answer.responderName} (${answer.responderId})`);
+    lines.push(`Confidence: ${answer.confidence}%`);
+    lines.push(`Answered:   ${answer.answeredAt}`);
+    lines.push(`---`);
+    lines.push(answer.text);
+    if (answer.references.length > 0) {
+        lines.push(`---`);
+        lines.push(`References:`);
+        for (const ref of answer.references) {
+            lines.push(`  - ${ref}`);
+        }
+    }
+    if (answer.followUpQuestions.length > 0) {
+        lines.push(`Follow-up questions:`);
+        for (const q of answer.followUpQuestions) {
+            lines.push(`  - ${q}`);
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Format a responder profile for display.
+ */
+export function formatResponder(responder, jsonMode) {
+    if (jsonMode) {
+        return JSON.stringify(responder, null, 2);
+    }
+    const lines = [];
+    lines.push(`Responder: ${responder.id}`);
+    lines.push(`Name:      ${responder.name}`);
+    lines.push(`Title:     ${responder.title}`);
+    lines.push(`Available: ${responder.availability ? "yes" : "no"}`);
+    lines.push(`Response SLA: ${formatDuration(responder.responseTimeSla)}`);
+    if (responder.domains.length > 0) {
+        lines.push(`Domains:   ${responder.domains.join(", ")}`);
+    }
+    if (responder.tags.length > 0) {
+        lines.push(`Tags:      ${responder.tags.join(", ")}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format data as a simple table.
+ */
+export function formatTable(rows, headers) {
+    if (rows.length === 0) {
+        return "(no results)";
+    }
+    // Calculate column widths
+    const widths = headers.map((h, i) => {
+        const maxDataWidth = rows.reduce((max, row) => Math.max(max, (row[i] ?? "").length), 0);
+        return Math.max(h.length, maxDataWidth);
+    });
+    const pad = (str, width) => str.padEnd(width);
+    const lines = [];
+    // Header row
+    lines.push(headers.map((h, i) => pad(h, widths[i])).join("  "));
+    // Separator
+    lines.push(widths.map((w) => "-".repeat(w)).join("  "));
+    // Data rows
+    for (const row of rows) {
+        lines.push(row.map((cell, i) => pad(cell ?? "", widths[i])).join("  "));
+    }
+    return lines.join("\n");
+}
+/**
+ * Print output, handling JSON mode.
+ */
+export function printOutput(data, jsonMode) {
+    if (jsonMode) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else if (typeof data === "string") {
+        console.log(data);
+    }
+    else {
+        console.log(data);
+    }
+}
+/**
+ * Print an error, handling JSON mode.
+ */
+export function printError(error, jsonMode) {
+    if (jsonMode) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(JSON.stringify({ error: message }));
+    }
+    else {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${message}`);
+    }
+}

package/dist/cli/program.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "commander";
+/**
+ * Create and configure the main CLI program.
+ */
+export declare function createProgram(): Command;
+//# sourceMappingURL=program.d.ts.map

package/dist/cli/program.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../../src/cli/program.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC;;GAEG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAmCvC"}

package/dist/cli/program.js

@@ -0,0 +1,32 @@
+import { Command } from "commander";
+import { createAskCommand } from "./commands/ask.js";
+import { createRespondersCommand } from "./commands/responders.js";
+import { createBreakpointsCommand } from "./commands/breakpoints.js";
+import { createServerCommand } from "./commands/server.js";
+import { createResponderLoopCommand } from "./commands/responder-loop.js";
+import { createAuthCommand } from "./commands/auth.js";
+import { DEFAULT_BMUX_SERVER_URL } from "../client/index.js";
+/**
+ * Create and configure the main CLI program.
+ */
+export function createProgram() {
+    const program = new Command();
+    program
+        .name("tasks-mux")
+        .version("5.0.0")
+        .description("CLI for Breakpoints Mux - route breakpoints to domain responders")
+        .option("--server-url <url>", `Server URL (defaults to ${DEFAULT_BMUX_SERVER_URL})`)
+        .option("--auth-token <token>", "Bearer token for BMUX API access")
+        .option("--json", "Output in JSON format", false)
+        .option("--responder-dir <path>", "Responder profile directory, relative to the associated repo or config root when not absolute")
+        .option("--repo-root <path>", "Associated repository root for resolving .a5c-based configuration")
+        .option("--config-root <path>", "Associated configuration root (.a5c) for resolving repo-scoped responder config");
+    // Register subcommands
+    program.addCommand(createAskCommand());
+    program.addCommand(createRespondersCommand());
+    program.addCommand(createBreakpointsCommand());
+    program.addCommand(createServerCommand());
+    program.addCommand(createResponderLoopCommand());
+    program.addCommand(createAuthCommand());
+    return program;
+}

package/dist/client/answer-poller.d.ts

@@ -0,0 +1,52 @@
+import type { BreakpointWaitResult } from "../types.js";
+import type { BreakpointBackend } from "../backend.js";
+import { ServerClient } from "./server-client.js";
+/**
+ * Options for waiting for an answer via the client-side poller.
+ */
+export interface PollerWaitForAnswerOptions {
+    /** Maximum time to wait in milliseconds. Defaults to DEFAULT_TIMEOUT_MS (30 min). */
+    timeoutMs?: number;
+    /** Polling interval in milliseconds when using HTTP polling. Defaults to DEFAULT_POLL_INTERVAL_MS (3s). */
+    pollIntervalMs?: number;
+    /** Whether to use SSE for real-time updates. Falls back to polling if false or on error. */
+    useSSE?: boolean;
+    /** AbortSignal for external cancellation. */
+    signal?: AbortSignal;
+}
+/**
+ * Waits for answers to breakpoints using either SSE streaming or HTTP polling.
+ *
+ * Accepts either a ServerClient (legacy) or a BreakpointBackend.
+ * When a BreakpointBackend is passed, delegates to its waitForAnswer method.
+ * When a ServerClient is passed, uses the existing SSE/polling logic.
+ */
+export declare class AnswerPoller {
+    private readonly client;
+    private readonly backend;
+    constructor(clientOrBackend: ServerClient | BreakpointBackend);
+    /**
+     * Wait for an answer to a breakpoint.
+     *
+     * Resolves when:
+     * - An answer is received (status becomes "answered" or "completed")
+     * - The breakpoint expires or is cancelled
+     * - The timeout is reached
+     * - The operation is aborted via AbortSignal
+     */
+    waitForAnswer(breakpointId: string, options?: PollerWaitForAnswerOptions): Promise<BreakpointWaitResult>;
+    /**
+     * Wait for an answer using SSE streaming.
+     */
+    private waitViaSSE;
+    /**
+     * Wait for an answer using HTTP polling.
+     */
+    private waitViaPolling;
+    /**
+     * Fetch the current breakpoint state and build a BreakpointWaitResult.
+     */
+    private buildResult;
+    private breakpointToResult;
+}
+//# sourceMappingURL=answer-poller.d.ts.map

package/dist/client/answer-poller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"answer-poller.d.ts","sourceRoot":"","sources":["../../src/client/answer-poller.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAc,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,qFAAqF;IACrF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2GAA2G;IAC3G,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,4FAA4F;IAC5F,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,6CAA6C;IAC7C,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;;GAMG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;gBAEvC,eAAe,EAAE,YAAY,GAAG,iBAAiB;IAU7D;;;;;;;;OAQG;IACG,aAAa,CACjB,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,oBAAoB,CAAC;IAmDhC;;OAEG;IACH,OAAO,CAAC,UAAU;IAkElB;;OAEG;YACW,cAAc;IA+B5B;;OAEG;YACW,WAAW;IA6BzB,OAAO,CAAC,kBAAkB;CAe3B"}