@a5c-ai/tasks-adapter 5.1.1-staging.0007199a1cb2

package/dist/cli/auth-store.js

@@ -0,0 +1,150 @@
+import { readFileSync, writeFileSync, mkdirSync, unlinkSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { AuthTokenSchema } from "../auth/index.js";
+// ── Constants ─────────────────────────────────────────────────────────────
+const BMUX_DIR = ".tasks-adapter";
+const AUTH_FILE = "auth.json";
+const CONFIG_FILE = "config.json";
+const KEYS_DIR = "keys";
+// ── Path helpers ─────────────────────────────────────────────────────────
+/**
+ * Get the path to the tasks-adapter config directory (~/.tasks-adapter).
+ */
+export function getBmuxDir() {
+    return join(homedir(), BMUX_DIR);
+}
+/**
+ * Get the path to the auth state file (~/.tasks-adapter/auth.json).
+ */
+export function getAuthStorePath() {
+    return join(getBmuxDir(), AUTH_FILE);
+}
+/**
+ * Get the path to the client config file (~/.tasks-adapter/config.json).
+ */
+export function getClientConfigPath() {
+    return join(getBmuxDir(), CONFIG_FILE);
+}
+/**
+ * Get the path to the SSH keys directory (~/.tasks-adapter/keys).
+ */
+export function getKeysDir() {
+    return join(getBmuxDir(), KEYS_DIR);
+}
+// ── Generic client config ───────────────────────────────────────────────
+/**
+ * Load CLI/MCP client configuration from ~/.tasks-adapter/config.json.
+ */
+export function loadClientConfig() {
+    const filePath = getClientConfigPath();
+    if (!existsSync(filePath)) {
+        return {};
+    }
+    try {
+        const raw = readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const config = {};
+        if (typeof parsed.serverUrl === "string" && parsed.serverUrl.trim().length > 0) {
+            config.serverUrl = parsed.serverUrl.trim();
+        }
+        if (typeof parsed.authToken === "string" && parsed.authToken.trim().length > 0) {
+            config.authToken = parsed.authToken.trim();
+        }
+        return config;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Save or update CLI/MCP client configuration in ~/.tasks-adapter/config.json.
+ */
+export function saveClientConfig(next) {
+    const dir = getBmuxDir();
+    mkdirSync(dir, { recursive: true });
+    const merged = { ...loadClientConfig() };
+    if (next.serverUrl !== undefined) {
+        const normalized = next.serverUrl.trim();
+        if (normalized.length > 0) {
+            merged.serverUrl = normalized;
+        }
+        else {
+            delete merged.serverUrl;
+        }
+    }
+    if (next.authToken !== undefined) {
+        const normalized = next.authToken.trim();
+        if (normalized.length > 0) {
+            merged.authToken = normalized;
+        }
+        else {
+            delete merged.authToken;
+        }
+    }
+    const filePath = getClientConfigPath();
+    if (Object.keys(merged).length === 0) {
+        if (existsSync(filePath)) {
+            unlinkSync(filePath);
+        }
+        return;
+    }
+    writeFileSync(filePath, JSON.stringify(merged, null, 2), {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+}
+// ── Auth state persistence ───────────────────────────────────────────────
+/**
+ * Load the stored authentication state from ~/.tasks-adapter/auth.json.
+ * Returns null if no auth file exists or the contents are invalid.
+ */
+export function loadAuthState() {
+    const filePath = getAuthStorePath();
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const raw = readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const result = AuthTokenSchema.safeParse(parsed);
+        if (!result.success) {
+            return null;
+        }
+        return result.data;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save authentication state to ~/.tasks-adapter/auth.json.
+ * Creates the directory if it does not exist.
+ * Sets file permissions to 0600 (owner read/write only).
+ */
+export function saveAuthState(state) {
+    const dir = getBmuxDir();
+    mkdirSync(dir, { recursive: true });
+    const filePath = getAuthStorePath();
+    writeFileSync(filePath, JSON.stringify(state, null, 2), {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+}
+/**
+ * Clear the stored authentication state by removing ~/.tasks-adapter/auth.json.
+ */
+export function clearAuthState() {
+    const filePath = getAuthStorePath();
+    if (existsSync(filePath)) {
+        unlinkSync(filePath);
+    }
+}
+// ── Token expiration ─────────────────────────────────────────────────────
+/**
+ * Check whether a token has expired based on its expiresAt timestamp.
+ */
+export function isTokenExpired(expiresAt) {
+    const expiry = new Date(expiresAt).getTime();
+    return Date.now() >= expiry;
+}

package/dist/cli/client-config.d.ts

@@ -0,0 +1,10 @@
+import { ServerClient } from "../client/index.js";
+export interface CliConnectionOptions {
+    serverUrl?: string;
+    authToken?: string;
+}
+export declare function resolveServerUrl(explicit?: string): string;
+export declare function resolveApiBaseUrl(explicit?: string): string;
+export declare function resolveAuthToken(serverUrl?: string, explicit?: string): Promise<string | undefined>;
+export declare function createCliServerClient(options?: CliConnectionOptions): Promise<ServerClient>;
+//# sourceMappingURL=client-config.d.ts.map

package/dist/cli/client-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-config.d.ts","sourceRoot":"","sources":["../../src/cli/client-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuC,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGvF,MAAM,WAAW,oBAAoB;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA4BD,wBAAgB,gBAAgB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAS1D;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAG3D;AAED,wBAAsB,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAyDzG;AAED,wBAAsB,qBAAqB,CAAC,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,YAAY,CAAC,CAQrG"}

package/dist/cli/client-config.js

@@ -0,0 +1,87 @@
+import { AuthClient, DEFAULT_BMUX_SERVER_URL, ServerClient } from "../client/index.js";
+import { isTokenExpired, loadAuthState, loadClientConfig, saveAuthState } from "./auth-store.js";
+function normalizeTrimmed(value) {
+    const normalized = value?.trim();
+    return normalized && normalized.length > 0 ? normalized : undefined;
+}
+function decodeJwtExpiry(token) {
+    const parts = token.split(".");
+    if (parts.length < 2) {
+        return undefined;
+    }
+    try {
+        const payload = JSON.parse(Buffer.from(parts[1].replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf-8"));
+        if (typeof payload.exp !== "number") {
+            return undefined;
+        }
+        return new Date(payload.exp * 1000).toISOString();
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resolveServerUrl(explicit) {
+    const config = loadClientConfig();
+    return (normalizeTrimmed(explicit) ??
+        normalizeTrimmed(process.env.BMUX_SERVER_URL) ??
+        normalizeTrimmed(process.env.SERVER_URL) ??
+        normalizeTrimmed(config.serverUrl) ??
+        DEFAULT_BMUX_SERVER_URL).replace(/\/+$/, "");
+}
+export function resolveApiBaseUrl(explicit) {
+    const serverUrl = resolveServerUrl(explicit);
+    return serverUrl.endsWith("/api/v1") ? serverUrl : `${serverUrl}/api/v1`;
+}
+export async function resolveAuthToken(serverUrl, explicit) {
+    const config = loadClientConfig();
+    const configuredToken = normalizeTrimmed(explicit) ??
+        normalizeTrimmed(process.env.BMUX_AUTH_TOKEN) ??
+        normalizeTrimmed(process.env.AUTH_TOKEN) ??
+        normalizeTrimmed(config.authToken);
+    if (configuredToken) {
+        return configuredToken;
+    }
+    const session = loadAuthState();
+    if (!session?.accessToken) {
+        return undefined;
+    }
+    if (!isTokenExpired(session.expiresAt)) {
+        return session.accessToken;
+    }
+    if (!session.refreshToken) {
+        return session.accessToken;
+    }
+    let refreshedTokens;
+    const client = new AuthClient({
+        serverUrl: resolveApiBaseUrl(serverUrl),
+        token: session.accessToken,
+        refreshToken: session.refreshToken,
+        onTokenRefresh: (tokens) => {
+            refreshedTokens = tokens;
+        },
+    });
+    try {
+        const user = await client.getUser();
+        if (refreshedTokens) {
+            saveAuthState({
+                accessToken: refreshedTokens.accessToken,
+                refreshToken: refreshedTokens.refreshToken,
+                expiresAt: decodeJwtExpiry(refreshedTokens.accessToken) ?? session.expiresAt,
+                user,
+            });
+            return refreshedTokens.accessToken;
+        }
+    }
+    catch {
+        // Fall back to the stored token and let the command surface the real server error.
+    }
+    return session.accessToken;
+}
+export async function createCliServerClient(options = {}) {
+    const baseUrl = resolveApiBaseUrl(options.serverUrl);
+    const token = await resolveAuthToken(options.serverUrl, options.authToken);
+    return new ServerClient({
+        baseUrl,
+        defaultHeaders: token ? { Authorization: `Bearer ${token}` } : undefined,
+    });
+}

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

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

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

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

package/dist/cli/commands/ask.js

@@ -0,0 +1,171 @@
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { AnswerPoller, } from "../../client/index.js";
+import { DEFAULT_POLL_INTERVAL_MS } from "../../types.js";
+import { formatBreakpoint, formatAnswer, printError } from "../output.js";
+import { createCliServerClient } from "../client-config.js";
+function collectValues(value, previous = []) {
+    previous.push(value);
+    return previous;
+}
+function parseContextFile(filePath) {
+    const raw = readFileSync(filePath, "utf-8");
+    if (filePath.toLowerCase().endsWith(".json")) {
+        return JSON.parse(raw);
+    }
+    return { description: raw };
+}
+function parseLinks(values = []) {
+    return values.map((value) => {
+        const [label, url] = value.includes("=") ? value.split(/=(.*)/s, 2) : [value, value];
+        return {
+            label: label.trim(),
+            url: url.trim(),
+            kind: "reference",
+        };
+    });
+}
+function buildBreakpointContext(opts) {
+    const fileContext = opts.contextFile ? parseContextFile(opts.contextFile) : {};
+    const markdownFromFile = opts.markdownFile ? readFileSync(opts.markdownFile, "utf-8") : undefined;
+    const parsedLinks = parseLinks(opts.link);
+    return {
+        description: opts.context ?? fileContext.description ?? "",
+        codeSnippets: opts.code ?? fileContext.codeSnippets ?? [],
+        fileReferences: opts.fileRef ?? fileContext.fileReferences ?? [],
+        tags: opts.tag ?? fileContext.tags ?? [],
+        title: fileContext.title,
+        summary: fileContext.summary,
+        markdown: opts.markdown ?? markdownFromFile ?? fileContext.markdown,
+        links: (parsedLinks.length > 0 ? parsedLinks : fileContext.links),
+        sections: fileContext.sections,
+        artifacts: fileContext.artifacts,
+        metadata: fileContext.metadata,
+    };
+}
+function openBrowser(url) {
+    if (process.env.VITEST || process.env.CI || process.env.NODE_ENV === "test" || process.env.BMUX_NO_BROWSER)
+        return;
+    const platform = process.platform;
+    if (platform === "win32") {
+        spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" }).unref();
+        return;
+    }
+    if (platform === "darwin") {
+        spawn("open", [url], { detached: true, stdio: "ignore" }).unref();
+        return;
+    }
+    spawn("xdg-open", [url], { detached: true, stdio: "ignore" }).unref();
+}
+export function createAskCommand() {
+    const cmd = new Command("ask")
+        .description("Submit a breakpoint to responders")
+        .requiredOption("-q, --question <text>", "Breakpoint text")
+        .option("-c, --context <text>", "Additional context for the breakpoint", "")
+        .option("--context-file <path>", "Load structured context from a JSON or text file")
+        .option("--markdown <text>", "Markdown body to render in the browser session")
+        .option("--markdown-file <path>", "Load markdown body from a file")
+        .option("--code <snippet>", "Add a code snippet to the context", collectValues, [])
+        .option("--file-ref <path>", "Add a file reference to the context", collectValues, [])
+        .option("--tag <tag>", "Add a tag to the context", collectValues, [])
+        .option("--link <label=url>", "Add a rich reference link to the context", collectValues, [])
+        .option("-e, --responders <ids>", "Comma-separated list of responder IDs")
+        .requiredOption("-p, --project <id>", "Associate the breakpoint with a project ID")
+        .requiredOption("-r, --repo <id>", "Associate the breakpoint with a repository ID")
+        .option("-s, --strategy <strategy>", "Routing strategy (single, first-response-wins, collect-all, quorum)", "first-response-wins")
+        .option("-t, --timeout <seconds>", "Timeout in seconds", "300")
+        .option("-w, --wait", "Wait for an answer before returning", false)
+        .option("--open-browser", "Open a browser session for answering", false)
+        .option("--answerer-id <id>", "Identity to attach to browser-session answers")
+        .option("--answerer-name <name>", "Display name for browser-session answers")
+        .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 timeoutMs = parseInt(localOpts.timeout ?? "300", 10) * 1000;
+            const responderIds = localOpts.responders
+                ? localOpts.responders.split(",").map((e) => e.trim())
+                : [];
+            const projectId = localOpts.project?.trim();
+            const repoId = localOpts.repo?.trim();
+            if (!projectId || !repoId) {
+                throw new Error("Both --project and --repo are required.");
+            }
+            const context = buildBreakpointContext(localOpts);
+            const routing = {
+                strategy: (localOpts.strategy ?? "first-response-wins"),
+                targetResponders: responderIds,
+                timeoutMs,
+                presentToUser: false,
+            };
+            const breakpoint = await client.submitBreakpoint({
+                text: localOpts.question,
+                context,
+                routing,
+                projectId,
+                repoId,
+            });
+            let browserSession;
+            if (localOpts.wait || localOpts.openBrowser) {
+                browserSession = await client.createBrowserSession(breakpoint.id, {
+                    mode: "same-user",
+                    responderId: localOpts.answererId,
+                    responderName: localOpts.answererName,
+                });
+                try {
+                    openBrowser(browserSession.url);
+                }
+                catch {
+                    // Opening the browser is best-effort. The URL is still surfaced below.
+                }
+            }
+            if (localOpts.wait) {
+                const poller = new AnswerPoller(client);
+                const result = await poller.waitForAnswer(breakpoint.id, {
+                    timeoutMs,
+                    pollIntervalMs: DEFAULT_POLL_INTERVAL_MS,
+                    useSSE: true,
+                });
+                if (jsonMode) {
+                    console.log(JSON.stringify({ ...result, browserSession }, null, 2));
+                }
+                else {
+                    console.log(formatBreakpoint(result.breakpoint, false));
+                    if (browserSession) {
+                        console.log(`\nBrowser session: ${browserSession.url}`);
+                    }
+                    if (result.answer) {
+                        console.log("");
+                        console.log(formatAnswer(result.answer, false));
+                    }
+                    else {
+                        console.log("\nNo answer received within timeout.");
+                    }
+                }
+            }
+            else {
+                if (jsonMode) {
+                    console.log(JSON.stringify({ breakpoint, browserSession }, null, 2));
+                }
+                else {
+                    console.log(formatBreakpoint(breakpoint, false));
+                    if (browserSession) {
+                        console.log(`\nBrowser session: ${browserSession.url}`);
+                    }
+                    console.log(`\nUse "tasks-adapter breakpoints poll ${breakpoint.id}" to wait for answers.`);
+                }
+            }
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    return cmd;
+}

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

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

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

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