conduyt 1.0.0 → 1.1.1

package/dist/index.js

@@ -1,13 +1,29 @@
 #!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
 import { Command } from "commander";
 import { ConduytClient, buildQuery } from "./client.js";
 import { saveConfig, resolveConfig, configPath } from "./config.js";
 import { print, fail } from "./output.js";
+// Derive the version from package.json at runtime so `--version` can never
+// drift from the published package (dist/index.js -> ../package.json). Read at
+// top level runs on every invocation, so fall back gracefully rather than
+// crashing the whole CLI if the file is somehow unreadable.
+function readVersion() {
+    try {
+        const raw = readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf8");
+        return JSON.parse(raw).version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
 const program = new Command();
 program
     .name("conduyt")
     .description("Command-line interface for Conduyt CRM — manage contacts, deals, pipelines, and run insight queries from your terminal.")
-    .version("1.0.0");
+    .version(readVersion());
 // ---- config ----
 const config = program.command("config").description("Manage CLI configuration");
 config
@@ -52,10 +68,129 @@ const deals = program.command("deals").description("Manage deals");
 deals
     .command("list")
     .description("List deals")
-    .option("--limit <n>", "max results")
-    .option("--cursor <cursor>", "pagination cursor")
-    .option("--pipeline <id>", "filter by pipeline id")
-    .action(run(async (client, opts) => client.get(`/api/v1/deals${buildQuery({ limit: opts.limit, cursor: opts.cursor, pipelineId: opts.pipeline })}`)));
+    .option("--all", "fetch ALL matching deals across every page — use this for totals/P&L")
+    .option("--limit <n>", "results per page, 1-1000 (default 50)")
+    .option("--page <n>", "fetch a specific page (an explicit partial page is allowed)")
+    .option("--pipeline <id>", "filter by pipeline UUID")
+    .option("--pipeline-name <name>", "filter by pipeline name (resolved server-side; errors if not found — never returns the whole account)")
+    .option("--stage <id>", "filter by stage UUID")
+    .option("--stage-name <name>", "filter by stage name (requires --pipeline or --pipeline-name)")
+    .action(run(async (client, opts) => {
+    // A provided-but-blank filter must error, not silently become "no filter":
+    // buildQuery drops empty strings, so a blank flag would never reach the
+    // server to be rejected and would return the whole account. On a CLI a
+    // blank flag is always a mistake (an empty $VAR) — there is no "All"
+    // selection to express, you just omit the flag — so guard ALL filter
+    // flags, ids included.
+    for (const [flag, val] of [
+        ["--pipeline", opts.pipeline],
+        ["--pipeline-name", opts.pipelineName],
+        ["--stage", opts.stage],
+        ["--stage-name", opts.stageName],
+    ]) {
+        if (val !== undefined && val.trim() === "") {
+            throw new Error(`${flag} was provided but is blank. Omit it to skip the filter, or pass a real value.`);
+        }
+    }
+    const MAX_PER_PAGE = 1000; // matches the server's per_page cap
+    const parsePos = (v, name) => {
+        if (v === undefined)
+            return undefined;
+        const n = Number(v);
+        if (!Number.isInteger(n) || n < 1) {
+            throw new Error(`${name} must be a positive integer.`);
+        }
+        return n;
+    };
+    const limitN = parsePos(opts.limit, "--limit");
+    if (limitN !== undefined && limitN > MAX_PER_PAGE) {
+        throw new Error(`--limit cannot exceed ${MAX_PER_PAGE}. Use --all to fetch every page.`);
+    }
+    const pageN = parsePos(opts.page, "--page");
+    if (opts.all && pageN !== undefined) {
+        throw new Error("Use either --all or --page, not both.");
+    }
+    // Each filter routes to the canonical wire param the live contract
+    // advertises (deals paginates by per_page/page, NOT limit/cursor). An
+    // unknown/blank/conflicting name 400s server-side and surfaces as a CLI
+    // error — never a silent whole-account list.
+    const filterQ = {
+        pipeline: opts.pipeline,
+        pipeline_name: opts.pipelineName,
+        stage: opts.stage,
+        stage_name: opts.stageName,
+    };
+    // --all: auto-page through EVERY page and PROVE completeness, so totals/P&L
+    // are computed on the whole, consistent set — otherwise FAIL CLOSED. We
+    // de-dup by deal id (page/offset pagination can repeat a row if data shifts),
+    // require the server total to stay stable across pages, and require the final
+    // unique count to equal that total. A non-terminating server (ignoring page)
+    // hits a hard error, never a silent truncated/duplicated success.
+    if (opts.all) {
+        // --all must return a CONSISTENT, COMPLETE set for totals/P&L. The deals
+        // API paginates by page/offset with no snapshot/cursor, so stitching
+        // multiple pages over live data can silently mix snapshots (a deal leaves
+        // the filter as another enters, total unchanged). To avoid ANY such
+        // inconsistency we fetch in ONE atomic max-size page and FAIL CLOSED if
+        // the result does not fit — never assembling a multi-page set. (≤1000
+        // deals — typical pipelines, incl. this workflow — fetch fine.)
+        if (limitN !== undefined) {
+            throw new Error("--all controls paging itself; do not combine it with --limit.");
+        }
+        const res = (await client.get(`/api/v1/deals${buildQuery({ ...filterQ, per_page: String(MAX_PER_PAGE), page: "1" })}`));
+        const rows = res?.data?.data;
+        const total = res?.data?.meta?.total;
+        if (!Array.isArray(rows)) {
+            throw new Error("--all: unexpected response (data.data is not an array). Aborting.");
+        }
+        if (typeof total !== "number" || !Number.isInteger(total) || total < 0) {
+            throw new Error("--all cannot verify completeness: the deals endpoint returned no numeric meta.total. " +
+                "Refusing to emit a possibly-partial set.");
+        }
+        if (total > MAX_PER_PAGE) {
+            throw new Error(`--all: this filter matches ${total} deals — more than the ${MAX_PER_PAGE} that fit in one ` +
+                "consistent page. The deals API has no snapshot/cursor pagination, so a multi-page total " +
+                "could be inconsistent. Narrow the filter (e.g. --stage-name) or fetch specific --page ranges.");
+        }
+        // Validate ids; a REPEATED id means an internally-inconsistent response
+        // (two rows for one deal, possibly with conflicting amounts) — fail rather
+        // than let a Map overwrite hide it. Require row count AND unique count to
+        // both equal the total, so nothing is duplicated, dropped, or arbitrary.
+        const byId = new Map();
+        for (const d of rows) {
+            const id = d?.id;
+            if (typeof id !== "string" || id.trim() === "") {
+                throw new Error("--all: a deal row has a missing/invalid id — cannot de-duplicate safely. Aborting.");
+            }
+            if (byId.has(id)) {
+                throw new Error(`--all: the response contains a duplicate deal id (${id}) — inconsistent. Aborting.`);
+            }
+            byId.set(id, d);
+        }
+        if (rows.length !== total || byId.size !== total) {
+            throw new Error(`--all: page returned ${rows.length} rows (${byId.size} unique) but total=${total} — inconsistent. ` +
+                "Aborting — a partial or duplicated set would produce wrong totals/P&L.");
+        }
+        return { data: { data: [...byId.values()], meta: { total, fetched: byId.size } } };
+    }
+    // Single page.
+    const res = (await client.get(`/api/v1/deals${buildQuery({ ...filterQ, per_page: opts.limit, page: opts.page })}`));
+    const rows = res?.data?.data;
+    const total = res?.data?.meta?.total;
+    // HARD-FAIL on IMPLICIT truncation: if the caller did NOT request a specific
+    // page and this page is incomplete, exit non-zero instead of emitting a
+    // partial list that a script (piping stdout to jq, ignoring stderr) could
+    // compute a wrong P&L from. An explicit --page is an intentional partial.
+    if (pageN === undefined &&
+        Array.isArray(rows) &&
+        typeof total === "number" &&
+        rows.length < total) {
+        throw new Error(`Result truncated: page 1 has ${rows.length} of ${total} deals. ` +
+            `Use --all to fetch every deal (required for correct totals/P&L), ` +
+            `or --page <n> for a specific page.`);
+    }
+    return res;
+}));
 // ---- pipelines ----
 program
     .command("pipelines")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conduyt",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Command-line interface for Conduyt CRM — manage contacts, deals, pipelines, and run insight queries from your terminal.",
   "type": "module",
   "main": "dist/index.js",