@nyrra/prismantix-cli 0.0.1

package/README.md

@@ -0,0 +1,42 @@
+# @nyrra/prismantix-cli
+
+Public PrismantiX export API client.
+
+## Usage
+
+Run the guided export flow:
+
+```sh
+npx -y @nyrra/prismantix-cli
+```
+
+The guided flow reads `PRISMANTIX_API_KEY` when it is set. If it is missing, the CLI prompts for the key with masked input. The default API base is `https://api.prismantix.com`.
+
+## Non-Interactive Download
+
+Queue a full client export, poll until completion, write the manifest and CSV files locally, and print machine-readable JSON to stdout:
+
+```sh
+export PRISMANTIX_API_KEY="sk_..."
+npx -y @nyrra/prismantix-cli download --client LLY --yes --json
+```
+
+Download an existing export without queueing a new one:
+
+```sh
+export PRISMANTIX_API_KEY="sk_..."
+npx -y @nyrra/prismantix-cli download --export-id <export-id> --json
+```
+
+Useful options:
+
+```sh
+npx -y @nyrra/prismantix-cli download \
+  --api-base "https://api.prismantix.com" \
+  --client LLY \
+  --yes \
+  --output ./prismantix-exports \
+  --json
+```
+
+`--json` keeps stdout machine-readable. Progress and errors are written to stderr, and the API key is never printed.

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node --loader ts-node/esm --no-warnings=ExperimentalWarning "%~dp0\dev" %*

package/bin/dev.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env -S node --loader ts-node/esm --disable-warning=ExperimentalWarning
+
+import { execute } from "@oclif/core";
+
+const args = process.argv.slice(2);
+
+await execute({
+	args: args.length === 0 ? ["guided"] : args,
+	development: true,
+	dir: import.meta.url,
+});

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/bin/run.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+import { execute } from "@oclif/core";
+
+const args = process.argv.slice(2);
+
+await execute({
+	args: args.length === 0 ? ["guided"] : args,
+	dir: import.meta.url,
+});

package/dist/api.d.ts

@@ -0,0 +1,179 @@
+import { z } from "zod";
+declare const exportFileSchema: z.ZodObject<{
+    downloadUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    fileName: z.ZodString;
+    mimeType: z.ZodOptional<z.ZodString>;
+    rowCount: z.ZodOptional<z.ZodNumber>;
+    sha256: z.ZodOptional<z.ZodString>;
+    sizeBytes: z.ZodOptional<z.ZodNumber>;
+    tableName: z.ZodString;
+}, z.core.$strip>;
+declare const exportCreatedSchema: z.ZodObject<{
+    clientId: z.ZodString;
+    exportId: z.ZodString;
+    manifestUrl: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodLiteral<"queued">>;
+    statusUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const exportStatusSchema: z.ZodObject<{
+    clientId: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodOptional<z.ZodNumber>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+    exportId: z.ZodString;
+    failedAt: z.ZodOptional<z.ZodNumber>;
+    files: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        downloadUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        fileName: z.ZodString;
+        mimeType: z.ZodOptional<z.ZodString>;
+        rowCount: z.ZodOptional<z.ZodNumber>;
+        sha256: z.ZodOptional<z.ZodString>;
+        sizeBytes: z.ZodOptional<z.ZodNumber>;
+        tableName: z.ZodString;
+    }, z.core.$strip>>>;
+    manifestUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    startedAt: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+    }>;
+    totalFiles: z.ZodOptional<z.ZodNumber>;
+    totalRows: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const exportManifestSchema: z.ZodPipe<z.ZodObject<{
+    clientId: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodOptional<z.ZodNumber>;
+    exportId: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        downloadUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        fileName: z.ZodString;
+        mimeType: z.ZodOptional<z.ZodString>;
+        rowCount: z.ZodOptional<z.ZodNumber>;
+        sha256: z.ZodOptional<z.ZodString>;
+        sizeBytes: z.ZodOptional<z.ZodNumber>;
+        tableName: z.ZodString;
+        columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        storageKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    format: z.ZodOptional<z.ZodLiteral<"csv">>;
+    medium: z.ZodOptional<z.ZodLiteral<"csv_bundle">>;
+    mode: z.ZodOptional<z.ZodLiteral<"current_client_snapshot">>;
+    schemaVersion: z.ZodOptional<z.ZodString>;
+    totalRows: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodTransform<{
+    totalRows: number;
+    clientId: string;
+    exportId: string;
+    files: {
+        fileName: string;
+        tableName: string;
+        downloadUrl?: string | null | undefined;
+        mimeType?: string | undefined;
+        rowCount?: number | undefined;
+        sha256?: string | undefined;
+        sizeBytes?: number | undefined;
+        columns?: string[] | undefined;
+        storageKey?: string | undefined;
+    }[];
+    completedAt?: number | undefined;
+    createdAt?: number | undefined;
+    format?: "csv" | undefined;
+    medium?: "csv_bundle" | undefined;
+    mode?: "current_client_snapshot" | undefined;
+    schemaVersion?: string | undefined;
+}, {
+    clientId: string;
+    exportId: string;
+    files: {
+        fileName: string;
+        tableName: string;
+        downloadUrl?: string | null | undefined;
+        mimeType?: string | undefined;
+        rowCount?: number | undefined;
+        sha256?: string | undefined;
+        sizeBytes?: number | undefined;
+        columns?: string[] | undefined;
+        storageKey?: string | undefined;
+    }[];
+    completedAt?: number | undefined;
+    createdAt?: number | undefined;
+    format?: "csv" | undefined;
+    medium?: "csv_bundle" | undefined;
+    mode?: "current_client_snapshot" | undefined;
+    schemaVersion?: string | undefined;
+    totalRows?: number | undefined;
+}>>;
+export type ExportCreated = z.infer<typeof exportCreatedSchema>;
+export type ExportFile = z.infer<typeof exportFileSchema>;
+export type ExportManifest = z.output<typeof exportManifestSchema>;
+export type ExportManifestFile = ExportManifest["files"][number];
+export type ExportStatus = z.infer<typeof exportStatusSchema>;
+export interface PrismantixApiClientOptions {
+    readonly apiBaseUrl?: string;
+    readonly apiKey: string;
+    readonly fetchImpl?: typeof fetch;
+}
+export declare class PrismantixApiClient {
+    private readonly apiBaseUrl;
+    private readonly apiKey;
+    private readonly fetchImpl;
+    constructor(options: PrismantixApiClientOptions);
+    createExport(clientId: string): Promise<{
+        clientId: string;
+        exportId: string;
+        manifestUrl?: string | undefined;
+        status?: "queued" | undefined;
+        statusUrl?: string | undefined;
+    }>;
+    getExportStatus(exportId: string): Promise<{
+        clientId: string;
+        exportId: string;
+        files: {
+            fileName: string;
+            tableName: string;
+            downloadUrl?: string | null | undefined;
+            mimeType?: string | undefined;
+            rowCount?: number | undefined;
+            sha256?: string | undefined;
+            sizeBytes?: number | undefined;
+        }[];
+        status: "queued" | "running" | "completed" | "failed";
+        completedAt?: number | undefined;
+        createdAt?: number | undefined;
+        errorMessage?: string | undefined;
+        failedAt?: number | undefined;
+        manifestUrl?: string | null | undefined;
+        startedAt?: number | undefined;
+        totalFiles?: number | undefined;
+        totalRows?: number | undefined;
+    }>;
+    getManifest(exportId: string): Promise<{
+        totalRows: number;
+        clientId: string;
+        exportId: string;
+        files: {
+            fileName: string;
+            tableName: string;
+            downloadUrl?: string | null | undefined;
+            mimeType?: string | undefined;
+            rowCount?: number | undefined;
+            sha256?: string | undefined;
+            sizeBytes?: number | undefined;
+            columns?: string[] | undefined;
+            storageKey?: string | undefined;
+        }[];
+        completedAt?: number | undefined;
+        createdAt?: number | undefined;
+        format?: "csv" | undefined;
+        medium?: "csv_bundle" | undefined;
+        mode?: "current_client_snapshot" | undefined;
+        schemaVersion?: string | undefined;
+    }>;
+    getFile(exportId: string, tableName: string): Promise<Response>;
+    private request;
+}
+export {};
+//# sourceMappingURL=api.d.ts.map

package/dist/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,QAAA,MAAM,gBAAgB;;;;;;;;iBAQpB,CAAC;AAEH,QAAA,MAAM,mBAAmB;;;;;;iBAMvB,CAAC;AAEH,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAatB,CAAC;AAOH,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkBtB,CAAC;AAEL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACnE,MAAM,MAAM,kBAAkB,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AACjE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,MAAM,WAAW,0BAA0B;IAC1C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CAClC;AAED,qBAAa,mBAAmB;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAe;gBAE7B,OAAO,EAAE,0BAA0B;IAQzC,YAAY,CAAC,QAAQ,EAAE,MAAM;;;;;;;IAS7B,eAAe,CAAC,QAAQ,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;IAQhC,WAAW,CAAC,QAAQ,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;IAQ5B,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;YAUnC,OAAO;CAuBrB"}

package/dist/api.js

@@ -0,0 +1,120 @@
+import { z } from "zod";
+import { DEFAULT_API_BASE_URL } from "./constants.js";
+import { CliUserError } from "./errors.js";
+const exportFileSchema = z.object({
+    downloadUrl: z.string().url().nullable().optional(),
+    fileName: z.string(),
+    mimeType: z.string().optional(),
+    rowCount: z.number().optional(),
+    sha256: z.string().optional(),
+    sizeBytes: z.number().optional(),
+    tableName: z.string(),
+});
+const exportCreatedSchema = z.object({
+    clientId: z.string(),
+    exportId: z.string(),
+    manifestUrl: z.string().url().optional(),
+    status: z.literal("queued").optional(),
+    statusUrl: z.string().url().optional(),
+});
+const exportStatusSchema = z.object({
+    clientId: z.string(),
+    completedAt: z.number().optional(),
+    createdAt: z.number().optional(),
+    errorMessage: z.string().optional(),
+    exportId: z.string(),
+    failedAt: z.number().optional(),
+    files: z.array(exportFileSchema).default([]),
+    manifestUrl: z.string().url().nullable().optional(),
+    startedAt: z.number().optional(),
+    status: z.enum(["queued", "running", "completed", "failed"]),
+    totalFiles: z.number().optional(),
+    totalRows: z.number().optional(),
+});
+const manifestFileSchema = exportFileSchema.extend({
+    columns: z.array(z.string()).optional(),
+    storageKey: z.string().optional(),
+});
+const exportManifestSchema = z
+    .object({
+    clientId: z.string(),
+    completedAt: z.number().optional(),
+    createdAt: z.number().optional(),
+    exportId: z.string(),
+    files: z.array(manifestFileSchema),
+    format: z.literal("csv").optional(),
+    medium: z.literal("csv_bundle").optional(),
+    mode: z.literal("current_client_snapshot").optional(),
+    schemaVersion: z.string().optional(),
+    totalRows: z.number().optional(),
+})
+    .transform((manifest) => ({
+    ...manifest,
+    totalRows: manifest.totalRows ??
+        manifest.files.reduce((sum, file) => sum + (file.rowCount ?? 0), 0),
+}));
+export class PrismantixApiClient {
+    apiBaseUrl;
+    apiKey;
+    fetchImpl;
+    constructor(options) {
+        this.apiBaseUrl = trimTrailingSlash(options.apiBaseUrl ?? DEFAULT_API_BASE_URL);
+        this.apiKey = options.apiKey;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+    }
+    async createExport(clientId) {
+        const response = await this.request(`/v1/clients/${encodeURIComponent(clientId)}/exports`, { method: "POST" });
+        return exportCreatedSchema.parse(await response.json());
+    }
+    async getExportStatus(exportId) {
+        const response = await this.request(`/v1/exports/${encodeURIComponent(exportId)}`);
+        return exportStatusSchema.parse(await response.json());
+    }
+    async getManifest(exportId) {
+        const response = await this.request(`/v1/exports/${encodeURIComponent(exportId)}/manifest`);
+        return exportManifestSchema.parse(await response.json());
+    }
+    async getFile(exportId, tableName) {
+        return this.request(`/v1/exports/${encodeURIComponent(exportId)}/files/${encodeURIComponent(tableName)}`, {}, { accept: "*/*" });
+    }
+    async request(path, init = {}, options = {}) {
+        const headers = new Headers(init.headers);
+        headers.set("Authorization", `Bearer ${this.apiKey}`);
+        headers.set("Accept", options.accept ?? "application/json");
+        const response = await this.fetchImpl(`${this.apiBaseUrl}${path}`, {
+            ...init,
+            headers,
+        });
+        if (response.ok) {
+            return response;
+        }
+        throw new CliUserError(codeForStatus(response.status), await readApiError(response));
+    }
+}
+async function readApiError(response) {
+    try {
+        const payload = (await response.json());
+        return (payload.message ?? payload.error ?? `API returned ${response.status}.`);
+    }
+    catch {
+        return `API returned ${response.status}.`;
+    }
+}
+function codeForStatus(status) {
+    if (status === 401) {
+        return "unauthorized";
+    }
+    if (status === 403) {
+        return "forbidden";
+    }
+    if (status === 404) {
+        return "not_found";
+    }
+    if (status === 409) {
+        return "export_not_ready";
+    }
+    return "api_error";
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}

package/dist/commands/download.d.ts

@@ -0,0 +1,22 @@
+import { Command } from "@oclif/core";
+export default class Download extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        "api-base": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        client: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "export-id": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "poll-interval": import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        table: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        tables: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        timeout: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private fail;
+    private printProgress;
+    private printSummary;
+}
+//# sourceMappingURL=download.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"download.d.ts","sourceRoot":"","sources":["../../src/commands/download.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAS,MAAM,aAAa,CAAC;AAa7C,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,OAAO;IAC5C,OAAgB,WAAW,SACqD;IAEhF,OAAgB,QAAQ,WAGtB;IAEF,OAAgB,KAAK;;;;;;;;;;;MAwCnB;IAEW,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;IAmDjC,OAAO,CAAC,IAAI;IAeZ,OAAO,CAAC,aAAa;IA0BrB,OAAO,CAAC,YAAY;CAYpB"}

package/dist/commands/download.js

@@ -0,0 +1,136 @@
+import { Command, Flags } from "@oclif/core";
+import { DEFAULT_API_BASE_URL, DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS, } from "../constants.js";
+import { CliUserError, toCliUserError } from "../errors.js";
+import { runDownloadWorkflow, } from "../workflow.js";
+export default class Download extends Command {
+    static description = "Create or download a PrismantiX client export without opening the guided UI.";
+    static examples = [
+        "<%= config.bin %> download --client LLY --yes --json",
+        "<%= config.bin %> download --export-id export_123 --json",
+    ];
+    static flags = {
+        "api-base": Flags.string({
+            description: "PrismantiX API base URL.",
+            env: "PRISMANTIX_API_BASE",
+        }),
+        client: Flags.string({
+            description: "Client ID to export when queueing a new export.",
+        }),
+        "export-id": Flags.string({
+            description: "Existing export ID to download.",
+            env: "PRISMANTIX_EXPORT_ID",
+        }),
+        json: Flags.boolean({
+            description: "Print machine-readable JSON to stdout.",
+        }),
+        output: Flags.string({
+            description: "Output directory.",
+            env: "PRISMANTIX_OUTPUT_DIR",
+        }),
+        "poll-interval": Flags.integer({
+            default: DEFAULT_POLL_INTERVAL_MS,
+            description: "Polling interval in milliseconds.",
+            env: "PRISMANTIX_POLL_INTERVAL_MS",
+        }),
+        table: Flags.string({
+            description: "Table to download; repeat for multiple tables.",
+            multiple: true,
+        }),
+        tables: Flags.string({
+            description: "Comma-separated list of tables to download.",
+        }),
+        timeout: Flags.integer({
+            default: DEFAULT_TIMEOUT_MS,
+            description: "Polling timeout in milliseconds.",
+            env: "PRISMANTIX_TIMEOUT_MS",
+        }),
+        yes: Flags.boolean({
+            char: "y",
+            description: "Confirm queueing a new export.",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Download);
+        try {
+            validatePositiveInteger(flags["poll-interval"], "--poll-interval");
+            validatePositiveInteger(flags.timeout, "--timeout");
+            const clientId = flags.client?.trim();
+            const exportId = flags["export-id"]?.trim();
+            if (!exportId && !clientId) {
+                throw new CliUserError("missing_input", "Pass --client to create an export or --export-id to download one.");
+            }
+            if (!exportId && !flags.yes) {
+                throw new CliUserError("missing_consent", "Pass --yes to confirm queueing a new export.");
+            }
+            const result = await runDownloadWorkflow({
+                apiBaseUrl: flags["api-base"] ?? DEFAULT_API_BASE_URL,
+                apiKey: process.env.PRISMANTIX_API_KEY,
+                clientId,
+                exportId,
+                outputDir: flags.output,
+                pollIntervalMs: flags["poll-interval"],
+                tables: collectTables(flags.table, flags.tables),
+                timeoutMs: flags.timeout,
+            }, {
+                onEvent: (event) => this.printProgress(event),
+            });
+            if (flags.json) {
+                this.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            this.printSummary(result);
+        }
+        catch (error) {
+            this.fail(toCliUserError(error), flags.json);
+        }
+    }
+    fail(error, json) {
+        if (json) {
+            this.logToStderr(JSON.stringify({
+                code: error.code,
+                error: error.message,
+                ok: false,
+            }));
+            this.exit(error.exitCode);
+        }
+        this.error(error.message, { code: error.code, exit: error.exitCode });
+    }
+    printProgress(event) {
+        switch (event.type) {
+            case "created":
+                this.logToStderr(`Queued export ${event.exportId} for ${event.clientId}.`);
+                break;
+            case "poll":
+                this.logToStderr(`Export ${event.status.exportId}: ${event.status.status}.`);
+                break;
+            case "manifest":
+                this.logToStderr(`Manifest ready: ${event.manifest.files.length} file(s), ${event.manifest.totalRows} row(s).`);
+                break;
+            case "download-start":
+                this.logToStderr(`Downloading ${event.file.tableName}...`);
+                break;
+            case "download-complete":
+                this.logToStderr(`Downloaded ${event.file.tableName}.`);
+                break;
+        }
+    }
+    printSummary(result) {
+        this.log(`Downloaded PrismantiX export ${result.exportId}`);
+        this.log(`Output: ${result.outputDir}`);
+        this.log(`Manifest: ${result.manifestPath}`);
+        this.log(`Files: ${result.files.length}`);
+        for (const file of result.files) {
+            const rowLabel = file.rowCount === undefined ? "" : ` (${file.rowCount} row(s))`;
+            this.log(`- ${file.tableName}${rowLabel}: ${file.path}`);
+        }
+    }
+}
+function collectTables(tableFlags, tablesFlag) {
+    return [...(tableFlags ?? []), ...(tablesFlag ? [tablesFlag] : [])];
+}
+function validatePositiveInteger(value, flagName) {
+    if (value === undefined || (Number.isInteger(value) && value > 0)) {
+        return;
+    }
+    throw new CliUserError("invalid_argument", `${flagName} must be a positive integer.`);
+}

package/dist/commands/guided.d.ts

@@ -0,0 +1,7 @@
+import { Command } from "@oclif/core";
+export default class Guided extends Command {
+    static description: string;
+    static hidden: boolean;
+    run(): Promise<void>;
+}
+//# sourceMappingURL=guided.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"guided.d.ts","sourceRoot":"","sources":["../../src/commands/guided.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAGtC,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,OAAO;IAC1C,OAAgB,WAAW,SACuB;IAClD,OAAgB,MAAM,UAAQ;IAEjB,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAUjC"}

package/dist/commands/guided.js

@@ -0,0 +1,15 @@
+import { Command } from "@oclif/core";
+import { renderGuidedFlow } from "../ui/guided-flow.js";
+export default class Guided extends Command {
+    static description = "Launch the interactive PrismantiX export flow.";
+    static hidden = true;
+    async run() {
+        const result = await renderGuidedFlow({
+            cwd: process.cwd(),
+            env: process.env,
+        });
+        if (!result.ok) {
+            this.exit(1);
+        }
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const DEFAULT_API_BASE_URL = "https://api.prismantix.com";
+export declare const DEFAULT_OUTPUT_ROOT = "prismantix-exports";
+export declare const DEFAULT_POLL_INTERVAL_MS = 1000;
+export declare const DEFAULT_TIMEOUT_MS = 120000;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,+BAA+B,CAAC;AACjE,eAAO,MAAM,mBAAmB,uBAAuB,CAAC;AACxD,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAC7C,eAAO,MAAM,kBAAkB,SAAU,CAAC"}

package/dist/constants.js

@@ -0,0 +1,4 @@
+export const DEFAULT_API_BASE_URL = "https://api.prismantix.com";
+export const DEFAULT_OUTPUT_ROOT = "prismantix-exports";
+export const DEFAULT_POLL_INTERVAL_MS = 1000;
+export const DEFAULT_TIMEOUT_MS = 120_000;

package/dist/errors.d.ts

@@ -0,0 +1,7 @@
+export declare class CliUserError extends Error {
+    readonly code: string;
+    readonly exitCode: number;
+    constructor(code: string, message: string, exitCode?: number);
+}
+export declare function toCliUserError(error: unknown): CliUserError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,YAAa,SAAQ,KAAK;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,SAAI;CAMvD;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,gBAU5C"}

package/dist/errors.js

@@ -0,0 +1,19 @@
+export class CliUserError extends Error {
+    code;
+    exitCode;
+    constructor(code, message, exitCode = 1) {
+        super(message);
+        this.name = "CliUserError";
+        this.code = code;
+        this.exitCode = exitCode;
+    }
+}
+export function toCliUserError(error) {
+    if (error instanceof CliUserError) {
+        return error;
+    }
+    if (error instanceof Error) {
+        return new CliUserError("unexpected_error", error.message);
+    }
+    return new CliUserError("unexpected_error", String(error));
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { run } from "@oclif/core";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from "@oclif/core";

package/dist/io.d.ts

@@ -0,0 +1,2 @@
+export declare function writeResponseBodyToFile(response: Response, path: string): Promise<number>;
+//# sourceMappingURL=io.d.ts.map

package/dist/io.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"io.d.ts","sourceRoot":"","sources":["../src/io.ts"],"names":[],"mappings":"AAKA,wBAAsB,uBAAuB,CAC5C,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,mBAuBZ"}

package/dist/io.js

@@ -0,0 +1,20 @@
+import { createWriteStream } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+export async function writeResponseBodyToFile(response, path) {
+    if (!response.body) {
+        const body = Buffer.from(await response.arrayBuffer());
+        await writeFile(path, body);
+        return body.byteLength;
+    }
+    let sizeBytes = 0;
+    const byteCounter = new Transform({
+        transform(chunk, _encoding, callback) {
+            sizeBytes += chunk.byteLength;
+            callback(null, chunk);
+        },
+    });
+    await pipeline(Readable.fromWeb(response.body), byteCounter, createWriteStream(path));
+    return sizeBytes;
+}

package/dist/ui/guided-flow.d.ts

@@ -0,0 +1,20 @@
+import { type DownloadResult, type ManifestSummary } from "../workflow.js";
+export interface GuidedFlowResult {
+    readonly error?: string;
+    readonly ok: boolean;
+    readonly result?: DownloadResult;
+}
+export interface GuidedFlowProps {
+    readonly cwd?: string;
+    readonly env?: Record<string, string | undefined>;
+    readonly fetchImpl?: typeof fetch;
+    readonly now?: () => number;
+    readonly onComplete?: (result: GuidedFlowResult) => void;
+    readonly sleep?: (ms: number) => Promise<void>;
+}
+export declare function renderGuidedFlow(props?: GuidedFlowProps): Promise<GuidedFlowResult>;
+export declare function GuidedFlow({ cwd, env, fetchImpl, now, onComplete, sleep, }: GuidedFlowProps): import("react/jsx-runtime").JSX.Element;
+export declare function ManifestSummaryView({ summary, }: {
+    readonly summary: ManifestSummary;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=guided-flow.d.ts.map

package/dist/ui/guided-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guided-flow.d.ts","sourceRoot":"","sources":["../../src/ui/guided-flow.tsx"],"names":[],"mappings":"AAgBA,OAAO,EACN,KAAK,cAAc,EACnB,KAAK,eAAe,EAIpB,MAAM,gBAAgB,CAAC;AAExB,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAClD,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IAClC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/C;AAID,wBAAsB,gBAAgB,CAAC,KAAK,GAAE,eAAoB,6BAcjE;AAED,wBAAgB,UAAU,CAAC,EAC1B,GAAG,EACH,GAAiB,EACjB,SAAS,EACT,GAAG,EACH,UAAU,EACV,KAAK,GACL,EAAE,eAAe,2CAyLjB;AAED,wBAAgB,mBAAmB,CAAC,EACnC,OAAO,GACP,EAAE;IACF,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;CAClC,2CAiBA"}

package/dist/ui/guided-flow.js

@@ -0,0 +1,156 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Alert, PasswordInput, Spinner, StatusMessage, TextInput, UnorderedList, } from "@inkjs/ui";
+import { Box, render, Text, useApp } from "ink";
+import { useEffect, useMemo, useState } from "react";
+import { DEFAULT_API_BASE_URL, DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS, } from "../constants.js";
+import { toCliUserError } from "../errors.js";
+import { runDownloadWorkflow, summarizeManifest, } from "../workflow.js";
+export async function renderGuidedFlow(props = {}) {
+    let result = { ok: false };
+    const instance = render(_jsx(GuidedFlow, { ...props, onComplete: (nextResult) => {
+            result = nextResult;
+            props.onComplete?.(nextResult);
+        } }));
+    await instance.waitUntilExit();
+    return result;
+}
+export function GuidedFlow({ cwd, env = process.env, fetchImpl, now, onComplete, sleep, }) {
+    const { exit } = useApp();
+    const envApiKey = env.PRISMANTIX_API_KEY?.trim();
+    const envClientId = env.PRISMANTIX_CLIENT_ID?.trim().toUpperCase();
+    const [apiKey, setApiKey] = useState(envApiKey ?? "");
+    const [clientId, setClientId] = useState(envClientId ?? "");
+    const [step, setStep] = useState(envApiKey ? "client" : "api-key");
+    const [events, setEvents] = useState([]);
+    const [inputError, setInputError] = useState();
+    const [manifestSummary, setManifestSummary] = useState();
+    const [result, setResult] = useState();
+    const [fatalError, setFatalError] = useState();
+    const apiBaseUrl = env.PRISMANTIX_API_BASE ?? DEFAULT_API_BASE_URL;
+    const outputDir = env.PRISMANTIX_OUTPUT_DIR;
+    const pollIntervalMs = readPositiveInteger(env.PRISMANTIX_POLL_INTERVAL_MS, DEFAULT_POLL_INTERVAL_MS);
+    const timeoutMs = readPositiveInteger(env.PRISMANTIX_TIMEOUT_MS, DEFAULT_TIMEOUT_MS);
+    useEffect(() => {
+        if (step !== "running") {
+            return;
+        }
+        let cancelled = false;
+        runDownloadWorkflow({
+            apiBaseUrl,
+            apiKey,
+            clientId,
+            outputDir,
+            pollIntervalMs,
+            timeoutMs,
+        }, {
+            cwd,
+            fetchImpl,
+            now,
+            onEvent: (event) => {
+                if (cancelled) {
+                    return;
+                }
+                if (event.type === "manifest") {
+                    setManifestSummary(summarizeManifest(event.manifest));
+                }
+                setEvents((previousEvents) => [
+                    ...previousEvents.slice(-7),
+                    formatEvent(event),
+                ]);
+            },
+            sleep,
+        })
+            .then((downloadResult) => {
+            if (cancelled) {
+                return;
+            }
+            setResult(downloadResult);
+            setStep("done");
+            onComplete?.({ ok: true, result: downloadResult });
+            setTimeout(() => exit(), 0);
+        })
+            .catch((error) => {
+            if (cancelled) {
+                return;
+            }
+            const cliError = toCliUserError(error);
+            setFatalError(cliError.message);
+            setStep("error");
+            onComplete?.({ error: cliError.message, ok: false });
+            setTimeout(() => exit(), 0);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [
+        apiBaseUrl,
+        apiKey,
+        clientId,
+        cwd,
+        exit,
+        fetchImpl,
+        now,
+        onComplete,
+        outputDir,
+        pollIntervalMs,
+        sleep,
+        step,
+        timeoutMs,
+    ]);
+    const header = useMemo(() => (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { bold: true, children: "PrismantiX Export" }), _jsxs(Text, { color: "gray", children: ["API: ", apiBaseUrl] })] })), [apiBaseUrl]);
+    if (step === "api-key") {
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [header, _jsx(Text, { children: "Enter PRISMANTIX_API_KEY" }), _jsx(PasswordInput, { placeholder: "API key", onSubmit: (value) => {
+                        const nextApiKey = value.trim();
+                        if (!nextApiKey) {
+                            setInputError("API key is required.");
+                            return;
+                        }
+                        setInputError(undefined);
+                        setApiKey(nextApiKey);
+                        setStep("client");
+                    } }), inputError ? (_jsx(StatusMessage, { variant: "error", children: inputError })) : null] }));
+    }
+    if (step === "client") {
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [header, _jsxs(StatusMessage, { variant: "info", children: ["API key loaded from ", envApiKey ? "environment" : "prompt", "."] }), _jsx(Text, { children: "Enter client ID" }), _jsx(TextInput, { placeholder: clientId ? `Client ID (${clientId})` : "Client ID", onSubmit: (value) => {
+                        const nextClientId = (value.trim() || clientId).toUpperCase();
+                        if (!nextClientId) {
+                            setInputError("Client ID is required.");
+                            return;
+                        }
+                        setInputError(undefined);
+                        setClientId(nextClientId);
+                        setStep("running");
+                    } }), inputError ? (_jsx(StatusMessage, { variant: "error", children: inputError })) : null] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [header, step === "running" ? _jsx(Spinner, { label: "Creating export" }) : null, manifestSummary ? (_jsx(ManifestSummaryView, { summary: manifestSummary })) : null, _jsx(EventLog, { events: events }), step === "done" && result ? (_jsxs(StatusMessage, { variant: "success", children: ["Downloaded ", result.files.length, " file(s) to ", result.outputDir] })) : null, step === "error" && fatalError ? (_jsx(Alert, { variant: "error", children: fatalError })) : null] }));
+}
+export function ManifestSummaryView({ summary, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Manifest: ", summary.fileCount, " file(s), ", summary.totalRows, " total row(s)"] }), _jsx(UnorderedList, { children: summary.tables.map((table) => (_jsx(UnorderedList.Item, { children: _jsxs(Text, { children: [table.tableName, ": ", table.rowCount ?? 0, " row(s)"] }) }, table.tableName))) })] }));
+}
+function EventLog({ events }) {
+    if (events.length === 0) {
+        return null;
+    }
+    return (_jsx(Box, { flexDirection: "column", children: events.map((event) => (_jsx(Text, { color: "gray", children: event }, event))) }));
+}
+function formatEvent(event) {
+    switch (event.type) {
+        case "created":
+            return `Queued export ${event.exportId} for ${event.clientId}.`;
+        case "poll":
+            return `Export ${event.status.exportId}: ${event.status.status}.`;
+        case "manifest":
+            return `Manifest fetched for ${event.manifest.exportId}.`;
+        case "download-start":
+            return `Downloading ${event.file.tableName}.`;
+        case "download-complete":
+            return `Downloaded ${event.file.tableName}.`;
+    }
+}
+function readPositiveInteger(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}

package/dist/workflow.d.ts

@@ -0,0 +1,64 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { type ExportManifest, type ExportManifestFile, type ExportStatus } from "./api.js";
+export interface DownloadWorkflowOptions {
+    readonly apiBaseUrl?: string;
+    readonly apiKey?: string;
+    readonly clientId?: string;
+    readonly exportId?: string;
+    readonly outputDir?: string;
+    readonly pollIntervalMs?: number;
+    readonly tables?: readonly string[];
+    readonly timeoutMs?: number;
+}
+export interface DownloadWorkflowRuntime {
+    readonly cwd?: string;
+    readonly fetchImpl?: typeof fetch;
+    readonly mkdir?: typeof mkdir;
+    readonly now?: () => number;
+    readonly onEvent?: (event: WorkflowEvent) => void;
+    readonly sleep?: (ms: number) => Promise<void>;
+    readonly writeFile?: typeof writeFile;
+    readonly writeResponseBody?: (response: Response, path: string) => Promise<number>;
+}
+export type WorkflowEvent = {
+    readonly clientId: string;
+    readonly exportId: string;
+    readonly type: "created";
+} | {
+    readonly status: ExportStatus;
+    readonly type: "poll";
+} | {
+    readonly manifest: ExportManifest;
+    readonly type: "manifest";
+} | {
+    readonly file: ExportManifestFile;
+    readonly type: "download-start";
+} | {
+    readonly file: DownloadedFile;
+    readonly type: "download-complete";
+};
+export interface DownloadedFile {
+    readonly path: string;
+    readonly rowCount?: number;
+    readonly sha256?: string;
+    readonly sizeBytes: number;
+    readonly tableName: string;
+}
+export interface DownloadResult {
+    readonly clientId: string;
+    readonly exportId: string;
+    readonly files: readonly DownloadedFile[];
+    readonly manifestPath: string;
+    readonly outputDir: string;
+}
+export interface ManifestSummary {
+    readonly fileCount: number;
+    readonly tables: readonly {
+        readonly rowCount?: number;
+        readonly tableName: string;
+    }[];
+    readonly totalRows: number;
+}
+export declare function runDownloadWorkflow(options: DownloadWorkflowOptions, runtime?: DownloadWorkflowRuntime): Promise<DownloadResult>;
+export declare function summarizeManifest(manifest: ExportManifest): ManifestSummary;
+//# sourceMappingURL=workflow.d.ts.map

package/dist/workflow.d.ts.map

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

package/dist/workflow.js

@@ -0,0 +1,130 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { PrismantixApiClient, } from "./api.js";
+import { DEFAULT_API_BASE_URL, DEFAULT_OUTPUT_ROOT, DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS, } from "./constants.js";
+import { CliUserError } from "./errors.js";
+import { writeResponseBodyToFile } from "./io.js";
+export async function runDownloadWorkflow(options, runtime = {}) {
+    const apiKey = options.apiKey?.trim();
+    if (!apiKey) {
+        throw new CliUserError("missing_api_key", "Set PRISMANTIX_API_KEY before running the CLI.");
+    }
+    const sleep = runtime.sleep ??
+        ((ms) => new Promise((resolveSleep) => setTimeout(resolveSleep, ms)));
+    const now = runtime.now ?? (() => Date.now());
+    const mkdirImpl = runtime.mkdir ?? mkdir;
+    const writeFileImpl = runtime.writeFile ?? writeFile;
+    const writeResponseBody = runtime.writeResponseBody ?? writeResponseBodyToFile;
+    const emit = runtime.onEvent ?? (() => undefined);
+    const api = new PrismantixApiClient({
+        apiBaseUrl: options.apiBaseUrl ?? DEFAULT_API_BASE_URL,
+        apiKey,
+        fetchImpl: runtime.fetchImpl,
+    });
+    let clientId = normalizeClientId(options.clientId);
+    let exportId = options.exportId?.trim();
+    if (!exportId) {
+        if (!clientId) {
+            throw new CliUserError("missing_client", "Pass --client when creating a new export.");
+        }
+        const created = await api.createExport(clientId);
+        clientId = created.clientId;
+        exportId = created.exportId;
+        emit({ clientId, exportId, type: "created" });
+    }
+    const status = await waitForCompletedExport({
+        api,
+        exportId,
+        now,
+        onPoll: (polledStatus) => emit({ status: polledStatus, type: "poll" }),
+        pollIntervalMs: options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
+        sleep,
+        timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    });
+    clientId = status.clientId;
+    const manifest = await api.getManifest(exportId);
+    emit({ manifest, type: "manifest" });
+    const outputDir = resolveOutputDir({
+        clientId,
+        cwd: runtime.cwd ?? process.cwd(),
+        exportId,
+        outputDir: options.outputDir,
+    });
+    await mkdirImpl(outputDir, { recursive: true });
+    const manifestPath = join(outputDir, "manifest.json");
+    await writeFileImpl(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, {
+        encoding: "utf8",
+    });
+    const selectedFiles = selectManifestFiles(manifest.files, options.tables ?? []);
+    if (selectedFiles.length === 0) {
+        throw new CliUserError("no_matching_files", `No export files matched: ${(options.tables ?? []).join(", ")}`);
+    }
+    const files = [];
+    for (const file of selectedFiles) {
+        emit({ file, type: "download-start" });
+        const destinationPath = join(outputDir, basename(file.fileName));
+        const response = await api.getFile(exportId, file.tableName);
+        const writtenSizeBytes = await writeResponseBody(response, destinationPath);
+        const downloadedFile = {
+            path: destinationPath,
+            rowCount: file.rowCount,
+            sha256: file.sha256,
+            sizeBytes: file.sizeBytes ?? writtenSizeBytes,
+            tableName: file.tableName,
+        };
+        files.push(downloadedFile);
+        emit({ file: downloadedFile, type: "download-complete" });
+    }
+    return {
+        clientId,
+        exportId,
+        files,
+        manifestPath,
+        outputDir,
+    };
+}
+export function summarizeManifest(manifest) {
+    return {
+        fileCount: manifest.files.length,
+        tables: manifest.files.map((file) => ({
+            rowCount: file.rowCount,
+            tableName: file.tableName,
+        })),
+        totalRows: manifest.totalRows,
+    };
+}
+function normalizeClientId(value) {
+    const normalized = value?.trim();
+    return normalized ? normalized.toUpperCase() : undefined;
+}
+async function waitForCompletedExport(args) {
+    const startedAt = args.now();
+    for (;;) {
+        const status = await args.api.getExportStatus(args.exportId);
+        args.onPoll(status);
+        if (status.status === "completed") {
+            return status;
+        }
+        if (status.status === "failed") {
+            throw new CliUserError("export_failed", status.errorMessage ?? `Export ${args.exportId} failed.`);
+        }
+        if (args.now() - startedAt >= args.timeoutMs) {
+            throw new CliUserError("timeout", `Timed out waiting for export ${args.exportId}.`);
+        }
+        await args.sleep(args.pollIntervalMs);
+    }
+}
+function resolveOutputDir(args) {
+    return resolve(args.cwd, args.outputDir ?? join(DEFAULT_OUTPUT_ROOT, args.clientId, args.exportId));
+}
+function selectManifestFiles(files, tables) {
+    const normalizedTables = tables
+        .flatMap((table) => table.split(","))
+        .map((table) => table.trim())
+        .filter(Boolean);
+    if (normalizedTables.length === 0 || normalizedTables.includes("all")) {
+        return [...files];
+    }
+    const allowedTables = new Set(normalizedTables);
+    return files.filter((file) => allowedTables.has(file.tableName));
+}

package/oclif.manifest.json

@@ -0,0 +1,127 @@
+{
+  "commands": {
+    "download": {
+      "aliases": [],
+      "args": {},
+      "description": "Create or download a PrismantiX client export without opening the guided UI.",
+      "examples": [
+        "<%= config.bin %> download --client LLY --yes --json",
+        "<%= config.bin %> download --export-id export_123 --json"
+      ],
+      "flags": {
+        "api-base": {
+          "description": "PrismantiX API base URL.",
+          "env": "PRISMANTIX_API_BASE",
+          "name": "api-base",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "client": {
+          "description": "Client ID to export when queueing a new export.",
+          "name": "client",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "export-id": {
+          "description": "Existing export ID to download.",
+          "env": "PRISMANTIX_EXPORT_ID",
+          "name": "export-id",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "json": {
+          "description": "Print machine-readable JSON to stdout.",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "output": {
+          "description": "Output directory.",
+          "env": "PRISMANTIX_OUTPUT_DIR",
+          "name": "output",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "poll-interval": {
+          "description": "Polling interval in milliseconds.",
+          "env": "PRISMANTIX_POLL_INTERVAL_MS",
+          "name": "poll-interval",
+          "default": 1000,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "table": {
+          "description": "Table to download; repeat for multiple tables.",
+          "name": "table",
+          "hasDynamicHelp": false,
+          "multiple": true,
+          "type": "option"
+        },
+        "tables": {
+          "description": "Comma-separated list of tables to download.",
+          "name": "tables",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "timeout": {
+          "description": "Polling timeout in milliseconds.",
+          "env": "PRISMANTIX_TIMEOUT_MS",
+          "name": "timeout",
+          "default": 120000,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "yes": {
+          "char": "y",
+          "description": "Confirm queueing a new export.",
+          "name": "yes",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "download",
+      "pluginAlias": "@nyrra/prismantix-cli",
+      "pluginName": "@nyrra/prismantix-cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "download.js"
+      ]
+    },
+    "guided": {
+      "aliases": [],
+      "args": {},
+      "description": "Launch the interactive PrismantiX export flow.",
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hidden": true,
+      "hiddenAliases": [],
+      "id": "guided",
+      "pluginAlias": "@nyrra/prismantix-cli",
+      "pluginName": "@nyrra/prismantix-cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "guided.js"
+      ]
+    }
+  },
+  "version": "0.0.1"
+}

package/package.json

@@ -0,0 +1,76 @@
+{
+	"name": "@nyrra/prismantix-cli",
+	"description": "PrismantiX API client CLI.",
+	"version": "0.0.1",
+	"author": "NYRRA Inc.",
+	"bin": {
+		"prismantix-cli": "bin/run.js"
+	},
+	"bugs": {
+		"url": "https://github.com/nyrra-labs/prismantix/issues"
+	},
+	"dependencies": {
+		"@inkjs/ui": "^2.0.0",
+		"@oclif/core": "^4",
+		"@oclif/plugin-help": "^6",
+		"ink": "^7.0.2",
+		"react": "^19.2.0",
+		"react-devtools-core": "^6.1.2",
+		"zod": "^4.2.1"
+	},
+	"devDependencies": {
+		"@oclif/test": "^4",
+		"@types/node": "^25",
+		"ink-testing-library": "^4.0.0",
+		"oclif": "^4",
+		"shx": "^0.3.3",
+		"typescript": "^5"
+	},
+	"engines": {
+		"node": ">=22.0.0"
+	},
+	"files": [
+		"./bin",
+		"./dist",
+		"./README.md",
+		"./oclif.manifest.json"
+	],
+	"homepage": "https://github.com/nyrra-labs/prismantix",
+	"keywords": [
+		"prismantix",
+		"export",
+		"api",
+		"cli"
+	],
+	"license": "SEE LICENSE IN LICENSE",
+	"main": "dist/index.js",
+	"type": "module",
+	"oclif": {
+		"bin": "prismantix-cli",
+		"dirname": "prismantix-cli",
+		"commands": "./dist/commands",
+		"plugins": [
+			"@oclif/plugin-help"
+		],
+		"topicSeparator": " "
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/nyrra-labs/prismantix.git",
+		"directory": "apps/cli"
+	},
+	"scripts": {
+		"build": "shx rm -rf dist tsconfig.tsbuildinfo && tsc -b tsconfig.json --force && oclif manifest",
+		"postpack": "shx rm -f oclif.manifest.json",
+		"prepack": "pnpm run build",
+		"test": "pnpm run build && vitest run --config vitest.config.mts",
+		"typecheck": "tsc -p tsconfig.json --noEmit"
+	},
+	"types": "dist/index.d.ts",
+	"publishConfig": {
+		"access": "public"
+	},
+	"nx": {
+		"name": "prismantix-cli"
+	}
+}