@dzhng/crm.cli 0.2.0 → 0.3.1

package/README.md

@@ -4,7 +4,7 @@
 
 **A headless, CLI-first CRM for developers who do sales.** Contacts, deals, and pipeline in a single SQLite file — queryable from your terminal, composable with Unix tools, and mountable as a virtual filesystem so any tool that reads files (Claude Code, Codex, grep, jq, vim) has full CRM access without any integration.
 
-No server. No Docker. No accounts. No GUI. Just `bun install -g @dzhng/crm.cli` and go.
+No server. No Docker. No accounts. No GUI. Just `npm install -g @dzhng/crm.cli` and go.
 
 > **Sponsored by [Duet](https://duet.so)** — a cloud agent workspace with persistent AI. Set up crm.cli in your own private cloud computer and run it with Claude Code or Codex — no local setup required. [Try Duet →](https://duet.so)
 
@@ -44,11 +44,8 @@ crm dupes --threshold 0.5
 ## Install
 
 ```bash
-# Install globally via bun (recommended)
-bun install -g @dzhng/crm.cli
-
-# Or npx without installing
-bunx @dzhng/crm.cli contact list
+npm install -g @dzhng/crm.cli
+# or: bun install -g @dzhng/crm.cli
 
 # Or install the compiled binary
 curl -fsSL https://raw.githubusercontent.com/dzhng/crm.cli/main/install.sh | sh
@@ -1224,10 +1221,20 @@ max_recent_activity = 10        # how many activities to inline in entity files
 search_limit = 20               # max results for search/ virtual files
 ```
 
+### How Mount Works
+
+`crm mount` starts two background processes:
+
+1. **Daemon** (`crm __daemon`) — a Unix socket server that handles all business logic (reads, writes, search, validation, normalization). The `crm` binary spawns itself with a hidden `__daemon` subcommand, so this works identically whether installed via npm, compiled binary, or running from source during development.
+
+2. **Filesystem bridge** — connects the OS filesystem layer to the daemon:
+   - **macOS:** An NFS v3 server (Rust binary, auto-compiled on first mount via Cargo) that translates NFS operations to daemon socket calls. Mounted via `mount_nfs`.
+   - **Linux:** A FUSE helper (C binary, auto-compiled on first mount via gcc) that translates FUSE syscalls to daemon socket calls.
+
 ### Platform Notes
 
-- **Linux:** Works out of the box (FUSE is in the kernel).
-- **macOS:** Requires [FUSE-T](https://www.fuse-t.org/) (`brew install fuse-t`, recommended) or [macFUSE](https://osxfuse.github.io/) (`brew install --cask macfuse`).
+- **Linux:** Works out of the box (FUSE is in the kernel). Requires `libfuse3-dev` and `gcc`.
+- **macOS:** Requires Rust toolchain for the NFS server (`curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh`). No FUSE or kernel extensions needed.
 - **Windows:** Not supported (use WSL).
 - **Containers/sandboxes:** FUSE requires `--privileged` or `--device /dev/fuse`. If unavailable, use the CLI with `--format json` instead.
 
@@ -1250,15 +1257,8 @@ search_limit = 20               # max results for search/ virtual files
 ### Package Manager
 
 ```bash
-# Install globally via bun (recommended)
-bun install -g @dzhng/crm.cli
-
-# Or via npm
 npm install -g @dzhng/crm.cli
-
-# Or use without installing
-bunx @dzhng/crm.cli contact list
-npx @dzhng/crm.cli contact list
+# or: bun install -g @dzhng/crm.cli
 ```
 
 ### Compiled Binary

package/dist/cli.js

@@ -3255,6 +3255,13 @@ function ensureDir2(dir) {
     mkdirSync4(dir, { recursive: true });
   }
 }
+function getDaemonArgs() {
+  const script = process.argv[1];
+  if (script && /\.[tj]s$/.test(script)) {
+    return [script];
+  }
+  return [];
+}
 async function mountDarwin(mp, config, _opts) {
   const nfsHelperPath = join3(homedir2(), ".crm", "bin", "crm-nfs");
   if (!existsSync3(nfsHelperPath)) {
@@ -3280,10 +3287,9 @@ ${compile.stderr?.toString() || ""}`);
     ]);
   }
   const socketPath = join3(tmpdir(), `crm-fuse-${slugify(mp)}.sock`);
-  const daemonPath = join3(import.meta.dir, "..", "fuse-daemon.ts");
-  const daemonProc = spawn("bun", [
-    "run",
-    daemonPath,
+  const daemonProc = spawn(process.execPath, [
+    ...getDaemonArgs(),
+    "__daemon",
     socketPath,
     config.database.path,
     ...config.pipeline.stages
@@ -3389,10 +3395,9 @@ ${compile.stderr?.toString() || ""}`);
     }
   }
   const socketPath = join3(tmpdir(), `crm-fuse-${slugify(mp)}.sock`);
-  const daemonPath = join3(import.meta.dir, "..", "fuse-daemon.ts");
-  const daemonProc = spawn("bun", [
-    "run",
-    daemonPath,
+  const daemonProc = spawn(process.execPath, [
+    ...getDaemonArgs(),
+    "__daemon",
     socketPath,
     config.database.path,
     ...config.pipeline.stages
@@ -4260,9 +4265,1162 @@ async function tagList(opts) {
   }
 }
 
+// src/fuse-daemon.ts
+import { existsSync as existsSync4, unlinkSync as unlinkSync2 } from "node:fs";
+import { createServer } from "node:net";
+import { eq as eq13 } from "drizzle-orm";
+import { ulid as ulid2 } from "ulid";
+function makeId2(prefix) {
+  return `${prefix}_${ulid2()}`;
+}
+function extractId(filename) {
+  const dots = filename.indexOf("...");
+  if (dots === -1) {
+    return null;
+  }
+  return filename.slice(0, dots);
+}
+function stripJsonExt(s) {
+  return s.endsWith(".json") ? s.slice(0, -5) : s;
+}
+function extractCompanyId(val) {
+  if (typeof val === "object" && val !== null && "id" in val) {
+    return val.id;
+  }
+  return val;
+}
+var CONTACT_WRITE_FIELDS = new Set([
+  "id",
+  "name",
+  "emails",
+  "email",
+  "phones",
+  "phone",
+  "linkedin",
+  "x",
+  "bluesky",
+  "telegram",
+  "companies",
+  "company",
+  "tags",
+  "custom_fields",
+  "created_at",
+  "updated_at",
+  "title",
+  "department",
+  "source",
+  "notes",
+  "address",
+  "birthday",
+  "website",
+  "job_title",
+  "role",
+  "position",
+  "deals",
+  "recent_activity"
+]);
+var COMPANY_WRITE_FIELDS = new Set([
+  "id",
+  "name",
+  "websites",
+  "website",
+  "phones",
+  "phone",
+  "tags",
+  "custom_fields",
+  "created_at",
+  "updated_at",
+  "industry",
+  "address",
+  "notes",
+  "source",
+  "description",
+  "size",
+  "contacts",
+  "deals"
+]);
+var DEAL_WRITE_FIELDS = new Set([
+  "id",
+  "title",
+  "value",
+  "stage",
+  "contacts",
+  "company",
+  "expected_close",
+  "probability",
+  "tags",
+  "custom_fields",
+  "created_at",
+  "updated_at",
+  "stage_history"
+]);
+var ACTIVITY_WRITE_FIELDS = new Set([
+  "id",
+  "type",
+  "body",
+  "note",
+  "contacts",
+  "contact",
+  "company",
+  "deal",
+  "entity_ref",
+  "custom_fields",
+  "created_at"
+]);
+var KNOWN_REPORTS = new Set([
+  "pipeline.json",
+  "stale.json",
+  "forecast.json",
+  "conversion.json",
+  "velocity.json",
+  "won.json",
+  "lost.json"
+]);
+async function handleRequest(db, config, stages, req) {
+  const { op, path } = req;
+  const p = path.startsWith("/") ? path.slice(1) : path;
+  switch (op) {
+    case "getattr":
+      return await handleGetattr(db, config, p, stages);
+    case "readdir":
+      return await handleReaddir(db, p, stages);
+    case "read":
+      return await handleRead(db, config, p, stages);
+    case "write":
+      return await handleWrite(db, config, p, req.data || "");
+    case "unlink":
+      return await handleUnlink(db, p);
+    default:
+      return { error: "ENOSYS" };
+  }
+}
+async function handleGetattr(db, config, p, stages) {
+  const result = await _handleGetattr(db, p, stages);
+  if (result.type === "file") {
+    const readResult = await handleRead(db, config, p, stages);
+    if ("data" in readResult && typeof readResult.data === "string") {
+      return { type: "file", size: Buffer.byteLength(readResult.data, "utf-8") };
+    }
+  }
+  return result;
+}
+async function _handleGetattr(db, p, stages) {
+  if (p === "") {
+    return { type: "dir" };
+  }
+  if ([
+    "contacts",
+    "companies",
+    "deals",
+    "activities",
+    "reports",
+    "search"
+  ].includes(p)) {
+    return { type: "dir" };
+  }
+  if (p === "pipeline.json" || p === "tags.json") {
+    return { type: "file" };
+  }
+  const parts = p.split("/");
+  if (parts.length === 2) {
+    const [dir, file] = parts;
+    if (["contacts", "companies", "deals", "activities"].includes(dir) && file.endsWith(".json")) {
+      const id = extractId(file);
+      if (id) {
+        const exists = await entityExists(db, dir, id);
+        return exists ? { type: "file" } : { error: "ENOENT" };
+      }
+      return { type: "file" };
+    }
+    if (file.startsWith("_by-")) {
+      return { type: "dir" };
+    }
+    if (dir === "reports") {
+      if (KNOWN_REPORTS.has(file)) {
+        return { type: "file" };
+      }
+      return { error: "ENOENT" };
+    }
+    if (dir === "search" && file.endsWith(".json")) {
+      return { type: "file" };
+    }
+  }
+  if (parts.length === 3) {
+    const [dir, byDir, item] = parts;
+    if (dir === "contacts" && byDir === "_by-tag") {
+      const exists = await tagExists(db, item);
+      return exists ? { type: "dir" } : { error: "ENOENT" };
+    }
+    if (dir === "contacts" && byDir === "_by-company") {
+      const exists = await companySlugExists(db, item);
+      return exists ? { type: "dir" } : { error: "ENOENT" };
+    }
+    if (dir === "deals" && byDir === "_by-stage") {
+      return stages.includes(item) ? { type: "dir" } : { error: "ENOENT" };
+    }
+    if (item.endsWith(".json")) {
+      const val = stripJsonExt(item);
+      const exists = await byIndexExists(db, dir, byDir, val);
+      return exists ? { type: "file" } : { error: "ENOENT" };
+    }
+  }
+  if (parts.length === 4 && parts[0] === "deals" && parts[1] === "_by-stage" && parts[3].endsWith(".json")) {
+    const id = extractId(parts[3]);
+    if (id) {
+      const exists = await entityExists(db, "deals", id);
+      return exists ? { type: "file" } : { error: "ENOENT" };
+    }
+  }
+  if (parts.length === 4 && parts[0] === "contacts" && parts[1].startsWith("_by-") && parts[3].endsWith(".json")) {
+    const id = extractId(parts[3]);
+    if (id) {
+      const exists = await entityExists(db, "contacts", id);
+      return exists ? { type: "file" } : { error: "ENOENT" };
+    }
+  }
+  return { error: "ENOENT" };
+}
+async function entityExists(db, entityDir, id) {
+  switch (entityDir) {
+    case "contacts": {
+      const r = await db.select({ id: contacts.id }).from(contacts).where(eq13(contacts.id, id));
+      return r.length > 0;
+    }
+    case "companies": {
+      const r = await db.select({ id: companies.id }).from(companies).where(eq13(companies.id, id));
+      return r.length > 0;
+    }
+    case "deals": {
+      const r = await db.select({ id: deals.id }).from(deals).where(eq13(deals.id, id));
+      return r.length > 0;
+    }
+    case "activities": {
+      const r = await db.select({ id: activities.id }).from(activities).where(eq13(activities.id, id));
+      return r.length > 0;
+    }
+    default:
+      return false;
+  }
+}
+async function tagExists(db, tag) {
+  const contacts2 = await db.select({ tags: contacts.tags }).from(contacts);
+  for (const c of contacts2) {
+    const tags = safeJSON(c.tags);
+    if (tags.includes(tag)) {
+      return true;
+    }
+  }
+  const companies2 = await db.select({ tags: companies.tags }).from(companies);
+  for (const co of companies2) {
+    const tags = safeJSON(co.tags);
+    if (tags.includes(tag)) {
+      return true;
+    }
+  }
+  const deals2 = await db.select({ tags: deals.tags }).from(deals);
+  for (const d of deals2) {
+    const tags = safeJSON(d.tags);
+    if (tags.includes(tag)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function companySlugExists(db, slug) {
+  const allCompanies = await db.select().from(companies);
+  const contacts2 = await db.select({ companies: contacts.companies }).from(contacts);
+  for (const c of contacts2) {
+    const companyIds = safeJSON(c.companies);
+    for (const compId of companyIds) {
+      const co = allCompanies.find((x) => x.id === compId);
+      if (co && slugify(co.name) === slug) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+async function byIndexExists(db, dir, byDir, val) {
+  if (dir === "contacts") {
+    if (byDir === "_by-email") {
+      const all = await db.select().from(contacts);
+      return all.some((c) => safeJSON(c.emails).includes(val));
+    }
+    if (byDir === "_by-phone") {
+      const all = await db.select().from(contacts);
+      return all.some((c) => safeJSON(c.phones).includes(val));
+    }
+    if (byDir === "_by-linkedin") {
+      const all = await db.select().from(contacts).where(eq13(contacts.linkedin, val));
+      return all.length > 0;
+    }
+    if (byDir === "_by-x") {
+      const all = await db.select().from(contacts).where(eq13(contacts.x, val));
+      return all.length > 0;
+    }
+    if (byDir === "_by-bluesky") {
+      const all = await db.select().from(contacts).where(eq13(contacts.bluesky, val));
+      return all.length > 0;
+    }
+    if (byDir === "_by-telegram") {
+      const all = await db.select().from(contacts).where(eq13(contacts.telegram, val));
+      return all.length > 0;
+    }
+  }
+  if (dir === "companies") {
+    if (byDir === "_by-website") {
+      const all = await db.select().from(companies);
+      return all.some((co) => safeJSON(co.websites).includes(val));
+    }
+    if (byDir === "_by-phone") {
+      const all = await db.select().from(companies);
+      return all.some((co) => safeJSON(co.phones).includes(val));
+    }
+  }
+  return false;
+}
+async function handleReaddir(db, p, stages) {
+  if (p === "") {
+    return {
+      entries: [
+        "llm.txt",
+        "contacts",
+        "companies",
+        "deals",
+        "activities",
+        "reports",
+        "search",
+        "pipeline.json",
+        "tags.json"
+      ]
+    };
+  }
+  if (p === "contacts") {
+    const contacts2 = await db.select().from(contacts);
+    const files = contacts2.map((c) => `${c.id}...${slugify(c.name || "")}.json`);
+    return {
+      entries: [
+        "_by-email",
+        "_by-phone",
+        "_by-linkedin",
+        "_by-x",
+        "_by-bluesky",
+        "_by-telegram",
+        "_by-company",
+        "_by-tag",
+        ...files
+      ]
+    };
+  }
+  if (p === "companies") {
+    const companies2 = await db.select().from(companies);
+    const files = companies2.map((co) => `${co.id}...${slugify(co.name || "")}.json`);
+    return {
+      entries: ["_by-website", "_by-phone", "_by-tag", ...files]
+    };
+  }
+  if (p === "deals") {
+    const deals2 = await db.select().from(deals);
+    const files = deals2.map((d) => `${d.id}...${slugify(d.title || "")}.json`);
+    return {
+      entries: ["_by-stage", "_by-company", "_by-tag", ...files]
+    };
+  }
+  if (p === "activities") {
+    return {
+      entries: ["_by-contact", "_by-company", "_by-deal", "_by-type"]
+    };
+  }
+  if (p === "reports") {
+    return {
+      entries: [
+        "pipeline.json",
+        "stale.json",
+        "forecast.json",
+        "conversion.json",
+        "velocity.json",
+        "won.json",
+        "lost.json"
+      ]
+    };
+  }
+  if (p === "search") {
+    return { entries: [] };
+  }
+  if (p === "deals/_by-stage") {
+    return { entries: stages };
+  }
+  if (p.startsWith("deals/_by-stage/")) {
+    const stage = p.slice("deals/_by-stage/".length);
+    if (!stage.includes("/")) {
+      const deals2 = await db.select().from(deals).where(eq13(deals.stage, stage));
+      return {
+        entries: deals2.map((d) => `${d.id}...${slugify(d.title || "")}.json`)
+      };
+    }
+  }
+  if (p === "contacts/_by-email") {
+    const all = await db.select().from(contacts);
+    const entries = [];
+    for (const c of all) {
+      for (const e of safeJSON(c.emails)) {
+        entries.push(`${e}.json`);
+      }
+    }
+    return { entries };
+  }
+  if (p === "contacts/_by-phone") {
+    const all = await db.select().from(contacts);
+    const entries = [];
+    for (const c of all) {
+      for (const ph of safeJSON(c.phones)) {
+        entries.push(`${ph}.json`);
+      }
+    }
+    return { entries };
+  }
+  for (const field of ["linkedin", "x", "bluesky", "telegram"]) {
+    if (p === `contacts/_by-${field}`) {
+      const all = await db.select().from(contacts);
+      const entries = all.filter((c) => c[field]).map((c) => `${c[field]}.json`);
+      return { entries };
+    }
+  }
+  if (p === "contacts/_by-tag") {
+    const all = await db.select().from(contacts);
+    const tagSet = new Set;
+    for (const c of all) {
+      for (const t of safeJSON(c.tags)) {
+        tagSet.add(t);
+      }
+    }
+    return { entries: [...tagSet] };
+  }
+  if (p.startsWith("contacts/_by-tag/")) {
+    const tag = p.slice("contacts/_by-tag/".length);
+    if (!tag.includes("/")) {
+      const all = await db.select().from(contacts);
+      const entries = all.filter((c) => safeJSON(c.tags).includes(tag)).map((c) => `${c.id}...${slugify(c.name || "")}.json`);
+      return { entries };
+    }
+  }
+  if (p === "contacts/_by-company") {
+    const allContacts = await db.select().from(contacts);
+    const allCompanies = await db.select().from(companies);
+    const slugSet = new Set;
+    for (const c of allContacts) {
+      for (const compId of safeJSON(c.companies)) {
+        const co = allCompanies.find((x) => x.id === compId);
+        if (co) {
+          slugSet.add(slugify(co.name));
+        }
+      }
+    }
+    return { entries: [...slugSet] };
+  }
+  if (p.startsWith("contacts/_by-company/")) {
+    const cslug = p.slice("contacts/_by-company/".length);
+    if (!cslug.includes("/")) {
+      const allContacts = await db.select().from(contacts);
+      const allCompanies = await db.select().from(companies);
+      const entries = allContacts.filter((c) => {
+        const compIds = safeJSON(c.companies);
+        return compIds.some((compId) => {
+          const co = allCompanies.find((x) => x.id === compId);
+          return co && slugify(co.name) === cslug;
+        });
+      }).map((c) => `${c.id}...${slugify(c.name || "")}.json`);
+      return { entries };
+    }
+  }
+  if (p === "companies/_by-website") {
+    const all = await db.select().from(companies);
+    const entries = [];
+    for (const co of all) {
+      for (const w of safeJSON(co.websites)) {
+        entries.push(`${w}.json`);
+      }
+    }
+    return { entries };
+  }
+  if (p === "companies/_by-phone") {
+    const all = await db.select().from(companies);
+    const entries = [];
+    for (const co of all) {
+      for (const ph of safeJSON(co.phones)) {
+        entries.push(`${ph}.json`);
+      }
+    }
+    return { entries };
+  }
+  if (p === "companies/_by-tag") {
+    const all = await db.select().from(companies);
+    const tagSet = new Set;
+    for (const co of all) {
+      for (const t of safeJSON(co.tags)) {
+        tagSet.add(t);
+      }
+    }
+    return { entries: [...tagSet] };
+  }
+  return { error: "ENOENT" };
+}
+async function handleRead(db, config, p, stages) {
+  if (p === "llm.txt") {
+    return { data: LLM_TXT };
+  }
+  if (p === "pipeline.json" || p === "reports/pipeline.json") {
+    const deals2 = await db.select().from(deals);
+    const data = stages.map((stage) => ({
+      stage,
+      count: deals2.filter((d) => d.stage === stage).length,
+      value: deals2.filter((d) => d.stage === stage).reduce((s, d) => s + (d.value || 0), 0)
+    }));
+    return { data: JSON.stringify(data) };
+  }
+  if (p === "tags.json") {
+    const tagCounts = {};
+    const contacts2 = await db.select().from(contacts);
+    for (const c of contacts2) {
+      for (const t of safeJSON(c.tags)) {
+        tagCounts[t] = (tagCounts[t] || 0) + 1;
+      }
+    }
+    const companies2 = await db.select().from(companies);
+    for (const co of companies2) {
+      for (const t of safeJSON(co.tags)) {
+        tagCounts[t] = (tagCounts[t] || 0) + 1;
+      }
+    }
+    const deals2 = await db.select().from(deals);
+    for (const d of deals2) {
+      for (const t of safeJSON(d.tags)) {
+        tagCounts[t] = (tagCounts[t] || 0) + 1;
+      }
+    }
+    const data = Object.entries(tagCounts).map(([tag, count]) => ({
+      tag,
+      count
+    }));
+    return { data: JSON.stringify(data) };
+  }
+  if (p === "reports/stale.json") {
+    const data = await computeStale(db, config);
+    return { data: JSON.stringify(data) };
+  }
+  if (p === "reports/conversion.json") {
+    const data = await computeConversion(db, stages);
+    return { data: JSON.stringify(data) };
+  }
+  if (p === "reports/velocity.json") {
+    const data = await computeVelocity(db, stages);
+    return { data: JSON.stringify(data) };
+  }
+  if (p === "reports/forecast.json") {
+    const data = await computeForecast(db, config);
+    return { data: JSON.stringify(data) };
+  }
+  if (p === "reports/won.json") {
+    const data = await computeWon(db, config);
+    return { data: JSON.stringify(data) };
+  }
+  if (p === "reports/lost.json") {
+    const data = await computeLost(db, config);
+    return { data: JSON.stringify(data) };
+  }
+  if (p.startsWith("search/") && p.endsWith(".json")) {
+    const query = stripJsonExt(p.slice("search/".length));
+    return handleSearch(db, query);
+  }
+  if (p.startsWith("contacts/")) {
+    return readContactPath(db, config, p.slice("contacts/".length));
+  }
+  if (p.startsWith("companies/")) {
+    return readCompanyPath(db, p.slice("companies/".length));
+  }
+  if (p.startsWith("deals/")) {
+    return readDealPath(db, p.slice("deals/".length));
+  }
+  if (p.startsWith("activities/")) {
+    return readActivityPath(db, p.slice("activities/".length));
+  }
+  return { error: "ENOENT" };
+}
+async function readContactPath(db, config, sub) {
+  if (sub.startsWith("_by-email/")) {
+    const email = stripJsonExt(sub.slice("_by-email/".length));
+    const all = await db.select().from(contacts);
+    const c = all.find((x) => safeJSON(x.emails).includes(email));
+    if (!c) {
+      return { error: "ENOENT" };
+    }
+    return { data: JSON.stringify(await buildContactJSON(db, c, config)) };
+  }
+  if (sub.startsWith("_by-phone/")) {
+    const phone = stripJsonExt(sub.slice("_by-phone/".length));
+    const all = await db.select().from(contacts);
+    const c = all.find((x) => safeJSON(x.phones).includes(phone));
+    if (!c) {
+      return { error: "ENOENT" };
+    }
+    return { data: JSON.stringify(await buildContactJSON(db, c, config)) };
+  }
+  for (const field of ["linkedin", "x", "bluesky", "telegram"]) {
+    if (sub.startsWith(`_by-${field}/`)) {
+      const handle = stripJsonExt(sub.slice(`_by-${field}/`.length));
+      const results = await db.select().from(contacts).where(eq13(contacts[field], handle));
+      if (!results[0]) {
+        return { error: "ENOENT" };
+      }
+      return {
+        data: JSON.stringify(await buildContactJSON(db, results[0], config))
+      };
+    }
+  }
+  if (sub.startsWith("_by-tag/") || sub.startsWith("_by-company/")) {
+    const lastSlash = sub.lastIndexOf("/");
+    const file = sub.slice(lastSlash + 1);
+    const id2 = extractId(file);
+    if (id2) {
+      const results = await db.select().from(contacts).where(eq13(contacts.id, id2));
+      if (!results[0]) {
+        return { error: "ENOENT" };
+      }
+      return {
+        data: JSON.stringify(await buildContactJSON(db, results[0], config))
+      };
+    }
+  }
+  const id = extractId(sub);
+  if (id) {
+    const results = await db.select().from(contacts).where(eq13(contacts.id, id));
+    if (!results[0]) {
+      return { error: "ENOENT" };
+    }
+    return {
+      data: JSON.stringify(await buildContactJSON(db, results[0], config))
+    };
+  }
+  return { error: "ENOENT" };
+}
+async function readCompanyPath(db, sub) {
+  if (sub.startsWith("_by-website/")) {
+    const website = stripJsonExt(sub.slice("_by-website/".length));
+    const all = await db.select().from(companies);
+    const co = all.find((x) => safeJSON(x.websites).includes(website));
+    if (!co) {
+      return { error: "ENOENT" };
+    }
+    return { data: JSON.stringify(await buildCompanyJSON(db, co)) };
+  }
+  if (sub.startsWith("_by-phone/")) {
+    const phone = stripJsonExt(sub.slice("_by-phone/".length));
+    const all = await db.select().from(companies);
+    const co = all.find((x) => safeJSON(x.phones).includes(phone));
+    if (!co) {
+      return { error: "ENOENT" };
+    }
+    return { data: JSON.stringify(await buildCompanyJSON(db, co)) };
+  }
+  const id = extractId(sub);
+  if (id) {
+    const results = await db.select().from(companies).where(eq13(companies.id, id));
+    if (!results[0]) {
+      return { error: "ENOENT" };
+    }
+    return { data: JSON.stringify(await buildCompanyJSON(db, results[0])) };
+  }
+  return { error: "ENOENT" };
+}
+async function readDealPath(db, sub) {
+  if (sub.startsWith("_by-stage/")) {
+    const rest = sub.slice("_by-stage/".length);
+    const slash = rest.indexOf("/");
+    if (slash !== -1) {
+      const file = rest.slice(slash + 1);
+      const id2 = extractId(file);
+      if (id2) {
+        const results = await db.select().from(deals).where(eq13(deals.id, id2));
+        if (!results[0]) {
+          return { error: "ENOENT" };
+        }
+        return { data: JSON.stringify(await buildDealJSON(db, results[0])) };
+      }
+    }
+  }
+  const id = extractId(sub);
+  if (id) {
+    const results = await db.select().from(deals).where(eq13(deals.id, id));
+    if (!results[0]) {
+      return { error: "ENOENT" };
+    }
+    return { data: JSON.stringify(await buildDealJSON(db, results[0])) };
+  }
+  return { error: "ENOENT" };
+}
+async function readActivityPath(db, sub) {
+  const id = extractId(sub);
+  if (id) {
+    const results = await db.select().from(activities).where(eq13(activities.id, id));
+    if (!results[0]) {
+      return { error: "ENOENT" };
+    }
+    return { data: JSON.stringify(buildActivityJSON(results[0])) };
+  }
+  return { error: "ENOENT" };
+}
+async function handleSearch(db, query) {
+  const contacts2 = await db.select().from(contacts);
+  const companies2 = await db.select().from(companies);
+  const deals2 = await db.select().from(deals);
+  const results = [];
+  for (const c of contacts2) {
+    if (c.name?.includes(query) || safeJSON(c.emails).some((e) => e.includes(query))) {
+      results.push({
+        type: "contact",
+        id: c.id,
+        name: c.name,
+        emails: safeJSON(c.emails)
+      });
+    }
+  }
+  for (const co of companies2) {
+    if (co.name?.includes(query)) {
+      results.push({ type: "company", id: co.id, name: co.name });
+    }
+  }
+  for (const d of deals2) {
+    if (d.title?.includes(query)) {
+      results.push({ type: "deal", id: d.id, title: d.title });
+    }
+  }
+  return { data: JSON.stringify(results) };
+}
+async function handleWrite(db, config, p, rawData) {
+  let data;
+  try {
+    data = JSON.parse(rawData);
+  } catch {
+    return { error: "EINVAL", msg: "malformed JSON" };
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    return { error: "EINVAL", msg: "expected JSON object" };
+  }
+  if (p.startsWith("contacts/")) {
+    return await writeContact(db, config, p.slice("contacts/".length), data);
+  }
+  if (p.startsWith("companies/")) {
+    return await writeCompany(db, config, p.slice("companies/".length), data);
+  }
+  if (p.startsWith("deals/")) {
+    return await writeDeal(db, config, p.slice("deals/".length), data);
+  }
+  if (p.startsWith("activities/")) {
+    return await writeActivity(db, config, p.slice("activities/".length), data);
+  }
+  return { error: "EPERM" };
+}
+async function writeContact(db, config, sub, data) {
+  const customFieldKeys = [];
+  for (const key of Object.keys(data)) {
+    if (!CONTACT_WRITE_FIELDS.has(key)) {
+      return { error: "EINVAL", msg: `unknown field: ${key}` };
+    }
+    if ([
+      "title",
+      "department",
+      "source",
+      "notes",
+      "address",
+      "birthday",
+      "website",
+      "job_title",
+      "role",
+      "position"
+    ].includes(key)) {
+      customFieldKeys.push(key);
+    }
+  }
+  if (data.emails !== undefined && !Array.isArray(data.emails)) {
+    return { error: "EINVAL", msg: "emails must be an array" };
+  }
+  if (data.phones !== undefined && !Array.isArray(data.phones)) {
+    return { error: "EINVAL", msg: "phones must be an array" };
+  }
+  let phones = data.phones || data.phone;
+  if (typeof phones === "string") {
+    phones = [phones];
+  }
+  if (phones && Array.isArray(phones)) {
+    const normalized = [];
+    for (const p of phones) {
+      try {
+        normalized.push(normalizePhone(p, config.phone.default_country));
+      } catch {
+        return { error: "EINVAL", msg: `invalid phone: ${p}` };
+      }
+    }
+    phones = normalized;
+  }
+  const id = extractId(sub);
+  const now2 = new Date().toISOString();
+  let customFields = data.custom_fields || {};
+  for (const key of customFieldKeys) {
+    customFields = { ...customFields, [key]: data[key] };
+  }
+  const cfStr = Object.keys(customFields).length > 0 ? JSON.stringify(customFields) : "{}";
+  let emails = data.emails;
+  if (!emails && data.email) {
+    emails = Array.isArray(data.email) ? data.email : [data.email];
+  }
+  let companies2 = data.companies;
+  if (!companies2 && data.company) {
+    companies2 = Array.isArray(data.company) ? data.company : [data.company];
+  }
+  if (companies2 && Array.isArray(companies2)) {
+    const resolved = [];
+    for (const c of companies2) {
+      if (typeof c === "object" && c !== null && "id" in c) {
+        resolved.push(c.id);
+      } else if (typeof c === "string" && c.startsWith("co_")) {
+        resolved.push(c);
+      } else if (typeof c === "string") {
+        const coId = await getOrCreateCompanyId(db, c);
+        resolved.push(coId);
+      }
+    }
+    companies2 = resolved;
+  }
+  if (id) {
+    const existing = await db.select().from(contacts).where(eq13(contacts.id, id));
+    if (!existing[0]) {
+      return { error: "ENOENT" };
+    }
+    await db.update(contacts).set({
+      name: data.name || existing[0].name,
+      emails: JSON.stringify(emails || safeJSON(existing[0].emails)),
+      phones: JSON.stringify(phones || safeJSON(existing[0].phones)),
+      companies: JSON.stringify(companies2 ?? safeJSON(existing[0].companies)),
+      linkedin: data.linkedin === undefined ? existing[0].linkedin : data.linkedin,
+      x: data.x === undefined ? existing[0].x : data.x,
+      bluesky: data.bluesky === undefined ? existing[0].bluesky : data.bluesky,
+      telegram: data.telegram === undefined ? existing[0].telegram : data.telegram,
+      tags: data.tags === undefined ? existing[0].tags : JSON.stringify(data.tags),
+      custom_fields: cfStr,
+      updated_at: now2
+    }).where(eq13(contacts.id, id));
+    return { ok: true };
+  }
+  if (!data.name) {
+    return { error: "EINVAL", msg: "missing required field: name" };
+  }
+  const newId = makeId2("ct");
+  await db.insert(contacts).values({
+    id: newId,
+    name: data.name,
+    emails: JSON.stringify(emails || []),
+    phones: JSON.stringify(phones || []),
+    companies: JSON.stringify(companies2 || []),
+    linkedin: data.linkedin || null,
+    x: data.x || null,
+    bluesky: data.bluesky || null,
+    telegram: data.telegram || null,
+    tags: JSON.stringify(data.tags || []),
+    custom_fields: cfStr,
+    created_at: now2,
+    updated_at: now2
+  });
+  return { ok: true };
+}
+async function writeCompany(db, config, sub, data) {
+  const customFieldKeys = [];
+  for (const key of Object.keys(data)) {
+    if (!COMPANY_WRITE_FIELDS.has(key)) {
+      return { error: "EINVAL", msg: `unknown field: ${key}` };
+    }
+    if ([
+      "industry",
+      "address",
+      "notes",
+      "source",
+      "description",
+      "size"
+    ].includes(key)) {
+      customFieldKeys.push(key);
+    }
+  }
+  let phones = data.phones || data.phone;
+  if (typeof phones === "string") {
+    phones = [phones];
+  }
+  if (phones && Array.isArray(phones)) {
+    const normalized = [];
+    for (const p of phones) {
+      try {
+        normalized.push(normalizePhone(p, config.phone.default_country));
+      } catch {
+        return { error: "EINVAL", msg: `invalid phone: ${p}` };
+      }
+    }
+    phones = normalized;
+  }
+  let customFields = data.custom_fields || {};
+  for (const key of customFieldKeys) {
+    customFields = { ...customFields, [key]: data[key] };
+  }
+  const cfStr = Object.keys(customFields).length > 0 ? JSON.stringify(customFields) : "{}";
+  let websites = data.websites;
+  if (!websites && data.website) {
+    websites = Array.isArray(data.website) ? data.website : [data.website];
+  }
+  const id = extractId(sub);
+  const now2 = new Date().toISOString();
+  if (id) {
+    const existing = await db.select().from(companies).where(eq13(companies.id, id));
+    if (!existing[0]) {
+      return { error: "ENOENT" };
+    }
+    await db.update(companies).set({
+      name: data.name || existing[0].name,
+      websites: JSON.stringify(websites || safeJSON(existing[0].websites)),
+      phones: JSON.stringify(phones || safeJSON(existing[0].phones)),
+      tags: data.tags === undefined ? existing[0].tags : JSON.stringify(data.tags),
+      custom_fields: cfStr,
+      updated_at: now2
+    }).where(eq13(companies.id, id));
+    return { ok: true };
+  }
+  if (!data.name) {
+    return { error: "EINVAL", msg: "missing required field: name" };
+  }
+  const newId = makeId2("co");
+  await db.insert(companies).values({
+    id: newId,
+    name: data.name,
+    websites: JSON.stringify(websites || []),
+    phones: JSON.stringify(phones || []),
+    tags: JSON.stringify(data.tags || []),
+    custom_fields: cfStr,
+    created_at: now2,
+    updated_at: now2
+  });
+  return { ok: true };
+}
+async function writeDeal(db, config, sub, data) {
+  for (const key of Object.keys(data)) {
+    if (!DEAL_WRITE_FIELDS.has(key)) {
+      return { error: "EINVAL", msg: `unknown field: ${key}` };
+    }
+  }
+  const id = extractId(sub);
+  const now2 = new Date().toISOString();
+  if (id) {
+    const existing = await db.select().from(deals).where(eq13(deals.id, id));
+    if (!existing[0]) {
+      return { error: "ENOENT" };
+    }
+    if (data.stage && data.stage !== existing[0].stage) {
+      const acId = makeId2("ac");
+      await db.insert(activities).values({
+        id: acId,
+        type: "stage-change",
+        body: `from ${existing[0].stage} to ${data.stage}`,
+        deal: id,
+        contacts: "[]",
+        company: null,
+        custom_fields: "{}",
+        created_at: now2
+      });
+    }
+    await db.update(deals).set({
+      title: data.title || existing[0].title,
+      value: data.value === undefined ? existing[0].value : data.value,
+      stage: data.stage || existing[0].stage,
+      contacts: data.contacts === undefined ? existing[0].contacts : JSON.stringify(Array.isArray(data.contacts) ? data.contacts.map((c) => typeof c === "object" && c !== null && ("id" in c) ? c.id : c) : data.contacts),
+      company: data.company === undefined ? existing[0].company : extractCompanyId(data.company),
+      expected_close: data.expected_close === undefined ? existing[0].expected_close : data.expected_close,
+      probability: data.probability === undefined ? existing[0].probability : data.probability,
+      tags: data.tags === undefined ? existing[0].tags : JSON.stringify(data.tags),
+      custom_fields: data.custom_fields === undefined ? existing[0].custom_fields : JSON.stringify(data.custom_fields),
+      updated_at: now2
+    }).where(eq13(deals.id, id));
+    return { ok: true };
+  }
+  if (!data.title) {
+    return { error: "EINVAL", msg: "missing required field: title" };
+  }
+  const newId = makeId2("dl");
+  await db.insert(deals).values({
+    id: newId,
+    title: data.title,
+    value: data.value || null,
+    stage: data.stage || config.pipeline.stages[0] || "lead",
+    contacts: JSON.stringify(data.contacts || []),
+    company: data.company || null,
+    expected_close: data.expected_close || null,
+    probability: data.probability || null,
+    tags: JSON.stringify(data.tags || []),
+    custom_fields: JSON.stringify(data.custom_fields || {}),
+    created_at: now2,
+    updated_at: now2
+  });
+  return { ok: true };
+}
+async function writeActivity(db, config, _sub, data) {
+  for (const key of Object.keys(data)) {
+    if (!ACTIVITY_WRITE_FIELDS.has(key)) {
+      return { error: "EINVAL", msg: `unknown field: ${key}` };
+    }
+  }
+  if (!data.type) {
+    return { error: "EINVAL", msg: "missing required field: type" };
+  }
+  const contacts2 = [];
+  if (data.contacts && Array.isArray(data.contacts)) {
+    contacts2.push(...data.contacts);
+  } else if (data.contact) {
+    contacts2.push(data.contact);
+  }
+  if (data.entity_ref && contacts2.length === 0) {
+    const resolved = await resolveContact(db, data.entity_ref, config);
+    if (resolved) {
+      contacts2.push(resolved.id);
+    }
+  }
+  const body = data.note || data.body || "";
+  const now2 = new Date().toISOString();
+  const newId = makeId2("ac");
+  await db.insert(activities).values({
+    id: newId,
+    type: data.type,
+    body,
+    contacts: JSON.stringify(contacts2),
+    company: data.company || null,
+    deal: data.deal || null,
+    custom_fields: JSON.stringify(data.custom_fields || {}),
+    created_at: now2
+  });
+  return { ok: true };
+}
+async function handleUnlink(db, p) {
+  if (p.startsWith("contacts/_by-") || p.startsWith("companies/_by-") || p.startsWith("deals/_by-")) {
+    return { error: "EPERM" };
+  }
+  if (p.startsWith("contacts/")) {
+    const file = p.slice("contacts/".length);
+    const id = extractId(file);
+    if (id) {
+      await db.delete(contacts).where(eq13(contacts.id, id));
+      await removeSearchIndex(db, id);
+      return { ok: true };
+    }
+  }
+  if (p.startsWith("companies/")) {
+    const file = p.slice("companies/".length);
+    const id = extractId(file);
+    if (id) {
+      await db.delete(companies).where(eq13(companies.id, id));
+      await removeSearchIndex(db, id);
+      return { ok: true };
+    }
+  }
+  if (p.startsWith("deals/")) {
+    const file = p.slice("deals/".length);
+    const id = extractId(file);
+    if (id) {
+      await db.delete(deals).where(eq13(deals.id, id));
+      await removeSearchIndex(db, id);
+      return { ok: true };
+    }
+  }
+  if (p.startsWith("activities/")) {
+    const file = p.slice("activities/".length);
+    const id = extractId(file);
+    if (id) {
+      await db.delete(activities).where(eq13(activities.id, id));
+      await removeSearchIndex(db, id);
+      return { ok: true };
+    }
+  }
+  return { error: "EPERM" };
+}
+async function startDaemon(daemonArgs) {
+  if (daemonArgs.length < 2) {
+    console.error("Usage: crm __daemon <socket-path> <db-path> [stage1 stage2 ...]");
+    process.exit(1);
+  }
+  const socketPath = daemonArgs[0];
+  const dbPath = daemonArgs[1];
+  const stages = daemonArgs.slice(2);
+  if (stages.length === 0) {
+    stages.push("lead", "qualified", "proposal", "negotiation", "closed-won", "closed-lost");
+  }
+  if (existsSync4(socketPath)) {
+    unlinkSync2(socketPath);
+  }
+  const db = await openDB(dbPath);
+  const config = loadConfig({ dbPath });
+  config.database.path = dbPath;
+  const server = createServer((conn) => {
+    let buffer = "";
+    conn.on("data", (chunk) => {
+      buffer += chunk.toString();
+      for (;; ) {
+        const newlineIdx = buffer.indexOf(`
+`);
+        if (newlineIdx === -1) {
+          break;
+        }
+        const line = buffer.slice(0, newlineIdx);
+        buffer = buffer.slice(newlineIdx + 1);
+        if (line.trim()) {
+          processLine(conn, db, config, stages, line);
+        }
+      }
+    });
+    conn.on("error", () => {});
+  });
+  server.listen(socketPath, () => {
+    process.stdout.write(`READY
+`);
+  });
+  process.on("SIGTERM", () => {
+    server.close();
+    if (existsSync4(socketPath)) {
+      unlinkSync2(socketPath);
+    }
+    process.exit(0);
+  });
+  process.on("SIGINT", () => {
+    server.close();
+    if (existsSync4(socketPath)) {
+      unlinkSync2(socketPath);
+    }
+    process.exit(0);
+  });
+}
+async function processLine(conn, db, config, stages, line) {
+  try {
+    const req = JSON.parse(line);
+    const resp = await handleRequest(db, config, stages, req);
+    conn.write(`${JSON.stringify(resp)}
+`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    conn.write(`${JSON.stringify({ error: "EIO", msg })}
+`);
+  }
+}
+if (process.argv[1]?.endsWith("fuse-daemon.ts")) {
+  startDaemon(process.argv.slice(2)).catch((err) => {
+    console.error("fuse-daemon fatal:", err);
+    process.exit(1);
+  });
+}
+
 // src/cli.ts
 var program = new Command;
-program.name("crm").description("Headless CLI-first CRM").version("0.1.0");
+program.name("crm").description("Headless CLI-first CRM").version("0.3.1");
 program.exitOverride();
 registerContactCommands(program);
 registerCompanyCommands(program);
@@ -4276,16 +5434,23 @@ registerReportCommands(program);
 registerImportExportCommands(program);
 registerDupesCommand(program);
 registerFuseCommands(program);
-try {
-  program.parse(["node", "crm", ...cleanArgv]);
-} catch (e) {
-  const err = e;
-  if (err.exitCode !== undefined && err.exitCode === 0) {
-    process.exit(0);
-  }
-  if (err.exitCode !== undefined) {
-    process.exit(err.exitCode);
+if (cleanArgv[0] === "__daemon") {
+  startDaemon(cleanArgv.slice(1)).catch((err) => {
+    console.error("fuse-daemon fatal:", err);
+    process.exit(1);
+  });
+} else {
+  try {
+    program.parse(["node", "crm", ...cleanArgv]);
+  } catch (e) {
+    const err = e;
+    if (err.exitCode !== undefined && err.exitCode === 0) {
+      process.exit(0);
+    }
+    if (err.exitCode !== undefined) {
+      process.exit(err.exitCode);
+    }
+    console.error(err.message || e);
+    process.exit(1);
   }
-  console.error(err.message || e);
-  process.exit(1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhng/crm.cli",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Headless CLI-first CRM",
   "author": "David Zhang",
   "license": "MIT",