callkaro-cli-unofficial 0.4.1 → 0.5.1

package/dist/lib/api.js

@@ -12,30 +12,64 @@ const types_1 = require("./types");
  * logic. Public methods map 1:1 to the `/cli/*` endpoints.
  */
 class Api {
-    token;
     monitoringAccountId;
+    renewToken;
     baseUrl;
     callBaseUrl;
-    constructor(baseUrl, callBaseUrl, token, monitoringAccountId) {
-        this.token = token;
+    /** Mutable: a renewed token replaces the rejected one for later requests. */
+    token;
+    constructor(baseUrl, callBaseUrl, token, monitoringAccountId, 
+    /**
+     * Re-issue a rejected token. The `ck_` token is opaque and has no refresh
+     * route, so the only way back in is to sign in again — which needs the
+     * account's password. Returns the new token, or undefined when the account
+     * cannot renew itself.
+     */
+    renewToken) {
         this.monitoringAccountId = monitoringAccountId;
+        this.renewToken = renewToken;
         this.baseUrl = baseUrl.replace(/\/+$/, '');
         this.callBaseUrl = (callBaseUrl || baseUrl).replace(/\/+$/, '');
+        this.token = token;
     }
     request(method, path, body, includeAccount = true) {
         return this.requestTo(this.baseUrl, method, path, body, includeAccount);
     }
     /** Same as request(), but against a specific base URL (e.g. the call cloud). */
     async requestTo(base, method, path, body, includeAccount = true) {
+        let res = await this.send(base, method, path, body, includeAccount, this.token);
+        // A rejected token is not a failure the user can act on by retrying: the
+        // same token gets the same answer. Renew once, silently, when the account
+        // has the means to renew itself. The renewed token then serves the rest of
+        // the command, so one renewal covers every request in it.
+        if (res.status === 401 && this.renewToken) {
+            const fresh = await this.renewToken();
+            if (fresh) {
+                this.token = fresh;
+                res = await this.send(base, method, path, body, includeAccount, fresh);
+            }
+        }
+        const text = await res.text();
+        const data = text ? safeJson(text) : undefined;
+        if (!res.ok) {
+            throw new types_1.ApiError(res.status, res.status === 401
+                ? `${data?.msg || 'Your session is no longer valid'} — the stored token was rejected and could not be renewed.\n` +
+                    '  Run `cku login` to sign in again.'
+                : data?.msg || data?.message || (typeof data?.error === 'string' ? data.error : undefined) ||
+                    `Request failed (${res.status})`, parseErrorDetails(data?.errors ?? data?.data?.errors ?? invalidDetails(data?.invalid)));
+        }
+        return data;
+    }
+    /** One HTTP round trip, with the given bearer token. */
+    async send(base, method, path, body, includeAccount, token) {
         const headers = { 'Content-Type': 'application/json' };
-        if (this.token)
-            headers.Authorization = `Bearer ${this.token}`;
+        if (token)
+            headers.Authorization = `Bearer ${token}`;
         // Monitoring mode: every request, writes included, acts on the client account.
         if (includeAccount && this.monitoringAccountId)
             headers['X-CallKaro-Account-Id'] = this.monitoringAccountId;
-        let res;
         try {
-            res = await fetch(`${base}${path}`, {
+            return await fetch(`${base}${path}`, {
                 method,
                 headers,
                 body: body === undefined ? undefined : JSON.stringify(body),
@@ -44,13 +78,6 @@ class Api {
         catch (err) {
             throw new types_1.ApiError(0, `Cannot reach ${base} (${err.message})`);
         }
-        const text = await res.text();
-        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));
-        }
-        return data;
     }
     // --- auth endpoints -------------------------------------------------------
     registerStart(email) { return this.request('POST', '/cli/auth/register/start', { email }); }
@@ -66,6 +93,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 +298,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 +352,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 +369,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 +413,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/config.js

@@ -30,6 +30,7 @@ exports.saveLogin = saveLogin;
 exports.monitoringAccountId = monitoringAccountId;
 exports.setMonitoring = setMonitoring;
 exports.getClient = getClient;
+exports.renewTokenFor = renewTokenFor;
 const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = require("path");
@@ -238,7 +239,16 @@ function saveAccount(email, session) {
     // so without this a later `cku login` would silently drop a dashboard session
     // the account already holds.
     const dashboard = session.dashboard ?? loadAccount(slug).dashboard;
-    writeJson(accountPath(slug), { ...session, email, savedAt: new Date().toISOString(), ...(dashboard ? { dashboard } : {}) });
+    // The password is the one field carried across a re-login: it is what lets a
+    // rejected token be re-issued without the user signing in again.
+    const password = session.password ?? loadAccount(slug).password;
+    writeJson(accountPath(slug), {
+        ...session,
+        email,
+        savedAt: new Date().toISOString(),
+        ...(dashboard ? { dashboard } : {}),
+        ...(password ? { password } : {}),
+    });
     setActiveAccount(email);
     return slug;
 }
@@ -323,8 +333,10 @@ function clearSession() {
     if (!(0, fs_1.existsSync)(path))
         return undefined;
     const { email, savedAt, dashboard } = loadAccount(slug);
-    // Dropping the ck_ token is what logout means. A dashboard session is a
-    // separate credential and is left in place — `cku firebase logout` removes it.
+    // Dropping the ck_ token is what logout means. The password goes with it: it
+    // exists only to re-issue that token, so keeping it would let a logged-out
+    // account sign itself back in. A dashboard session is a separate credential
+    // and is left in place — `cku dashboard logout` removes it.
     writeJson(path, { email, savedAt, ...(dashboard ? { dashboard } : {}) });
     return email;
 }
@@ -365,5 +377,48 @@ function setMonitoring(monitoring) {
 /** Build the API client from the endpoint URLs + resolved token. */
 function getClient() {
     const cfg = loadConfig();
-    return { api: new api_1.Api(backendUrl(), callUrl(), cfg.token, monitoringAccountId(cfg)), cfg };
+    return {
+        api: new api_1.Api(backendUrl(), callUrl(), cfg.token, monitoringAccountId(cfg), renewTokenFor(cfg)),
+        cfg,
+    };
+}
+/**
+ * Sign in again for an account that stored its password, and persist the new
+ * token.
+ *
+ * The `ck_` token is opaque and has no refresh route, so a token the server
+ * stops accepting leaves no way back in except a fresh sign-in. An account that
+ * stored its password renews itself; one that did not cannot, and the caller
+ * gets undefined so the error can name `cku login`.
+ *
+ * Under CK_TOKEN there is no stored account in effect, so nothing is renewed:
+ * the environment owns the credential.
+ */
+function renewTokenFor(cfg = loadConfig()) {
+    if (process.env.CK_TOKEN)
+        return undefined;
+    const email = cfg.email;
+    const password = cfg.password;
+    if (!email || !password)
+        return undefined;
+    return async () => {
+        try {
+            const res = await fetch(`${backendUrl()}/cli/auth/login`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ email, password }),
+            });
+            const data = (await res.json().catch(() => ({})));
+            if (!res.ok || !data.token)
+                return undefined;
+            // Persist the new token, keeping everything else the account holds.
+            const slug = slugFor(email);
+            const current = loadAccount(slug);
+            writeJson(accountPath(slug), { ...current, email, token: data.token, savedAt: new Date().toISOString() });
+            return data.token;
+        }
+        catch {
+            return undefined;
+        }
+    };
 }

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.1",
+  "version": "0.5.1",
   "license": "Apache-2.0",
   "description": "Unofficial fork of the CallKaro CLI — manage your voice AI agents from the terminal",
   "bin": {