@mafdet/cli 0.3.0

package/dist/commands/config.js

@@ -0,0 +1,74 @@
+import { ConfigError } from "../config/config.js";
+import { loadConfig } from "../config/load.js";
+import { ExitCode } from "../output/exit-codes.js";
+import { keyFingerprint } from "../security/redact.js";
+const USAGE = `Usage:
+  mafdet config list [--json]
+`;
+/**
+ * `config list` answers "what settings is the CLI actually using, and where
+ * did each come from" — the question a user asks when a run picks a model they
+ * did not expect. The key is only ever shown as a fingerprint.
+ */
+export function configCommand(argv, io) {
+    const [subcommand, ...rest] = argv;
+    if (subcommand !== "list") {
+        io.stderr(subcommand === undefined
+            ? USAGE
+            : `mafdet config: unknown subcommand '${subcommand}'\n${USAGE}`);
+        return ExitCode.Usage;
+    }
+    const json = rest.includes("--json");
+    const unknown = rest.filter((arg) => arg !== "--json");
+    if (unknown.length > 0) {
+        io.stderr(`mafdet config list: unexpected argument '${unknown[0]}'\n${USAGE}`);
+        return ExitCode.Usage;
+    }
+    let config;
+    try {
+        config = loadConfig({
+            env: io.env,
+            cwd: io.cwd,
+            userConfigFile: io.userConfigFile,
+        });
+    }
+    catch (error) {
+        if (error instanceof ConfigError) {
+            io.stderr(`mafdet config: ${error.message}\n`);
+            return ExitCode.Usage;
+        }
+        throw error;
+    }
+    const view = {
+        model: config.model ?? null,
+        model_source: config.modelSource,
+        base_url: config.baseUrl,
+        backend_url: config.backendUrl,
+        approval_mode: config.approvalMode,
+        api_key: config.apiKey ? keyFingerprint(config.apiKey) : null,
+        user_config: config.sources.userConfigFound
+            ? config.sources.userConfigPath
+            : null,
+        project_config: config.sources.projectConfigFound
+            ? config.sources.projectConfigPath
+            : null,
+    };
+    if (json) {
+        io.stdout(`${JSON.stringify(view, null, 2)}\n`);
+        return ExitCode.Ok;
+    }
+    const rows = [
+        ["model", view.model ? `${view.model} (${view.model_source})` : "<unset>"],
+        ["base url", view.base_url],
+        ["backend url", view.backend_url],
+        ["approval mode", view.approval_mode],
+        ["api key", view.api_key ?? "<unset> (set MAFDET_API_KEY)"],
+        ["user config", view.user_config ?? "<none>"],
+        ["project config", view.project_config ?? "<none>"],
+    ];
+    const width = Math.max(...rows.map(([label]) => label.length));
+    io.stdout(rows
+        .map(([label, value]) => `${label.padEnd(width)}  ${value}`)
+        .join("\n") + "\n");
+    return ExitCode.Ok;
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,15 @@
+import { ExitCode } from "../output/exit-codes.js";
+import { type CommandIo } from "./runtime.js";
+export interface DoctorIo extends CommandIo {
+    /** Injected by tests so the git probe stays hermetic. */
+    hasGit?: () => boolean;
+    nodeVersion?: string;
+}
+/**
+ * One pass over everything that has to be true before a real call works, so a
+ * failure is diagnosed once here instead of surfacing as a confusing error in
+ * the middle of a task. Every line is redacted; the key appears only as a
+ * fingerprint.
+ */
+export declare function doctorCommand(argv: readonly string[], io: DoctorIo): Promise<ExitCode>;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/commands/doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAInD,OAAO,EAAgB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAY5D,MAAM,WAAW,QAAS,SAAQ,SAAS;IACzC,yDAAyD;IACzD,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,EAAE,QAAQ,GACX,OAAO,CAAC,QAAQ,CAAC,CAyFnB"}

package/dist/commands/doctor.js

@@ -0,0 +1,157 @@
+import { accessSync, constants } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { fetchWallet } from "../api/account.js";
+import { ApiError } from "../api/errors.js";
+import { fetchAccessibleModels, fetchCatalog, intersectModels, } from "../api/models.js";
+import { ConfigError } from "../config/config.js";
+import { ExitCode } from "../output/exit-codes.js";
+import { parseFormatFlags, renderJson, renderTable } from "../output/format.js";
+import { formatUsd } from "../output/money.js";
+import { keyFingerprint, redact } from "../security/redact.js";
+import { buildRuntime } from "./runtime.js";
+const MINIMUM_NODE_MAJOR = 20;
+/**
+ * One pass over everything that has to be true before a real call works, so a
+ * failure is diagnosed once here instead of surfacing as a confusing error in
+ * the middle of a task. Every line is redacted; the key appears only as a
+ * fingerprint.
+ */
+export async function doctorCommand(argv, io) {
+    let format;
+    try {
+        ({ format } = parseFormatFlags(argv));
+    }
+    catch (error) {
+        io.stderr(`mafdet doctor: ${error.message}\n`);
+        return ExitCode.Usage;
+    }
+    const checks = [];
+    const add = (name, status, detail) => checks.push({ name, status, detail: redact(detail) });
+    const nodeVersion = io.nodeVersion ?? process.version;
+    const major = Number(nodeVersion.replace(/^v/, "").split(".")[0]);
+    add("node", Number.isFinite(major) && major >= MINIMUM_NODE_MAJOR ? "ok" : "fail", `${nodeVersion} (needs ${MINIMUM_NODE_MAJOR}+)`);
+    // Configuration first: an unreadable config or a downgraded endpoint stops
+    // everything else from meaning anything.
+    let runtime;
+    try {
+        runtime = buildRuntime(io);
+    }
+    catch (error) {
+        add("config", "fail", error instanceof ConfigError ? error.message : String(error));
+        return report(checks, format, io);
+    }
+    const { config } = runtime;
+    add("base url", "ok", config.baseUrl);
+    add("backend url", "ok", config.backendUrl);
+    add("api key", config.apiKey ? "ok" : "fail", config.apiKey
+        ? keyFingerprint(config.apiKey)
+        : "unset - set MAFDET_API_KEY");
+    await addWorkspaceChecks(add, io);
+    if (!config.apiKey)
+        return report(checks, format, io);
+    // Data plane: does the key work at all, and what may it call?
+    let accessible = [];
+    try {
+        accessible = await fetchAccessibleModels(runtime.dataPlane);
+        add("data plane", "ok", `${accessible.length} model(s) callable`);
+    }
+    catch (error) {
+        add("data plane", "fail", describe(error));
+    }
+    let catalog = [];
+    try {
+        catalog = await fetchCatalog(runtime.accountPlane);
+        add("catalogue", "ok", `${catalog.length} model(s) published`);
+    }
+    catch (error) {
+        add("catalogue", "warn", describe(error));
+    }
+    addModelChecks(add, config.model, accessible, catalog);
+    // account:read is optional: without it model calls still work, so a missing
+    // scope is a warning, not a failure.
+    try {
+        const wallet = await fetchWallet(runtime.accountPlane);
+        const available = BigInt(wallet.available_micro_usd);
+        add("balance", available > 0n ? "ok" : "fail", `${formatUsd(wallet.available_micro_usd)} available`);
+    }
+    catch (error) {
+        const scopeProblem = error instanceof ApiError && error.kind === "auth";
+        add("account:read", scopeProblem ? "warn" : "fail", scopeProblem ? "not granted - model calls still work" : describe(error));
+    }
+    return report(checks, format, io);
+}
+function addModelChecks(add, model, accessible, catalog) {
+    if (!model) {
+        add("model", "warn", "none selected - pass --model or set MAFDET_MODEL");
+        return;
+    }
+    const sets = intersectModels(accessible, catalog);
+    const resolved = sets.available.find((m) => m.modelId === model);
+    if (!resolved) {
+        // Say which of the two reasons it is; the server's 403 cannot.
+        if (sets.inaccessible.includes(model)) {
+            add("model", "fail", `${model} exists but this key may not call it`);
+        }
+        else if (sets.unlisted.includes(model)) {
+            add("model", "warn", `${model} is callable but the catalogue does not describe it`);
+        }
+        else {
+            add("model", "fail", `${model} is not callable with this key`);
+        }
+        return;
+    }
+    add("model", "ok", `${model} (${resolved.apiSurface ?? "CHAT_COMPLETIONS"})`);
+    add("tool calling", resolved.agentEligible ? "ok" : "warn", resolved.agentEligible
+        ? "verified - usable by the agent"
+        : "not verified for this model; the agent will refuse it");
+}
+async function addWorkspaceChecks(add, io) {
+    const cwd = io.cwd ?? process.cwd();
+    try {
+        accessSync(cwd, constants.R_OK);
+        let writable = true;
+        try {
+            accessSync(cwd, constants.W_OK);
+        }
+        catch {
+            writable = false;
+        }
+        add("workspace", writable ? "ok" : "warn", `${cwd}${writable ? "" : " (read-only)"}`);
+    }
+    catch {
+        add("workspace", "fail", `${cwd} is not readable`);
+    }
+    const hasGit = io.hasGit ?? defaultHasGit;
+    add("git", hasGit() ? "ok" : "warn", hasGit()
+        ? "available"
+        : "not found - diff and status tools will be unavailable");
+}
+function defaultHasGit() {
+    try {
+        execFileSync("git", ["--version"], { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function report(checks, format, io) {
+    const failed = checks.filter((check) => check.status === "fail").length;
+    if (format === "json") {
+        io.stdout(renderJson({ ok: failed === 0, checks }));
+    }
+    else {
+        const mark = { ok: "ok", warn: "warn", fail: "FAIL" };
+        io.stdout(renderTable(checks, [
+            { header: "", value: (c) => mark[c.status] },
+            { header: "CHECK", value: (c) => c.name },
+            { header: "DETAIL", value: (c) => c.detail },
+        ]));
+    }
+    // Warnings are survivable — a missing scope or an unverified model does not
+    // stop a chat — so only a real failure changes the exit code.
+    return failed === 0 ? ExitCode.Ok : ExitCode.General;
+}

package/dist/commands/embed.d.ts

@@ -0,0 +1,7 @@
+import { ExitCode } from "../output/exit-codes.js";
+import { type CommandIo } from "./runtime.js";
+export interface EmbedIo extends CommandIo {
+    readStdin?: () => Promise<string>;
+}
+export declare function embedCommand(argv: readonly string[], io: EmbedIo): Promise<ExitCode>;
+//# sourceMappingURL=embed.d.ts.map

package/dist/commands/embed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embed.d.ts","sourceRoot":"","sources":["../../src/commands/embed.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAEnD,OAAO,EAIL,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AAQtB,MAAM,WAAW,OAAQ,SAAQ,SAAS;IACxC,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;CACnC;AAED,wBAAsB,YAAY,CAChC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,EAAE,OAAO,GACV,OAAO,CAAC,QAAQ,CAAC,CA8DnB"}

package/dist/commands/embed.js

@@ -0,0 +1,105 @@
+import { readFileSync } from "node:fs";
+import { ApiError } from "../api/errors.js";
+import { assertSurface, fetchCatalog, SurfaceMismatchError, } from "../api/models.js";
+import { ExitCode } from "../output/exit-codes.js";
+import { writeOutputFile } from "../output/write-file.js";
+import { buildRuntime, reportError, requireApiKey, } from "./runtime.js";
+const USAGE = `Usage:
+  mafdet embed [text | <file>] --model <id> [--output <file>] [--force]
+
+Reads the text from an argument, a file, or stdin.
+`;
+export async function embedCommand(argv, io) {
+    try {
+        const runtime = buildRuntime(io);
+        requireApiKey(runtime.config);
+        let model = runtime.config.model;
+        let output;
+        let force = false;
+        const positional = [];
+        for (let i = 0; i < argv.length; i += 1) {
+            const arg = argv[i];
+            const next = () => argv[(i += 1)];
+            if (arg === "--model")
+                model = next();
+            else if (arg === "--output" || arg === "-o")
+                output = next();
+            else if (arg === "--force")
+                force = true;
+            else if (arg.startsWith("--")) {
+                io.stderr(`mafdet embed: unknown option '${arg}'\n${USAGE}`);
+                return ExitCode.Usage;
+            }
+            else
+                positional.push(arg);
+        }
+        if (!model) {
+            io.stderr("mafdet embed: no model. Pass --model or set MAFDET_MODEL.\n");
+            return ExitCode.Usage;
+        }
+        const input = await resolveInput(positional, io);
+        if (input === undefined)
+            return ExitCode.Usage;
+        // Catch the wrong-surface mistake locally, before it costs a request.
+        const catalog = await fetchCatalog(runtime.accountPlane).catch(() => []);
+        assertSurface(catalog, model, "EMBEDDINGS");
+        const { data } = await runtime.dataPlane.postJson("/embeddings", {
+            model,
+            input,
+        });
+        // Re-serialising a parsed double is exact in JavaScript, but the vector is
+        // the product here — pretty-print it and nothing else, so the file is both
+        // valid JSON and byte-for-byte reproducible.
+        const body = `${JSON.stringify(data, null, 2)}\n`;
+        if (output) {
+            writeOutputFile(output, body, { force });
+            const dimensions = firstVectorLength(data);
+            io.stderr(`wrote ${output}${dimensions === undefined ? "" : ` (${dimensions} dimensions)`}\n`);
+            return ExitCode.Ok;
+        }
+        io.stdout(body);
+        return ExitCode.Ok;
+    }
+    catch (error) {
+        if (error instanceof SurfaceMismatchError) {
+            io.stderr(`mafdet embed: ${error.message}\n`);
+            return ExitCode.Usage;
+        }
+        return reportError(error, io);
+    }
+}
+async function resolveInput(positional, io) {
+    if (positional.length > 1) {
+        io.stderr(`mafdet embed: expected one input, got ${positional.length}\n${USAGE}`);
+        return undefined;
+    }
+    if (positional.length === 1) {
+        const value = positional[0];
+        // A path is read; anything else is the text itself. Reading a file that
+        // happens to exist is the useful default for `mafdet embed input.txt`.
+        try {
+            return readFileSync(value, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return value;
+            throw new ApiError({
+                kind: "request",
+                exitCode: ExitCode.Usage,
+                message: `cannot read ${value}: ${error.message}`,
+            });
+        }
+    }
+    if (io.readStdin && !process.stdin.isTTY) {
+        const piped = (await io.readStdin()).trim();
+        if (piped.length > 0)
+            return piped;
+    }
+    io.stderr(`mafdet embed: no input\n${USAGE}`);
+    return undefined;
+}
+function firstVectorLength(body) {
+    const vector = body?.data?.[0]
+        ?.embedding;
+    return Array.isArray(vector) ? vector.length : undefined;
+}

package/dist/commands/models.d.ts

@@ -0,0 +1,4 @@
+import { ExitCode } from "../output/exit-codes.js";
+import { type CommandIo } from "./runtime.js";
+export declare function modelsCommand(argv: readonly string[], io: CommandIo): Promise<ExitCode>;
+//# sourceMappingURL=models.d.ts.map

package/dist/commands/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../src/commands/models.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAUnD,OAAO,EAIL,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AA0BtB,wBAAsB,aAAa,CACjC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,EAAE,SAAS,GACZ,OAAO,CAAC,QAAQ,CAAC,CA6BnB"}

package/dist/commands/models.js

@@ -0,0 +1,151 @@
+import { fetchAccessibleModels, fetchCatalog, intersectModels, } from "../api/models.js";
+import { ExitCode } from "../output/exit-codes.js";
+import { parseFormatFlags, renderJson, renderPlain, renderRecord, renderTable, } from "../output/format.js";
+import { formatUsd } from "../output/money.js";
+import { buildRuntime, reportError, requireApiKey, } from "./runtime.js";
+const USAGE = `Usage:
+  mafdet models list [--surface <chat|embeddings|speech>] [--agent] [--json|--plain]
+  mafdet models show <model-id> [--json]
+`;
+const SURFACES = {
+    chat: "CHAT_COMPLETIONS",
+    embeddings: "EMBEDDINGS",
+    speech: "AUDIO_SPEECH",
+    realtime: "REALTIME",
+};
+const columns = [
+    { header: "MODEL", value: (m) => m.modelId },
+    { header: "PROVIDER", value: (m) => m.provider ?? "-" },
+    { header: "SURFACE", value: (m) => m.apiSurface ?? "-" },
+    {
+        header: "CONTEXT",
+        value: (m) => String(m.contextLength ?? "-"),
+        align: "right",
+    },
+    { header: "AGENT", value: (m) => (m.agentEligible ? "yes" : "-") },
+];
+export async function modelsCommand(argv, io) {
+    const [subcommand, ...rest] = argv;
+    if (subcommand !== "list" && subcommand !== "show") {
+        io.stderr(subcommand === undefined
+            ? USAGE
+            : `mafdet models: unknown subcommand '${subcommand}'\n${USAGE}`);
+        return ExitCode.Usage;
+    }
+    try {
+        const { format, rest: args } = parseFormatFlags(rest);
+        const runtime = buildRuntime(io);
+        requireApiKey(runtime.config);
+        // Both planes are needed: one proves access, the other explains the model.
+        const [accessible, catalog] = await Promise.all([
+            fetchAccessibleModels(runtime.dataPlane),
+            fetchCatalog(runtime.accountPlane),
+        ]);
+        const sets = intersectModels(accessible, catalog);
+        return subcommand === "list"
+            ? listModels(sets, args, format, io)
+            : showModel(sets, args, format, io);
+    }
+    catch (error) {
+        return reportError(error, io);
+    }
+}
+function listModels(sets, args, format, io) {
+    let rows = sets.available;
+    const remaining = [...args];
+    const agentOnly = remaining.includes("--agent");
+    if (agentOnly)
+        remaining.splice(remaining.indexOf("--agent"), 1);
+    const surfaceAt = remaining.indexOf("--surface");
+    if (surfaceAt !== -1) {
+        const name = remaining[surfaceAt + 1];
+        const surface = name ? SURFACES[name] : undefined;
+        if (!surface) {
+            io.stderr(`mafdet models: unknown surface '${name ?? ""}' (expected ${Object.keys(SURFACES).join(", ")})\n`);
+            return ExitCode.Usage;
+        }
+        rows = rows.filter((m) => (m.apiSurface ?? "CHAT_COMPLETIONS") === surface);
+        remaining.splice(surfaceAt, 2);
+    }
+    if (agentOnly)
+        rows = rows.filter((m) => m.agentEligible);
+    if (remaining.length > 0) {
+        io.stderr(`mafdet models list: unexpected argument '${remaining[0]}'\n${USAGE}`);
+        return ExitCode.Usage;
+    }
+    if (format === "json") {
+        io.stdout(renderJson({
+            models: rows,
+            // Callable but undescribed. Surfaced rather than hidden, because the
+            // user can still use them with an explicit --model.
+            unlisted: sets.unlisted,
+            inaccessible: sets.inaccessible,
+        }));
+        return ExitCode.Ok;
+    }
+    if (rows.length === 0) {
+        io.stderr("mafdet: no models match\n");
+        return ExitCode.Ok;
+    }
+    io.stdout(format === "plain"
+        ? renderPlain(rows, columns)
+        : renderTable(rows, columns));
+    if (format === "table" && sets.unlisted.length > 0) {
+        io.stderr(`note: ${sets.unlisted.length} model(s) callable but missing from the catalogue: ${sets.unlisted.join(", ")}\n`);
+    }
+    return ExitCode.Ok;
+}
+function showModel(sets, args, format, io) {
+    const [modelId, ...extra] = args;
+    if (!modelId || extra.length > 0) {
+        io.stderr(USAGE);
+        return ExitCode.Usage;
+    }
+    const model = sets.available.find((m) => m.modelId === modelId);
+    if (!model) {
+        // Distinguish the two reasons the server cannot: a 403 looks identical for
+        // "not allowed" and "no such model" (CLI-001).
+        if (sets.inaccessible.includes(modelId)) {
+            io.stderr(`mafdet: '${modelId}' exists but this key may not call it\n`);
+        }
+        else if (sets.unlisted.includes(modelId)) {
+            io.stderr(`mafdet: '${modelId}' is callable but the catalogue does not describe it\n`);
+        }
+        else {
+            io.stderr(`mafdet: no such model '${modelId}'\n`);
+        }
+        return ExitCode.Usage;
+    }
+    if (format === "json") {
+        io.stdout(renderJson(model));
+        return ExitCode.Ok;
+    }
+    io.stdout(renderRecord([
+        ["model", model.modelId],
+        ["name", model.displayName ?? "-"],
+        ["provider", model.provider ?? "-"],
+        ["surface", model.apiSurface ?? "-"],
+        ["context", String(model.contextLength ?? "-")],
+        ["capabilities", (model.capabilities ?? []).join(", ") || "-"],
+        ["agent eligible", model.agentEligible ? "yes" : "no"],
+        [
+            "input / 1M",
+            model.inputPricePer1mMicroUsd
+                ? formatUsd(model.inputPricePer1mMicroUsd)
+                : "-",
+        ],
+        [
+            "output / 1M",
+            model.outputPricePer1mMicroUsd
+                ? formatUsd(model.outputPricePer1mMicroUsd)
+                : "-",
+        ],
+        [
+            "deprecated",
+            model.deprecated
+                ? `yes${model.retires_at ? ` (retires ${model.retires_at})` : ""}`
+                : "no",
+        ],
+    ]));
+    return ExitCode.Ok;
+}

package/dist/commands/runtime.d.ts

@@ -0,0 +1,29 @@
+import { type LoadedConfig } from "../config/load.js";
+import { HttpClient } from "../api/http.js";
+import { ExitCode } from "../output/exit-codes.js";
+export interface CommandIo {
+    stdout: (text: string) => void;
+    stderr: (text: string) => void;
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+    userConfigFile?: string;
+    /** Injected by tests; production uses global fetch. */
+    fetchImpl?: typeof fetch;
+    version?: string;
+}
+export interface Runtime {
+    config: LoadedConfig;
+    /** api.mafdet.ai/v1 — model calls. */
+    dataPlane: HttpClient;
+    /** backend.mafdet.ai — account reads. */
+    accountPlane: HttpClient;
+}
+export declare function userAgent(version: string): string;
+export declare function buildRuntime(io: CommandIo): Runtime;
+export declare function requireApiKey(config: LoadedConfig): void;
+/**
+ * Turn any failure into an exit code and a single stderr line. Nothing here
+ * prints a raw upstream message: ApiError redacted it at construction.
+ */
+export declare function reportError(error: unknown, io: CommandIo): ExitCode;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/commands/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/commands/runtime.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAE5C,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAEnD,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,uDAAuD;IACvD,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,OAAO;IACtB,MAAM,EAAE,YAAY,CAAC;IACrB,sCAAsC;IACtC,SAAS,EAAE,UAAU,CAAC;IACtB,yCAAyC;IACzC,YAAY,EAAE,UAAU,CAAC;CAC1B;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGjD;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAgBnD;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CASxD;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,SAAS,GAAG,QAAQ,CAkBnE"}

package/dist/commands/runtime.js

@@ -0,0 +1,56 @@
+import { ConfigError } from "../config/config.js";
+import { loadConfig } from "../config/load.js";
+import { HttpClient } from "../api/http.js";
+import { ApiError } from "../api/errors.js";
+import { ExitCode } from "../output/exit-codes.js";
+export function userAgent(version) {
+    // Identifiable, and carrying nothing about the user (plan §9.2).
+    return `mafdet-cli/${version}`;
+}
+export function buildRuntime(io) {
+    const config = loadConfig({
+        env: io.env,
+        cwd: io.cwd,
+        userConfigFile: io.userConfigFile,
+    });
+    const shared = {
+        apiKey: config.apiKey,
+        userAgent: userAgent(io.version ?? "0.0.0"),
+        fetchImpl: io.fetchImpl,
+    };
+    return {
+        config,
+        dataPlane: new HttpClient({ baseUrl: config.baseUrl, ...shared }),
+        accountPlane: new HttpClient({ baseUrl: config.backendUrl, ...shared }),
+    };
+}
+export function requireApiKey(config) {
+    if (!config.apiKey) {
+        throw new ApiError({
+            kind: "auth",
+            exitCode: ExitCode.Auth,
+            message: "no API key. Set MAFDET_API_KEY (there is deliberately no --api-key flag).",
+        });
+    }
+}
+/**
+ * Turn any failure into an exit code and a single stderr line. Nothing here
+ * prints a raw upstream message: ApiError redacted it at construction.
+ */
+export function reportError(error, io) {
+    if (error instanceof ApiError) {
+        const id = error.requestId ? ` (request ${error.requestId})` : "";
+        io.stderr(`mafdet: ${error.message}${id}\n`);
+        if (error.kind === "rate_limited" &&
+            error.retryAfterSeconds !== undefined) {
+            io.stderr(`mafdet: retry after ${error.retryAfterSeconds}s\n`);
+        }
+        return error.exitCode;
+    }
+    if (error instanceof ConfigError) {
+        io.stderr(`mafdet: ${error.message}\n`);
+        return ExitCode.Usage;
+    }
+    io.stderr(`mafdet: ${error.message}\n`);
+    return ExitCode.General;
+}

package/dist/commands/speech.d.ts

@@ -0,0 +1,7 @@
+import { ExitCode } from "../output/exit-codes.js";
+import { type CommandIo } from "./runtime.js";
+export interface SpeechIo extends CommandIo {
+    readStdin?: () => Promise<string>;
+}
+export declare function speechCommand(argv: readonly string[], io: SpeechIo): Promise<ExitCode>;
+//# sourceMappingURL=speech.d.ts.map

package/dist/commands/speech.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"speech.d.ts","sourceRoot":"","sources":["../../src/commands/speech.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAEnD,OAAO,EAIL,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AAStB,MAAM,WAAW,QAAS,SAAQ,SAAS;IACzC,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;CACnC;AAED,wBAAsB,aAAa,CACjC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,EAAE,QAAQ,GACX,OAAO,CAAC,QAAQ,CAAC,CAyEnB"}