@flowapt/flowiq-cli 0.1.5 → 0.1.7

package/src/commands/agent-updates.js

@@ -0,0 +1,186 @@
+// `flowiq agent-updates pull <org_id> [flags]` / `list`.
+// Read-only: fetches an org's agent_updates + chat context via /cli/agent-updates,
+// then downloads any attachments client-side into ./.flowiq/agent-updates/files/.
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { http } from "../http.js";
+
+const AU_DIR = path.resolve(process.cwd(), ".flowiq", "agent-updates");
+const FILES_DIRNAME = "files";
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const DEFAULT_MAX_MB = 25;
+
+function slugify(name, fallback) {
+  const s = String(name || "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+  return s || fallback;
+}
+
+async function fileExists(p) {
+  try { await fs.access(p); return true; } catch { return false; }
+}
+
+function oneLine(s, n = 120) {
+  const t = String(s ?? "").replace(/\s+/g, " ").trim();
+  return t.length > n ? t.slice(0, n - 1) + "…" : t;
+}
+
+// Filesystem-safe filename (strip path, control chars, separators).
+function safeFilename(name, fallback) {
+  const base = String(name || "").split("?")[0].split(/[\\/]/).pop().trim();
+  const cleaned = base.replace(/[\x00-\x1f]/g, "").replace(/[\\/]/g, "_");
+  return cleaned || fallback;
+}
+
+// Download one URL to destPath, respecting a byte cap. Never throws.
+async function downloadOne(url, destPath, maxBytes) {
+  let res;
+  try { res = await fetch(url); }
+  catch (e) { return { ok: false, reason: `fetch error: ${e.message}` }; }
+  if (!res.ok) return { ok: false, reason: `http ${res.status}` };
+  const len = Number(res.headers.get("content-length") || 0);
+  if (len && len > maxBytes) return { ok: false, reason: `too large (${len} bytes > cap)` };
+  const buf = Buffer.from(await res.arrayBuffer());
+  if (buf.length > maxBytes) return { ok: false, reason: `too large (${buf.length} bytes > cap)` };
+  await fs.mkdir(path.dirname(destPath), { recursive: true });
+  await fs.writeFile(destPath, buf);
+  return { ok: true, bytes: buf.length };
+}
+
+async function downloadUpdateFiles(update, maxBytes) {
+  const baseDir = path.join(AU_DIR, FILES_DIRNAME, update.id);
+  const atts = Array.isArray(update.attachments) ? update.attachments : [];
+  for (let i = 0; i < atts.length; i++) {
+    const a = atts[i];
+    if (!a || !a.url) continue;
+    const fname = safeFilename(a.filename, `attachment-${i + 1}`);
+    if (a.size && a.size > maxBytes) {
+      a.download = { ok: false, reason: `declared size ${a.size} bytes > cap` };
+      continue;
+    }
+    const r = await downloadOne(a.url, path.join(baseDir, fname), maxBytes);
+    a.download = r;
+    if (r.ok) a.local_path = path.join(baseDir, fname);
+  }
+  if (update.superadmin_response_image) {
+    const fname = "admin-" + safeFilename(update.superadmin_response_image, "response-image");
+    const r = await downloadOne(update.superadmin_response_image, path.join(baseDir, fname), maxBytes);
+    update.superadmin_response_image_download = r;
+    if (r.ok) update.superadmin_response_image_local = path.join(baseDir, fname);
+  }
+}
+
+export async function pull(orgId, opts = {}) {
+  if (!UUID_RE.test(orgId)) {
+    console.error(`Error: "${orgId}" is not a valid organization UUID.`);
+    process.exit(1);
+  }
+
+  const downloadFiles = !opts.noFiles;
+  const maxMb = opts.maxMb != null ? Number.parseFloat(opts.maxMb) : DEFAULT_MAX_MB;
+  if (!Number.isFinite(maxMb) || maxMb <= 0) {
+    console.error(`Invalid --max-mb: ${opts.maxMb}`);
+    process.exit(1);
+  }
+  const maxBytes = Math.round(maxMb * 1024 * 1024);
+
+  const query = { organization_id: orgId };
+  if (opts.status) query.status = opts.status;
+  if (opts.titles) query.titles = opts.titles;
+  if (opts.before != null) query.before = String(opts.before);
+  if (opts.after != null) query.after = String(opts.after);
+  if (opts.recent != null) query.recent = String(opts.recent);
+
+  let resp;
+  try {
+    resp = await http.get("agent-updates", query);
+  } catch (e) {
+    console.error(`Pull failed: ${e.message}`);
+    process.exit(1);
+  }
+
+  // Download attachments client-side (mutates the update objects with local_path).
+  if (downloadFiles) {
+    for (const u of resp.updates || []) {
+      try { await downloadUpdateFiles(u, maxBytes); }
+      catch (e) { u._file_download_error = e.message; }
+    }
+  }
+  resp.attachments_downloaded = downloadFiles;
+  resp.attachment_max_mb = maxMb;
+
+  await fs.mkdir(AU_DIR, { recursive: true });
+  const slug = slugify(resp.organization_name, resp.organization_id);
+  const filePath = path.join(AU_DIR, `${slug}.json`);
+  const overwriting = await fileExists(filePath);
+  await fs.writeFile(filePath, JSON.stringify(resp, null, 2) + "\n", "utf8");
+
+  const updates = resp.updates || [];
+  console.log(`${overwriting ? "Overwrote" : "Wrote"} ${filePath}`);
+  console.log(`  org:            ${resp.organization_name} (${resp.organization_id})`);
+  console.log(`  status filter:  ${resp.status_filter}`);
+  console.log(`  title filter:   ${resp.title_filter ? resp.title_filter.join(" | ") : "(none — all)"}`);
+  console.log(`  attachments:    ${downloadFiles ? `auto-download ON (cap ${maxMb}MB)` : "OFF (--no-files)"}`);
+  console.log(`  updates:        ${updates.length}`);
+  if (!updates.length) {
+    console.log("  (no matching updates)");
+    return;
+  }
+  console.log("");
+  updates.forEach((u, i) => {
+    const date = String(u.created_at || "").slice(0, 16).replace("T", " ");
+    console.log(`  [${i + 1}] ${u.title}`);
+    console.log(`      priority=${u.priority}  status=${u.status}  raised=${date}${u.created_by_name ? ` by ${u.created_by_name}` : ""}`);
+    console.log(`      desc: ${oneLine(u.description, 140)}`);
+    if (u.contact) console.log(`      contact: ${u.contact.full_name ?? "(no name)"} (${u.contact.whatsapp_id ?? u.contact.id})`);
+    if (u.attachments && u.attachments.length) {
+      console.log(`      attachments: ${u.attachments.length} (${u.attachments.map((a) => a.filename || a.type || "file").join(", ")})`);
+      for (const a of u.attachments) {
+        if (a.local_path) console.log(`        ↓ ${a.local_path}`);
+        else if (a.download && !a.download.ok) console.log(`        ✗ ${a.filename || "file"}: ${a.download.reason}`);
+      }
+    }
+    if (u.superadmin_response_image_local) console.log(`      admin response image: ↓ ${u.superadmin_response_image_local}`);
+    if (u.context && u.context.messages && u.context.messages.length) {
+      const trig = u.context.messages.find((m) => m.is_trigger);
+      console.log(`      context: ${u.context.total} msgs (anchor=${u.context.anchor})${trig ? ` · trigger: "${oneLine(trig.message, 80)}"` : ""}`);
+    } else {
+      console.log(`      context: (none linked)`);
+    }
+    console.log("");
+  });
+  console.log("Read the JSON for full update text + chat context. Attachments (paths marked ↓) were downloaded to");
+  console.log(`${path.join(AU_DIR, FILES_DIRNAME)}/<update-id>/ — Read those files for visual context, then act.`);
+}
+
+export async function list() {
+  let files;
+  try {
+    files = (await fs.readdir(AU_DIR)).filter((f) => f.endsWith(".json"));
+  } catch {
+    console.log("(no local snapshots — run `agent-updates pull <organization_id>`)");
+    return;
+  }
+  if (!files.length) {
+    console.log("(no local snapshots — run `agent-updates pull <organization_id>`)");
+    return;
+  }
+  files.sort();
+  for (const f of files) {
+    const fp = path.join(AU_DIR, f);
+    try {
+      const d = JSON.parse(await fs.readFile(fp, "utf8"));
+      console.log(f);
+      console.log(`  org:        ${d.organization_name ?? "(unknown)"} (${d.organization_id ?? "?"})`);
+      console.log(`  filter:     status=${d.status_filter ?? "?"} title=${d.title_filter ? d.title_filter.join("|") : "(all)"}`);
+      console.log(`  updates:    ${d.total_updates ?? "?"}`);
+      console.log(`  pulled:     ${d.pulled_at ?? "(unknown)"}`);
+    } catch (e) {
+      console.log(`${f}  [invalid JSON: ${e.message}]`);
+    }
+  }
+}

package/src/commands/export.js

@@ -0,0 +1,131 @@
+// `flowiq export chats <organization_id> [--out <path>]`.
+// Full chat export → TXT, byte-identical to the in-app "Export Settings TXT".
+// The server (/cli/export-chats) supplies keyset pages (ordered, whatsapp_id
+// resolved); ALL grouping + formatting happens here, verbatim from the legacy
+// export-chats.mjs, so the output matches the deployed feature exactly.
+
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { http } from "../http.js";
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+function slugify(name, fallback) {
+  const s = String(name || "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+  return s || fallback;
+}
+
+// Verbatim from export-chats.mjs.
+function getSenderLabel(senderType) {
+  if (senderType.startsWith("user-")) return "customer";
+  if (senderType.startsWith("bot-")) return "bot";
+  if (senderType.startsWith("human-")) return "agent";
+  if (senderType.startsWith("flowmod-")) return "flowmod";
+  if (senderType.startsWith("call-")) return "call";
+  if (senderType === "tool-call") return "tool";
+  return senderType;
+}
+
+export async function chats(orgId, opts = {}) {
+  if (!UUID_RE.test(orgId)) {
+    console.error(`Error: "${orgId}" is not a valid organization UUID.`);
+    process.exit(1);
+  }
+
+  const t0 = Date.now();
+
+  // --- Drive the keyset page loop, accumulating messages in global order ---
+  const messages = [];
+  let organizationName = null;
+  let cursor = null;
+  let pages = 0;
+  for (;;) {
+    const query = { organization_id: orgId };
+    if (cursor) {
+      query.cursor_created_at = cursor.created_at;
+      query.cursor_id = cursor.id;
+    }
+    let resp;
+    try {
+      resp = await http.get("export-chats", query);
+    } catch (e) {
+      console.error(`Export failed on page ${pages + 1}: ${e.message}`);
+      process.exit(1);
+    }
+    if (resp.organization_name != null) organizationName = resp.organization_name;
+    const page = resp.page || [];
+    for (const r of page) messages.push(r);
+    pages++;
+    if (pages % 20 === 0) {
+      console.log(`  ...${messages.length.toLocaleString("en-US")} messages (${pages} pages)`);
+    }
+    if (resp.done || !resp.next_cursor) break;
+    cursor = resp.next_cursor;
+  }
+  console.log(`Messages fetched: ${messages.length} in ${pages} page${pages === 1 ? "" : "s"}`);
+
+  // --- Group exactly like the deployed exportTXT: plain object, waId key ---
+  const grouped = {};
+  for (const row of messages) {
+    const whatsappId = row.whatsapp_id ?? null;
+    const waId = (whatsappId || "unknown").replace(/[+ ]/g, "");
+    if (!grouped[waId]) grouped[waId] = [];
+    grouped[waId].push(row);
+  }
+  const uniqueContacts = Object.keys(grouped).length;
+
+  // --- Resolve output path ---
+  let outPath = opts.out;
+  if (!outPath) {
+    const dir = path.resolve(process.cwd(), ".flowiq", "exports");
+    await fsp.mkdir(dir, { recursive: true });
+    outPath = path.join(dir, `${slugify(organizationName, orgId)}-chats.txt`);
+  } else {
+    outPath = path.resolve(outPath);
+    await fsp.mkdir(path.dirname(outPath), { recursive: true });
+  }
+
+  // --- Write the TXT (streamed; content identical to the deployed string build) ---
+  const out = fs.createWriteStream(outPath, { encoding: "utf8" });
+  const write = (s) =>
+    new Promise((resolve, reject) => {
+      if (out.write(s)) resolve();
+      else out.once("drain", resolve);
+      out.once("error", reject);
+    });
+
+  let header = `${organizationName || "Organization"} — Chat Export\n`;
+  header += `Total messages: ${messages.length.toLocaleString()} | Contacts: ${uniqueContacts}\n`;
+  header += `Exported: ${new Date().toLocaleString("en-ZA", { timeZone: "Africa/Johannesburg" })}\n`;
+  header += `${"=".repeat(60)}\n\n`;
+  await write(header);
+
+  for (const [waId, msgs] of Object.entries(grouped)) {
+    let chunk = `--- ${waId} ---\n`;
+    for (const msg of msgs) {
+      const date = msg.created_at
+        ? new Date(msg.created_at).toLocaleString("en-ZA", { timeZone: "Africa/Johannesburg" })
+        : "unknown";
+      const label = getSenderLabel(msg.sender_type || "");
+      let line = `[${date}] (${label}) ${msg.message || ""}`;
+      if (msg.media_url) line += ` [Media: ${msg.media_type || "file"} - ${msg.media_url}]`;
+      if (msg.voice_note_transcription) line += ` [Voice: ${msg.voice_note_transcription}]`;
+      chunk += `${line}\n`;
+    }
+    chunk += `\n`;
+    await write(chunk);
+  }
+
+  await new Promise((resolve, reject) => out.end((err) => (err ? reject(err) : resolve())));
+
+  const secs = ((Date.now() - t0) / 1000).toFixed(1);
+  console.log(`\nDone in ${secs}s`);
+  console.log(`  total messages: ${messages.length.toLocaleString()}`);
+  console.log(`  groups:         ${uniqueContacts}`);
+  console.log(`  file:           ${outPath}`);
+}

package/src/commands/flowmod.js

@@ -0,0 +1,130 @@
+// `flowiq flowmod pull <organization_id>` /
+// `flowiq flowmod push <slug>`.
+// Round-trips an org's FlowMod master-group prompts + config (the
+// flowmod_master_groups + flowmod_prompts tables) through a local JSON file.
+// No DB credentials on disk — all privileged work happens server-side in
+// /api/cli/flowmod.
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { http } from "../http.js";
+
+const FLOWMOD_DIR = path.resolve(process.cwd(), ".flowiq", "flowmod");
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+function slugify(name, fallback) {
+  const s = String(name || "")
+    .toLowerCase()
+    .replace(/&/g, "and")
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+  return s || fallback;
+}
+
+async function fileExists(p) {
+  try { await fs.access(p); return true; } catch { return false; }
+}
+
+async function resolvePushPath(identifier) {
+  const candidates = [];
+  if (path.isAbsolute(identifier)) {
+    candidates.push(identifier);
+  } else if (identifier.includes("/") || identifier.includes("\\")) {
+    candidates.push(path.resolve(identifier));
+  } else {
+    const base = identifier.endsWith(".json") ? identifier : `${identifier}.json`;
+    candidates.push(path.join(FLOWMOD_DIR, base));
+    candidates.push(path.resolve(base));
+  }
+  for (const c of candidates) {
+    if (await fileExists(c)) return c;
+  }
+  throw new Error(`File not found. Tried:\n  ${candidates.join("\n  ")}`);
+}
+
+function mainPromptChars(mg) {
+  const prompts = mg.prompts || [];
+  // Prefer the master-level main (no group_ids); fall back to any main prompt
+  // (some master_groups pin their main prompt to specific group_ids).
+  const main =
+    prompts.find((p) => p.type === "main" && (!Array.isArray(p.group_ids) || p.group_ids.length === 0)) ||
+    prompts.find((p) => p.type === "main");
+  return main ? (main.text || "").length : 0;
+}
+
+export async function pull(orgId) {
+  if (!UUID_RE.test(orgId)) {
+    console.error(`Error: "${orgId}" is not a valid organization UUID.`);
+    process.exit(1);
+  }
+  let resp;
+  try {
+    resp = await http.get("flowmod", { organization_id: orgId });
+  } catch (e) {
+    console.error(`Pull failed: ${e.message}`);
+    process.exit(1);
+  }
+
+  await fs.mkdir(FLOWMOD_DIR, { recursive: true });
+  const slug = slugify(resp.organization_name, resp.organization_id);
+  const filePath = path.join(FLOWMOD_DIR, `${slug}.json`);
+  const overwriting = await fileExists(filePath);
+  await fs.writeFile(filePath, JSON.stringify(resp, null, 2) + "\n", "utf8");
+
+  const totalPrompts = (resp.master_groups || []).reduce((a, mg) => a + (mg.prompts?.length ?? 0), 0);
+  console.log(`${overwriting ? "Overwrote" : "Wrote"} ${filePath}`);
+  console.log(`  org:           ${resp.organization_name} (${resp.organization_id})`);
+  console.log(`  master_groups: ${resp.master_groups?.length ?? 0} (${totalPrompts} prompt rows)`);
+  for (const mg of resp.master_groups || []) {
+    const cfg = mg.config || {};
+    const cfgBits = [
+      cfg.model && `model=${cfg.model}`,
+      cfg.reasoningEffort && `effort=${cfg.reasoningEffort}`,
+      Array.isArray(mg.custom_tools) && mg.custom_tools.length ? `${mg.custom_tools.length} tools` : null,
+    ].filter(Boolean).join(", ");
+    console.log(`    • ${mg.name}: main=${mainPromptChars(mg)} chars${cfgBits ? `  (${cfgBits})` : ""}`);
+  }
+}
+
+export async function push(identifier) {
+  let filePath;
+  try {
+    filePath = await resolvePushPath(identifier);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    process.exit(1);
+  }
+  const raw = await fs.readFile(filePath, "utf8");
+  let data;
+  try { data = JSON.parse(raw); }
+  catch (e) {
+    console.error(`Invalid JSON in ${filePath}: ${e.message}`);
+    process.exit(1);
+  }
+
+  if (!data.organization_id || !UUID_RE.test(data.organization_id)) {
+    console.error(`${filePath}: organization_id missing or invalid`);
+    process.exit(1);
+  }
+  if (!Array.isArray(data.master_groups) || data.master_groups.length === 0) {
+    console.error(`${filePath}: master_groups must be a non-empty array`);
+    process.exit(1);
+  }
+
+  let resp;
+  try {
+    resp = await http.post("flowmod", {
+      organization_id: data.organization_id,
+      master_groups: data.master_groups,
+    });
+  } catch (e) {
+    console.error(`Push failed: ${e.message}`);
+    process.exit(1);
+  }
+
+  console.log(`Pushed ${filePath}`);
+  console.log(`  org:           ${resp.organization_name} (${resp.organization_id})`);
+  console.log(`  master_groups: ${resp.master_groups_updated} updated`);
+  console.log(`  prompts:       ${resp.prompts_updated} updated`);
+}