callkaro-cli-unofficial 0.4.0 → 0.5.0

package/dist/lib/api.js

@@ -48,7 +48,7 @@ class Api {
         const data = text ? safeJson(text) : undefined;
         if (!res.ok) {
             throw new types_1.ApiError(res.status, data?.msg || data?.message || (typeof data?.error === 'string' ? data.error : undefined) ||
-                `Request failed (${res.status})`, parseErrorDetails(data?.errors));
+                `Request failed (${res.status})`, parseErrorDetails(data?.errors ?? data?.data?.errors ?? invalidDetails(data?.invalid)));
         }
         return data;
     }
@@ -66,6 +66,98 @@ class Api {
     me() { return this.request('GET', '/cli/auth/me'); }
     /** Client accounts assigned to this user. Sent without the monitoring header: it lists, not acts. */
     listClientAccounts() { return this.request('GET', '/cli/auth/accounts', undefined, false); }
+    // --- workflows ------------------------------------------------------------
+    // The workflow controllers answer { success, message, data }; callers get `data`.
+    async workflow(method, path, body) {
+        return (await this.request(method, `/cli/workflows${path}`, body)).data;
+    }
+    listWorkflows(search) {
+        const q = new URLSearchParams({ limit: '100', type: 'normal' });
+        if (search)
+            q.set('search', search);
+        return this.workflow('GET', `?${q}`);
+    }
+    getWorkflow(id) { return this.workflow('GET', `/${id}`); }
+    createWorkflow(payload) { return this.workflow('POST', '', payload); }
+    updateWorkflow(id, payload) { return this.workflow('PUT', `/${id}`, payload); }
+    deleteWorkflow(id) { return this.workflow('DELETE', `/${id}`); }
+    duplicateWorkflow(id, workFlowName) {
+        return this.workflow('POST', `/${id}/duplicate`, { workFlowName });
+    }
+    validateWorkflowGraph(graph) { return this.workflow('POST', '/validate', { graph }); }
+    listWorkflowLeads(id, query = {}) {
+        return this.workflow('GET', `/${id}/leads${qs(query)}`);
+    }
+    getWorkflowLead(id, phone) {
+        return this.workflow('GET', `/${id}/leads/${encodeURIComponent(phone)}`);
+    }
+    getWorkflowRunByPhone(id, phone) {
+        return this.workflow('GET', `/${id}/runs/by-phone/${encodeURIComponent(phone)}`);
+    }
+    /** Every call to/from a number inside the workflow. Answers { success, calls }, not { data }. */
+    workflowJourney(id, phone) {
+        return this.request('GET', `/cli/workflows/${id}/journey/${encodeURIComponent(phone)}`);
+    }
+    // --- contacts (CRM) -------------------------------------------------------
+    // Unlike workflows, these controllers answer plain JSON ({ msg, contacts, ... }).
+    listContacts(query = {}) { return this.request('GET', `/cli/contacts${qs(query)}`); }
+    getContact(phone) { return this.request('GET', `/cli/contacts/detail/${encodeURIComponent(phone)}`); }
+    /** Upsert: creates the contact, or merges into an existing one. */
+    saveContact(body) { return this.request('POST', '/cli/contacts', body); }
+    updateContactAttributes(phone, attributes) {
+        return this.request('PATCH', `/cli/contacts/detail/${encodeURIComponent(phone)}`, { attributes });
+    }
+    deleteContact(phone) { return this.request('DELETE', `/cli/contacts/detail/${encodeURIComponent(phone)}`); }
+    assignContacts(body) { return this.request('POST', '/cli/contacts/assign', body); }
+    listContactAttributes() { return this.request('GET', '/cli/contacts/attributes'); }
+    saveContactAttribute(definition) { return this.request('POST', '/cli/contacts/attributes', definition); }
+    deleteContactAttribute(name) {
+        return this.request('DELETE', `/cli/contacts/attributes/${encodeURIComponent(name)}`);
+    }
+    /** CSV upload (multipart). Columns must match defined attributes unless ignoreUnknown. */
+    async uploadContacts(filePath, ignoreUnknown) {
+        const form = new FormData();
+        form.append('file', new Blob([(0, fs_1.readFileSync)(filePath)], { type: 'text/csv' }), (0, path_1.basename)(filePath));
+        if (ignoreUnknown)
+            form.append('ignoreUnknownColumns', 'true');
+        const headers = {};
+        if (this.token)
+            headers.Authorization = `Bearer ${this.token}`;
+        if (this.monitoringAccountId)
+            headers['X-CallKaro-Account-Id'] = this.monitoringAccountId;
+        const res = await fetch(`${this.baseUrl}/cli/contacts/upload`, { method: 'POST', headers, body: form });
+        const text = await res.text();
+        const data = text ? safeJson(text) : {};
+        if (!res.ok) {
+            const unknown = data?.unknownColumns || [];
+            const hint = unknown.length
+                ? ' Pass --ignore-unknown to drop them, or define them with `cku contacts attributes set`.'
+                : '';
+            throw new types_1.ApiError(res.status, `${data?.msg || `Request failed (${res.status})`}${hint}`, parseErrorDetails(data?.errors ?? data?.data?.errors ?? invalidDetails(data?.invalid)));
+        }
+        return data;
+    }
+    /** CSV text for the filtered set, or { processing } when the server emails it instead. */
+    async exportContacts(query = {}) {
+        const headers = {};
+        if (this.token)
+            headers.Authorization = `Bearer ${this.token}`;
+        if (this.monitoringAccountId)
+            headers['X-CallKaro-Account-Id'] = this.monitoringAccountId;
+        let res;
+        try {
+            res = await fetch(`${this.baseUrl}/cli/contacts/export${qs(query)}`, { headers });
+        }
+        catch (err) {
+            throw new types_1.ApiError(0, `Cannot reach ${this.baseUrl} (${err.message})`);
+        }
+        const text = await res.text();
+        if (!res.ok)
+            throw new types_1.ApiError(res.status, safeJson(text)?.msg || `Request failed (${res.status})`);
+        if ((res.headers.get('content-type') || '').includes('application/json'))
+            return safeJson(text);
+        return { csv: text };
+    }
     // --- secrets --------------------------------------------------------------
     listSecrets() { return this.request('GET', '/cli/secrets'); }
     saveSecrets(secrets) { return this.request('PUT', '/cli/secrets', { secrets }); }
@@ -179,6 +271,8 @@ class Api {
         const headers = {};
         if (this.token)
             headers.Authorization = `Bearer ${this.token}`;
+        if (this.monitoringAccountId)
+            headers['X-CallKaro-Account-Id'] = this.monitoringAccountId;
         const res = await fetch(`${this.baseUrl}/cli/calls/export${qs(query)}`, { headers });
         const contentType = res.headers.get('content-type') || '';
         if (contentType.includes('application/json')) {
@@ -231,6 +325,8 @@ class Api {
         // Let fetch set the multipart boundary — do not set Content-Type here.
         if (this.token)
             headers.Authorization = `Bearer ${this.token}`;
+        if (this.monitoringAccountId)
+            headers['X-CallKaro-Account-Id'] = this.monitoringAccountId;
         const res = await fetch(url, { method: 'POST', headers, body: form });
         const text = await res.text();
         const data = text ? safeJson(text) : {};
@@ -246,6 +342,7 @@ class Api {
         return this.request('GET', `/cli/voices/provider/${encodeURIComponent(provider)}${qs(params)}`);
     }
     // --- simulations ----------------------------------------------------------
+    simulationModels() { return this.request('GET', '/cli/simulations/models'); }
     createTestCase(body) { return this.request('POST', '/cli/simulations/test-cases', body); }
     listTestCases(agentId) {
         return this.request('GET', `/cli/simulations/test-cases${qs({ agentId })}`);
@@ -289,6 +386,17 @@ function safeJson(text) {
         return { msg: text };
     }
 }
+/** The CRM's per-value refusals: [{ attribute, reason, value }] -> one line each. */
+function invalidDetails(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.flatMap((v) => v && typeof v === 'object' && typeof v.reason === 'string'
+        ? [{
+                message: `${v.reason}${v.value !== undefined ? ` (got "${v.value}")` : ''}`,
+                path: v.attribute || v.column,
+            }]
+        : []);
+}
 function parseErrorDetails(value) {
     if (!Array.isArray(value))
         return [];

package/dist/lib/workflowEdit.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlesOf = exports.ADDABLE_TYPES = void 0;
+exports.addNode = addNode;
+exports.setNode = setNode;
+exports.removeNode = removeNode;
+exports.connect = connect;
+exports.disconnect = disconnect;
+/**
+ * Pure edits on a workflow graph. Each takes a graph, mutates it in place and
+ * returns a one-line summary; none talks to the server. The server still
+ * validates on save, so these only guard what would make an edit meaningless
+ * (unknown ids, a handle that does not exist) and keep the shapes the canvas
+ * writes: one edge per (from, fromHandle), exit ids on `conditions` nodes.
+ */
+const DEFAULT_HANDLE = 'out';
+const X_STEP = 320;
+// Mirrors NODE_META in the dashboard's WorkflowCanvas.jsx.
+const DEFAULT_NAMES = {
+    end: 'End',
+    'send-call': 'Send Call',
+    'wa-template': 'WhatsApp Template',
+    'wa-message': 'WhatsApp Message',
+    wait: 'Wait',
+    conditions: 'Conditions',
+    'api-basic': 'API Call',
+    'api-advanced': 'Custom Function',
+    'update-lead': 'Update Contact',
+};
+exports.ADDABLE_TYPES = Object.keys(DEFAULT_NAMES);
+// Fields with no sensible default: the server refuses the node until they are set, so say so up front.
+const NEEDS = {
+    'send-call': { fields: ['agentId'], example: '{"agentId":"<id from cku agents list>"}' },
+    'wa-template': { fields: ['templateId'], example: 'a template entry (see cku workflows schema)' },
+    'wa-message': { fields: ['message'], example: '{"message":"Hello","phoneNumberId":"…","displayPhoneNumber":"…","provider":"whatsapp","parameters":[]}' },
+    'api-basic': { fields: ['url'], example: '{"method":"POST","url":"https://…"}' },
+    'update-lead': { fields: ['updates'], example: '{"updates":[{"attribute":"stage","source":"static_value","value":"contacted"}]}' },
+};
+let counter = 0;
+const stamp = () => `${Date.now()}${counter++ % 10}`;
+const exitId = () => `o_${Math.random().toString(36).slice(2, 10)}`;
+const defaultsFor = (type) => {
+    switch (type) {
+        case 'send-call':
+            return { retries: 0, retryGapMinutes: 30, retryGaps: [] };
+        case 'wait':
+            return { minutes: 15 };
+        case 'update-lead':
+            return { updates: [{ attribute: '', source: 'post_call_variables', value: '' }] };
+        case 'api-advanced':
+            return { code: 'async function handler(context) {\n  // Everything is on context, e.g.\n  // context.call_metadata.lead_id\n}' };
+        // The dashboard seeds an incomplete rule and lets the canvas hold it as a draft; a CLI edit
+        // saves at once, so this starts as a complete one ("did the call connect?"). Change it with set-node.
+        case 'conditions':
+            return {
+                exits: [
+                    { id: exitId(), label: 'connected', next: '', condition: { source: 'connected_call', field: '', op: 'eq', value: true } },
+                    { id: exitId(), label: 'otherwise', next: '' },
+                ],
+            };
+        default:
+            return {};
+    }
+};
+const nodeOf = (g, id) => {
+    const node = g.nodes.find((n) => n.id === id);
+    if (!node)
+        throw new Error(`No node with id "${id}". Ids: ${g.nodes.map((n) => n.id).join(', ')}`);
+    return node;
+};
+const handlesOf = (node) => node.type === 'conditions' ? (node.exits || []).map((e) => e.id) : [DEFAULT_HANDLE];
+exports.handlesOf = handlesOf;
+/** The handle to use when the caller named none: the only one, or an error listing the choices. */
+function resolveHandle(node, handle) {
+    const handles = (0, exports.handlesOf)(node);
+    if (handle) {
+        if (!handles.includes(handle)) {
+            throw new Error(`"${node.id}" has no handle "${handle}". Handles: ${handles.join(', ')}`);
+        }
+        return handle;
+    }
+    if (handles.length !== 1) {
+        throw new Error(`"${node.id}" has several branches; pass --handle. Handles: ${handles.join(', ')}`);
+    }
+    return handles[0];
+}
+const edgeFrom = (g, from, handle) => g.edges.find((e) => e.from === from && e.fromHandle === handle);
+/** One edge per (from, fromHandle): connecting replaces whatever left that handle. */
+function setEdge(g, from, handle, to) {
+    g.edges = g.edges.filter((e) => !(e.from === from && e.fromHandle === handle));
+    g.edges.push({ id: `edge-${stamp()}`, from, fromHandle: handle, to });
+}
+function addNode(g, opts) {
+    if (!exports.ADDABLE_TYPES.includes(opts.type)) {
+        throw new Error(`--type must be one of: ${exports.ADDABLE_TYPES.join(', ')} (a workflow has exactly one start, which already exists)`);
+    }
+    const anchor = opts.after ? nodeOf(g, opts.after) : undefined;
+    if (anchor?.type === 'end')
+        throw new Error(`Nothing can follow "${anchor.id}": a run stops at an End node.`);
+    const afterHandle = anchor ? resolveHandle(anchor, opts.handle) : undefined;
+    const id = `${opts.type}-${stamp()}`;
+    const node = {
+        id,
+        type: opts.type,
+        name: opts.name ?? DEFAULT_NAMES[opts.type],
+        ...defaultsFor(opts.type),
+        ...(opts.set || {}),
+        x: opts.x ?? (anchor ? Math.round((anchor.x ?? 0) + X_STEP) : Math.round(Math.max(0, ...g.nodes.map((n) => n.x ?? 0)) + X_STEP)),
+        y: opts.y ?? Math.round(anchor?.y ?? g.nodes[0]?.y ?? 180),
+    };
+    node.id = id;
+    node.type = opts.type;
+    const need = NEEDS[opts.type];
+    const empty = (v) => v === undefined || v === '' || (Array.isArray(v) && (v.length === 0 || v.every((r) => !r?.attribute)));
+    if (need && need.fields.some((f) => empty(node[f]))) {
+        throw new Error(`A ${opts.type} node needs ${need.fields.join(', ')}: pass --set, e.g. --set '${need.example}'`);
+    }
+    g.nodes.push(node);
+    let note = '';
+    if (anchor && afterHandle) {
+        const previous = edgeFrom(g, anchor.id, afterHandle)?.to;
+        setEdge(g, anchor.id, afterHandle, id);
+        if (previous) {
+            if (opts.type === 'end') {
+                note = ` "${previous}" is no longer connected (an End has nothing after it).`;
+            }
+            else {
+                const exits = node.exits || [];
+                const out = node.type === 'conditions' ? (exits.find((e) => !e.condition)?.id ?? exits[exits.length - 1].id) : DEFAULT_HANDLE;
+                setEdge(g, id, out, previous);
+            }
+        }
+    }
+    return `Added ${opts.type} node "${id}"${anchor ? ` after "${anchor.id}"` : ' (not connected yet; use `connect`)'}.${note}`;
+}
+function setNode(g, nodeId, fields) {
+    const node = nodeOf(g, nodeId);
+    const { id: _id, type: _type, ...rest } = fields;
+    if ((_id !== undefined && _id !== nodeId) || (_type !== undefined && _type !== node.type)) {
+        throw new Error("A node's id and type cannot be changed; remove it and add a new one.");
+    }
+    Object.assign(node, rest);
+    const live = (0, exports.handlesOf)(node);
+    const before = g.edges.length;
+    g.edges = g.edges.filter((e) => e.from !== nodeId || live.includes(e.fromHandle));
+    const dropped = before - g.edges.length;
+    return `Updated "${nodeId}".${dropped ? ` Removed ${dropped} edge(s) from branches that no longer exist.` : ''}`;
+}
+function removeNode(g, nodeId, reconnect = false) {
+    const node = nodeOf(g, nodeId);
+    if (node.type === 'start')
+        throw new Error('The Start node cannot be removed.');
+    const next = node.type !== 'conditions' ? edgeFrom(g, nodeId, DEFAULT_HANDLE)?.to : undefined;
+    const incoming = g.edges.filter((e) => e.to === nodeId);
+    if (reconnect && !next) {
+        throw new Error(`--reconnect needs "${nodeId}" to have a single next step to bridge to; it has none.`);
+    }
+    g.nodes = g.nodes.filter((n) => n.id !== nodeId);
+    g.edges = g.edges.filter((e) => e.from !== nodeId && e.to !== nodeId);
+    if (reconnect && next)
+        incoming.forEach((e) => setEdge(g, e.from, e.fromHandle, next));
+    return `Removed "${nodeId}" and its edges${reconnect && next ? `; ${incoming.length} incoming edge(s) now lead to "${next}"` : ''}.`;
+}
+function connect(g, from, to, handle) {
+    const source = nodeOf(g, from);
+    const target = nodeOf(g, to);
+    if (source.type === 'end')
+        throw new Error(`Nothing can follow "${from}": a run stops at an End node.`);
+    if (target.type === 'start')
+        throw new Error(`Nothing can lead into "${to}": a run begins at Start.`);
+    const h = resolveHandle(source, handle);
+    const replaced = edgeFrom(g, from, h)?.to;
+    setEdge(g, from, h, to);
+    return `Connected "${from}" (${h}) → "${to}".${replaced && replaced !== to ? ` Replaced the old link to "${replaced}".` : ''}`;
+}
+function disconnect(g, from, handle) {
+    const h = resolveHandle(nodeOf(g, from), handle);
+    const edge = edgeFrom(g, from, h);
+    if (!edge)
+        throw new Error(`"${from}" (${h}) is not connected to anything.`);
+    g.edges = g.edges.filter((e) => e !== edge);
+    return `Disconnected "${from}" (${h}) from "${edge.to}".`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "callkaro-cli-unofficial",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "license": "Apache-2.0",
   "description": "Unofficial fork of the CallKaro CLI — manage your voice AI agents from the terminal",
   "bin": {