conduyt 1.9.0 → 1.11.0

package/dist/index.js

@@ -1362,6 +1362,12 @@ users
     .option("--email <email>", "email")
     .option("--role <role>", "member | admin | owner")
     .option("--phone <phone>", "phone")
+    .option("--position <text>", "rep-profile position/title, merge-taggable as {{user.position}} (pass '' to clear)")
+    .option("--mobile <phone>", "rep-profile mobile phone, merge-taggable as {{user.mobilePhone}} (pass '' to clear)")
+    .option("--custom1 <text>", "rep-profile custom 1, {{user.custom1}} (pass '' to clear)")
+    .option("--custom2 <text>", "rep-profile custom 2, {{user.custom2}} (pass '' to clear)")
+    .option("--custom3 <text>", "rep-profile custom 3, {{user.custom3}} (pass '' to clear)")
+    .option("--custom4 <text>", "rep-profile custom 4, {{user.custom4}} (pass '' to clear)")
     .option("--json <json>", "full JSON body, merged over the flags")
     .action(run(async (client, id, opts) => {
     assertUuid(id, "user id");
@@ -1376,6 +1382,20 @@ users
         body.role = opts.role;
     if (opts.phone !== undefined)
         body.phone = opts.phone;
+    // Rep-profile fields (#42): an explicit empty string clears the field
+    // (the API treats blank as null); omitted flags leave it untouched.
+    if (opts.position !== undefined)
+        body.position = opts.position || null;
+    if (opts.mobile !== undefined)
+        body.mobilePhone = opts.mobile || null;
+    if (opts.custom1 !== undefined)
+        body.custom1 = opts.custom1 || null;
+    if (opts.custom2 !== undefined)
+        body.custom2 = opts.custom2 || null;
+    if (opts.custom3 !== undefined)
+        body.custom3 = opts.custom3 || null;
+    if (opts.custom4 !== undefined)
+        body.custom4 = opts.custom4 || null;
     if (opts.json !== undefined)
         Object.assign(body, jsonArg(opts.json, "--json"));
     if (Object.keys(body).length === 0)
@@ -1807,6 +1827,205 @@ lifecycle
         throw new Error(`Invalid status name '${bad}' — 1-40 chars; letters, numbers, spaces, - and _ only.`);
     return client.patch("/api/v1/settings", { masterStatuses: clean });
 }));
+// ---- call flows + ring groups (#25 tri-surface parity, 2026-08-23) ----
+// IVR routing graphs and their companion ring sets. Settings-scoped at the
+// API-key boundary (same tier as the rest of the Twilio setup surface): a
+// dialer-only key gets 403 here. The flow graph (--graph) is the node/edge
+// JSON the API validates — `validate` previews problems without publishing.
+const callFlows = program.command("call-flows").description("Call flows: the IVR routing graphs inbound numbers execute (settings scope)");
+callFlows
+    .command("list")
+    .description("List call flows with status (draft/published) and attached numbers")
+    .action(run(async (client) => client.get("/api/v1/call-flows")));
+callFlows
+    .command("get <id>")
+    .description("Get one call flow incl. draft + published graphs")
+    .action(run(async (client, id) => { assertUuid(id, "call flow id"); return client.get(`/api/v1/call-flows/${encodeURIComponent(id)}`); }));
+callFlows
+    .command("create <name>")
+    .description("Create a call flow (starts as a DRAFT)")
+    .option("--phone-number <e164>", "account number this flow answers")
+    .option("--graph <json>", "initial flow graph (node/edge JSON)")
+    .action(run(async (client, name, opts) => {
+    const body = { name };
+    if (opts.phoneNumber !== undefined)
+        body.phoneNumber = opts.phoneNumber;
+    if (opts.graph !== undefined)
+        body.draftGraph = graphArg(opts.graph);
+    return client.post("/api/v1/call-flows", body);
+}));
+callFlows
+    .command("update <id>")
+    .description("Update the DRAFT (published behavior changes only on the next publish)")
+    .option("--name <name>", "new name")
+    .option("--phone-number <e164>", "new number")
+    .option("--graph <json>", "replacement draft graph (node/edge JSON) — REQUIRES --expected-draft-revision")
+    .option("--expected-draft-revision <n>", "draftRevision from your last `call-flows get` read (REQUIRED with --graph; the API 428s without it — it is graph-specific, so calls/publish never invalidate it)")
+    .action(run(async (client, id, opts) => {
+    assertUuid(id, "call flow id");
+    const body = {};
+    if (opts.name !== undefined)
+        body.name = opts.name;
+    if (opts.phoneNumber !== undefined)
+        body.phoneNumber = opts.phoneNumber;
+    if (opts.graph !== undefined) {
+        if (opts.expectedDraftRevision === undefined) {
+            throw new Error("Replacing --graph requires --expected-draft-revision (the draftRevision you read the flow at) — `call-flows get` first.");
+        }
+        body.draftGraph = graphArg(opts.graph);
+    }
+    if (opts.expectedDraftRevision !== undefined) {
+        // Strict decimal form BEFORE Number(): Number("") is 0, and a newly
+        // created flow's revision IS 0 — an unset shell variable must refuse
+        // locally, never perform a real graph replacement.
+        const raw = String(opts.expectedDraftRevision).trim();
+        const n = /^\d+$/.test(raw) ? Number(raw) : NaN;
+        if (!Number.isSafeInteger(n) || n < 0) {
+            throw new Error("--expected-draft-revision must be the non-negative integer draftRevision from your last read.");
+        }
+        body.expectedDraftRevision = n;
+    }
+    if (Object.keys(body).length === 0)
+        throw new Error("Nothing to update. Pass at least one flag.");
+    return client.patch(`/api/v1/call-flows/${encodeURIComponent(id)}`, body);
+}));
+callFlows
+    .command("delete <id>")
+    .description("Delete a call flow. A PUBLISHED flow refuses deletion (409) — run `call-flows unpublish` first")
+    .action(run(async (client, id) => { assertUuid(id, "call flow id"); return client.del(`/api/v1/call-flows/${encodeURIComponent(id)}`); }));
+callFlows
+    .command("validate <id>")
+    .description("Validate the draft graph WITHOUT publishing — structured problems")
+    .action(run(async (client, id) => { assertUuid(id, "call flow id"); return client.get(`/api/v1/call-flows/${encodeURIComponent(id)}/validate`); }));
+callFlows
+    .command("publish <id>")
+    .description("Publish the draft (refuses an invalid graph). REQUIRES --expected-updated-at (the API 428s without it): `call-flows get` first, pass its updatedAt — a concurrent edit then 409s instead of being published over")
+    .requiredOption("--expected-updated-at <iso>", "updatedAt from your last `call-flows get` read (REQUIRED)")
+    .action(run(async (client, id, opts) => {
+    assertUuid(id, "call flow id");
+    if (Number.isNaN(Date.parse(opts.expectedUpdatedAt))) {
+        throw new Error("--expected-updated-at must be the ISO updatedAt timestamp from your last read.");
+    }
+    return client.post(`/api/v1/call-flows/${encodeURIComponent(id)}/publish`, { expectedUpdatedAt: opts.expectedUpdatedAt });
+}));
+callFlows
+    .command("unpublish <id>")
+    .description("Unpublish — the number falls back to default routing")
+    .action(run(async (client, id) => { assertUuid(id, "call flow id"); return client.post(`/api/v1/call-flows/${encodeURIComponent(id)}/unpublish`, {}); }));
+callFlows
+    .command("simulate <id>")
+    .description('"If someone calls right now, who picks up?" — DRAFT graph vs LIVE availability, no side effects')
+    .action(run(async (client, id) => { assertUuid(id, "call flow id"); return client.post(`/api/v1/call-flows/${encodeURIComponent(id)}/simulate`, {}); }));
+callFlows
+    .command("roster")
+    .description("Routing roster: members with DIDs + live availability")
+    .action(run(async (client) => client.get("/api/v1/call-flows/roster")));
+const ringGroups = program.command("ring-groups").description("Ring groups: simultaneous/sequential ring sets over member DIDs (settings scope)");
+ringGroups
+    .command("list")
+    .description("List ring groups with numbers and members")
+    .action(run(async (client) => client.get("/api/v1/ring-groups")));
+ringGroups
+    .command("get <id>")
+    .description("Get one ring group")
+    .action(run(async (client, id) => { assertUuid(id, "ring group id"); return client.get(`/api/v1/ring-groups/${encodeURIComponent(id)}`); }));
+ringGroups
+    .command("create <name>")
+    .description("Create a ring group. --phone-number is REQUIRED; without --member-ids the group is created INACTIVE (memberless groups never ring)")
+    .requiredOption("--phone-number <e164>", "account number that rings this group (REQUIRED)")
+    .option("--member-ids <ids>", "comma-separated member user UUIDs (omit → created inactive)")
+    .option("--strategy <strategy>", "ring strategy (e.g. simultaneous, sequential)")
+    .option("--ring-seconds <n>", "seconds to ring before advancing/failing over (integer 5-120)")
+    .option("--inactive", "create as inactive")
+    .action(run(async (client, name, opts) => {
+    // memberIds must ALWAYS be an array — the API rejects undefined
+    // (validateRingGroupMemberIds requires an array; [] = memberless →
+    // the group is created INACTIVE).
+    const body = {
+        name,
+        phoneNumber: opts.phoneNumber,
+        memberIds: opts.memberIds !== undefined ? memberIdsArg(opts.memberIds) : [],
+    };
+    if (opts.strategy !== undefined)
+        body.strategy = opts.strategy;
+    if (opts.ringSeconds !== undefined)
+        body.ringSeconds = ringSecondsArg(opts.ringSeconds);
+    if (opts.inactive)
+        body.isActive = false;
+    return client.post("/api/v1/ring-groups", body);
+}));
+ringGroups
+    .command("update <id>")
+    .description("Update a ring group. --expected-updated-at makes a concurrent edit 409 instead of being overwritten")
+    .option("--name <name>", "new name")
+    .option("--phone-number <e164>", "new number")
+    .option("--member-ids <ids>", 'comma-separated replacement member UUIDs, or "none" to clear the roster (deactivates the group)')
+    .option("--strategy <strategy>", "ring strategy")
+    .option("--ring-seconds <n>", "seconds to ring")
+    .option("--active <bool>", 'active flag — exactly "true" or "false"')
+    .option("--expected-updated-at <iso>", "updatedAt from your last read (REQUIRED when replacing --member-ids)")
+    .action(run(async (client, id, opts) => {
+    assertUuid(id, "ring group id");
+    const body = {};
+    if (opts.name !== undefined)
+        body.name = opts.name;
+    if (opts.phoneNumber !== undefined)
+        body.phoneNumber = opts.phoneNumber;
+    if (opts.memberIds !== undefined) {
+        if (opts.expectedUpdatedAt === undefined) {
+            throw new Error("Replacing --member-ids requires --expected-updated-at (the updatedAt you read the group at) — `ring-groups get` first.");
+        }
+        const ids = memberIdsArg(opts.memberIds);
+        body.memberIds = ids;
+        if (ids.length === 0) {
+            // An empty roster cannot stay active (the API 400s an active
+            // memberless group) — clearing implies deactivation.
+            if (opts.active === "true") {
+                throw new Error('--member-ids none clears the roster and deactivates the group — it cannot combine with --active true.');
+            }
+            body.isActive = false;
+        }
+    }
+    if (opts.strategy !== undefined)
+        body.strategy = opts.strategy;
+    if (opts.ringSeconds !== undefined)
+        body.ringSeconds = ringSecondsArg(opts.ringSeconds);
+    if (opts.active !== undefined)
+        body.isActive = strictBool(opts.active, "--active");
+    if (opts.expectedUpdatedAt !== undefined) {
+        if (Number.isNaN(Date.parse(opts.expectedUpdatedAt))) {
+            throw new Error("--expected-updated-at must be the ISO updatedAt timestamp from your last read.");
+        }
+        body.expectedUpdatedAt = opts.expectedUpdatedAt;
+    }
+    if (Object.keys(body).length === 0)
+        throw new Error("Nothing to update. Pass at least one flag.");
+    return client.patch(`/api/v1/ring-groups/${encodeURIComponent(id)}`, body);
+}));
+ringGroups
+    .command("delete <id>")
+    .description("Delete a ring group (its number keeps default routing)")
+    .action(run(async (client, id) => { assertUuid(id, "ring group id"); return client.del(`/api/v1/ring-groups/${encodeURIComponent(id)}`); }));
+ringGroups
+    .command("release-number <e164>")
+    .description("Release a number from routing (DESTRUCTIVE). --confirm must repeat the EXACT number. A number still referenced by an ACTIVE group cannot be released — delete or repoint that group first; --force does NOT bypass it (it exists only for numbers whose Twilio ownership cannot be verified, and then --force-reason is required)")
+    .requiredOption("--confirm <e164>", "EXACT repetition of the number being released (REQUIRED)")
+    .option("--force", "ONLY when Twilio ownership is unverifiable; requires --force-reason")
+    .option("--force-reason <why>", "non-empty justification, required with --force")
+    .action(run(async (client, phoneNumber, opts) => {
+    if (opts.confirm !== phoneNumber) {
+        throw new Error(`--confirm must repeat the exact number (${phoneNumber}) — got "${opts.confirm}".`);
+    }
+    if (opts.force && !(opts.forceReason && opts.forceReason.trim())) {
+        throw new Error("--force requires a non-empty --force-reason.");
+    }
+    const body = { phoneNumber, confirm: opts.confirm };
+    if (opts.force) {
+        body.force = true;
+        body.forceReason = opts.forceReason;
+    }
+    return client.post("/api/v1/ring-groups/release-number", body);
+}));
 program.parseAsync(process.argv).catch(fail);
 // helpers
 // Parse a --json / --stages style argument, throwing a clear CLI error (caught
@@ -1880,6 +2099,39 @@ function jsonArrayArg(raw, flag) {
     }
     return v;
 }
+function strictBool(raw, flag) {
+    if (raw === "true")
+        return true;
+    if (raw === "false")
+        return false;
+    throw new Error(`${flag} must be exactly "true" or "false" (got "${raw}").`);
+}
+function ringSecondsArg(raw) {
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < 5 || n > 120) {
+        throw new Error("--ring-seconds must be an integer between 5 and 120.");
+    }
+    return n;
+}
+function memberIdsArg(raw) {
+    // "none" is the explicit empty roster: the API accepts memberIds: [] and
+    // uses it to clear (and deactivate) a group — without a spelled form the
+    // CLI could never remove the final member.
+    if (raw.trim().toLowerCase() === "none")
+        return [];
+    const parts = raw.split(",").map((v) => v.trim());
+    if (parts.length === 0 || parts.some((v) => v === "")) {
+        throw new Error('--member-ids must be a comma-separated list of user UUIDs with no empty entries (or "none" to clear the roster).');
+    }
+    return parts;
+}
+function graphArg(raw) {
+    const g = jsonArg(raw, "--graph");
+    if (typeof g.entryId !== "string" || !Array.isArray(g.nodes)) {
+        throw new Error("--graph must be a flow graph object with a string entryId and a nodes array — the API silently substitutes a default voicemail flow for anything else.");
+    }
+    return g;
+}
 function jsonArg(raw, flag) {
     if (raw.trim() === "") {
         throw new Error(`${flag} must be valid JSON (got an empty string).`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conduyt",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "description": "Command-line interface for Conduyt CRM — manage contacts, deals, pipelines, and run insight queries from your terminal.",
   "type": "module",
   "main": "dist/index.js",
@@ -18,7 +18,7 @@
     "build": "tsc",
     "typecheck": "tsc --noEmit",
     "start": "tsx src/index.ts",
-    "prepublishOnly": "npm run check:version && npm run build && node --import tsx --experimental-test-module-mocks --test src/privacy-forget.test.ts src/contact-source-json.test.ts",
+    "prepublishOnly": "npm run check:version && npm run build && node --import tsx --experimental-test-module-mocks --test src/*.test.ts",
     "test": "node --import tsx --test src/*.test.ts",
     "check:version": "node -e \"const p=require('./package.json').version,l=require('./package-lock.json');if(l.version!==p||l.packages[''].version!==p){console.error('lockfile version != '+p);process.exit(1)}console.log('Version sync OK: '+p)\""
   },