@hasna/contacts 0.1.0

package/dist/server/index.js

@@ -0,0 +1,1476 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/server/serve.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/db/database.ts
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync } from "fs";
+import { dirname, join, resolve } from "path";
+function getDbPath() {
+  if (process.env["CONTACTS_DB_PATH"])
+    return process.env["CONTACTS_DB_PATH"];
+  const home = process.env["HOME"] || "~";
+  return join(home, ".contacts", "contacts.db");
+}
+function ensureDir(filePath) {
+  if (filePath === ":memory:")
+    return;
+  const dir = dirname(resolve(filePath));
+  if (!existsSync(dir))
+    mkdirSync(dir, { recursive: true });
+}
+var MIGRATIONS = [
+  `
+  CREATE TABLE IF NOT EXISTS companies (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    domain TEXT,
+    logo_url TEXT,
+    description TEXT,
+    industry TEXT,
+    size TEXT,
+    founded_year INTEGER,
+    notes TEXT,
+    custom_fields TEXT NOT NULL DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS contacts (
+    id TEXT PRIMARY KEY,
+    first_name TEXT NOT NULL DEFAULT '',
+    last_name TEXT NOT NULL DEFAULT '',
+    display_name TEXT NOT NULL,
+    nickname TEXT,
+    avatar_url TEXT,
+    notes TEXT,
+    birthday TEXT,
+    company_id TEXT REFERENCES companies(id) ON DELETE SET NULL,
+    job_title TEXT,
+    source TEXT NOT NULL DEFAULT 'manual',
+    custom_fields TEXT NOT NULL DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS tags (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    color TEXT NOT NULL DEFAULT '#6366f1',
+    description TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS contact_tags (
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    tag_id TEXT NOT NULL REFERENCES tags(id) ON DELETE CASCADE,
+    PRIMARY KEY (contact_id, tag_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS company_tags (
+    company_id TEXT NOT NULL REFERENCES companies(id) ON DELETE CASCADE,
+    tag_id TEXT NOT NULL REFERENCES tags(id) ON DELETE CASCADE,
+    PRIMARY KEY (company_id, tag_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS emails (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT REFERENCES contacts(id) ON DELETE CASCADE,
+    company_id TEXT REFERENCES companies(id) ON DELETE CASCADE,
+    address TEXT NOT NULL,
+    type TEXT NOT NULL DEFAULT 'work' CHECK(type IN ('work','personal','other')),
+    is_primary INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS phones (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT REFERENCES contacts(id) ON DELETE CASCADE,
+    company_id TEXT REFERENCES companies(id) ON DELETE CASCADE,
+    number TEXT NOT NULL,
+    country_code TEXT,
+    type TEXT NOT NULL DEFAULT 'mobile' CHECK(type IN ('mobile','work','home','fax','whatsapp','other')),
+    is_primary INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS addresses (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT REFERENCES contacts(id) ON DELETE CASCADE,
+    company_id TEXT REFERENCES companies(id) ON DELETE CASCADE,
+    type TEXT NOT NULL DEFAULT 'physical' CHECK(type IN ('physical','mailing','billing','virtual','other')),
+    street TEXT,
+    city TEXT,
+    state TEXT,
+    zip TEXT,
+    country TEXT,
+    is_primary INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS social_profiles (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT REFERENCES contacts(id) ON DELETE CASCADE,
+    company_id TEXT REFERENCES companies(id) ON DELETE CASCADE,
+    platform TEXT NOT NULL CHECK(platform IN ('twitter','linkedin','github','instagram','telegram','discord','youtube','tiktok','bluesky','facebook','whatsapp','snapchat','reddit','other')),
+    handle TEXT,
+    url TEXT,
+    is_primary INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS contact_relationships (
+    id TEXT PRIMARY KEY,
+    contact_a_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    contact_b_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    relationship_type TEXT NOT NULL CHECK(relationship_type IN ('colleague','friend','family','reports_to','mentor','investor','partner','client','vendor','other')),
+    notes TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS activity_log (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT REFERENCES contacts(id) ON DELETE CASCADE,
+    company_id TEXT REFERENCES companies(id) ON DELETE CASCADE,
+    action TEXT NOT NULL,
+    details TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS webhooks (
+    id TEXT PRIMARY KEY,
+    url TEXT NOT NULL,
+    events TEXT NOT NULL DEFAULT '["*"]',
+    secret TEXT,
+    active INTEGER NOT NULL DEFAULT 1,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE VIRTUAL TABLE IF NOT EXISTS contacts_fts USING fts5(
+    id UNINDEXED,
+    display_name,
+    first_name,
+    last_name,
+    nickname,
+    notes,
+    job_title,
+    content='contacts',
+    content_rowid='rowid'
+  );
+
+  CREATE TRIGGER IF NOT EXISTS contacts_fts_insert AFTER INSERT ON contacts BEGIN
+    INSERT INTO contacts_fts(rowid, id, display_name, first_name, last_name, nickname, notes, job_title)
+    VALUES (new.rowid, new.id, new.display_name, new.first_name, new.last_name, new.nickname, new.notes, new.job_title);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS contacts_fts_update AFTER UPDATE ON contacts BEGIN
+    DELETE FROM contacts_fts WHERE rowid = old.rowid;
+    INSERT INTO contacts_fts(rowid, id, display_name, first_name, last_name, nickname, notes, job_title)
+    VALUES (new.rowid, new.id, new.display_name, new.first_name, new.last_name, new.nickname, new.notes, new.job_title);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS contacts_fts_delete AFTER DELETE ON contacts BEGIN
+    DELETE FROM contacts_fts WHERE rowid = old.rowid;
+  END;
+
+  CREATE TABLE IF NOT EXISTS _migrations (version INTEGER PRIMARY KEY);
+  `
+];
+var _db = null;
+function getDatabase(path) {
+  if (_db)
+    return _db;
+  const dbPath = path || getDbPath();
+  ensureDir(dbPath);
+  const db = new Database(dbPath, { create: true });
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec("PRAGMA foreign_keys=ON");
+  runMigrations(db);
+  _db = db;
+  return db;
+}
+function uuid() {
+  return crypto.randomUUID();
+}
+function now() {
+  return new Date().toISOString();
+}
+function runMigrations(db) {
+  try {
+    const row = db.query("SELECT MAX(version) as v FROM _migrations").get();
+    const current = row?.v ?? -1;
+    for (let i = current + 1;i < MIGRATIONS.length; i++) {
+      db.exec(MIGRATIONS[i]);
+      db.exec(`INSERT OR REPLACE INTO _migrations(version) VALUES(${i})`);
+    }
+  } catch {
+    for (const m of MIGRATIONS) {
+      try {
+        db.exec(m);
+      } catch {}
+    }
+    try {
+      db.exec(`INSERT OR REPLACE INTO _migrations(version) VALUES(${MIGRATIONS.length - 1})`);
+    } catch {}
+  }
+}
+
+// src/types/index.ts
+class ContactNotFoundError extends Error {
+  constructor(id) {
+    super(`Contact not found: ${id}`);
+    this.name = "ContactNotFoundError";
+  }
+}
+
+class CompanyNotFoundError extends Error {
+  constructor(id) {
+    super(`Company not found: ${id}`);
+    this.name = "CompanyNotFoundError";
+  }
+}
+
+class TagNotFoundError extends Error {
+  constructor(id) {
+    super(`Tag not found: ${id}`);
+    this.name = "TagNotFoundError";
+  }
+}
+
+class DuplicateTagNameError extends Error {
+  constructor(name) {
+    super(`Tag with name already exists: ${name}`);
+    this.name = "DuplicateTagNameError";
+  }
+}
+
+// src/db/activity.ts
+function logActivity(db, input) {
+  const id = uuid();
+  db.run(`INSERT INTO activity_log (id, contact_id, company_id, action, details) VALUES (?, ?, ?, ?, ?)`, [id, input.contact_id ?? null, input.company_id ?? null, input.action, input.details ?? null]);
+  return db.query(`SELECT * FROM activity_log WHERE id = ?`).get(id);
+}
+
+// src/db/contacts.ts
+function rowToContact(row) {
+  return {
+    ...row,
+    source: row.source,
+    custom_fields: JSON.parse(row.custom_fields || "{}")
+  };
+}
+function rowToEmail(row) {
+  return {
+    ...row,
+    type: row.type,
+    is_primary: !!row.is_primary
+  };
+}
+function rowToPhone(row) {
+  return {
+    ...row,
+    type: row.type,
+    is_primary: !!row.is_primary
+  };
+}
+function rowToAddress(row) {
+  return {
+    ...row,
+    type: row.type,
+    is_primary: !!row.is_primary
+  };
+}
+function rowToSocialProfile(row) {
+  return {
+    ...row,
+    platform: row.platform,
+    is_primary: !!row.is_primary
+  };
+}
+function rowToTag(row) {
+  return { ...row };
+}
+function rowToCompany(row) {
+  return {
+    ...row,
+    custom_fields: JSON.parse(row.custom_fields || "{}")
+  };
+}
+function insertEmails(db, contactId, companyId, emails) {
+  for (const e of emails) {
+    db.run(`INSERT INTO emails (id, contact_id, company_id, address, type, is_primary) VALUES (?, ?, ?, ?, ?, ?)`, [uuid(), contactId, companyId, e.address, e.type ?? "work", e.is_primary ? 1 : 0]);
+  }
+}
+function insertPhones(db, contactId, companyId, phones) {
+  for (const p of phones) {
+    db.run(`INSERT INTO phones (id, contact_id, company_id, number, country_code, type, is_primary) VALUES (?, ?, ?, ?, ?, ?, ?)`, [uuid(), contactId, companyId, p.number, p.country_code ?? null, p.type ?? "mobile", p.is_primary ? 1 : 0]);
+  }
+}
+function insertAddresses(db, contactId, companyId, addresses) {
+  for (const a of addresses) {
+    db.run(`INSERT INTO addresses (id, contact_id, company_id, type, street, city, state, zip, country, is_primary) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [uuid(), contactId, companyId, a.type ?? "physical", a.street ?? null, a.city ?? null, a.state ?? null, a.zip ?? null, a.country ?? null, a.is_primary ? 1 : 0]);
+  }
+}
+function insertSocialProfiles(db, contactId, companyId, profiles) {
+  for (const s of profiles) {
+    db.run(`INSERT INTO social_profiles (id, contact_id, company_id, platform, handle, url, is_primary) VALUES (?, ?, ?, ?, ?, ?, ?)`, [uuid(), contactId, companyId, s.platform, s.handle ?? null, s.url ?? null, s.is_primary ? 1 : 0]);
+  }
+}
+function loadContactDetails(db, contact) {
+  const emails = db.query(`SELECT * FROM emails WHERE contact_id = ?`).all(contact.id).map(rowToEmail);
+  const phones = db.query(`SELECT * FROM phones WHERE contact_id = ?`).all(contact.id).map(rowToPhone);
+  const addresses = db.query(`SELECT * FROM addresses WHERE contact_id = ?`).all(contact.id).map(rowToAddress);
+  const social_profiles = db.query(`SELECT * FROM social_profiles WHERE contact_id = ?`).all(contact.id).map(rowToSocialProfile);
+  const tags = db.query(`
+    SELECT t.* FROM tags t
+    JOIN contact_tags ct ON ct.tag_id = t.id
+    WHERE ct.contact_id = ?
+  `).all(contact.id).map(rowToTag);
+  const companyRow = contact.company_id ? db.query(`SELECT * FROM companies WHERE id = ?`).get(contact.company_id) : null;
+  const company = companyRow ? rowToCompany(companyRow) : null;
+  return { ...contact, emails, phones, addresses, social_profiles, tags, company };
+}
+function createContact(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  const firstName = input.first_name ?? "";
+  const lastName = input.last_name ?? "";
+  const displayName = input.display_name ?? (firstName || lastName ? `${firstName} ${lastName}`.trim() : "Unnamed Contact");
+  d.run(`INSERT INTO contacts (id, first_name, last_name, display_name, nickname, avatar_url, notes, birthday, company_id, job_title, source, custom_fields, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    firstName,
+    lastName,
+    displayName,
+    input.nickname ?? null,
+    input.avatar_url ?? null,
+    input.notes ?? null,
+    input.birthday ?? null,
+    input.company_id ?? null,
+    input.job_title ?? null,
+    input.source ?? "manual",
+    JSON.stringify(input.custom_fields ?? {}),
+    timestamp,
+    timestamp
+  ]);
+  if (input.emails?.length)
+    insertEmails(d, id, null, input.emails);
+  if (input.phones?.length)
+    insertPhones(d, id, null, input.phones);
+  if (input.addresses?.length)
+    insertAddresses(d, id, null, input.addresses);
+  if (input.social_profiles?.length)
+    insertSocialProfiles(d, id, null, input.social_profiles);
+  if (input.tag_ids?.length) {
+    for (const tagId of input.tag_ids) {
+      d.run(`INSERT OR IGNORE INTO contact_tags (contact_id, tag_id) VALUES (?, ?)`, [id, tagId]);
+    }
+  }
+  logActivity(d, { contact_id: id, action: "contact.created", details: `Created contact: ${displayName}` });
+  const row = d.query(`SELECT * FROM contacts WHERE id = ?`).get(id);
+  return loadContactDetails(d, rowToContact(row));
+}
+function getContact(id, db) {
+  const d = db || getDatabase();
+  const row = d.query(`SELECT * FROM contacts WHERE id = ?`).get(id);
+  if (!row)
+    throw new ContactNotFoundError(id);
+  return loadContactDetails(d, rowToContact(row));
+}
+function listContacts(opts = {}, db) {
+  const d = db || getDatabase();
+  const {
+    limit = 50,
+    offset = 0,
+    company_id,
+    tag_id,
+    source,
+    order_by = "display_name",
+    order_dir = "asc"
+  } = opts;
+  const conditions = [];
+  const params = [];
+  if (company_id) {
+    conditions.push("c.company_id = ?");
+    params.push(company_id);
+  }
+  if (source) {
+    conditions.push("c.source = ?");
+    params.push(source);
+  }
+  if (tag_id) {
+    conditions.push("EXISTS (SELECT 1 FROM contact_tags ct WHERE ct.contact_id = c.id AND ct.tag_id = ?)");
+    params.push(tag_id);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const validOrderBy = ["display_name", "created_at", "updated_at"].includes(order_by) ? order_by : "display_name";
+  const validOrderDir = order_dir === "desc" ? "DESC" : "ASC";
+  const totalRow = d.query(`SELECT COUNT(*) as total FROM contacts c ${where}`).get(...params);
+  const rows = d.query(`SELECT c.* FROM contacts c ${where} ORDER BY c.${validOrderBy} ${validOrderDir} LIMIT ? OFFSET ?`).all(...params, limit, offset);
+  const contacts = rows.map((row) => loadContactDetails(d, rowToContact(row)));
+  return { contacts, total: totalRow.total };
+}
+function updateContact(id, input, db) {
+  const d = db || getDatabase();
+  const existing = d.query(`SELECT * FROM contacts WHERE id = ?`).get(id);
+  if (!existing)
+    throw new ContactNotFoundError(id);
+  const setClauses = ["updated_at = ?"];
+  const params = [now()];
+  if (input.first_name !== undefined) {
+    setClauses.push("first_name = ?");
+    params.push(input.first_name);
+  }
+  if (input.last_name !== undefined) {
+    setClauses.push("last_name = ?");
+    params.push(input.last_name);
+  }
+  if (input.display_name !== undefined) {
+    setClauses.push("display_name = ?");
+    params.push(input.display_name);
+  }
+  if (input.nickname !== undefined) {
+    setClauses.push("nickname = ?");
+    params.push(input.nickname);
+  }
+  if (input.avatar_url !== undefined) {
+    setClauses.push("avatar_url = ?");
+    params.push(input.avatar_url);
+  }
+  if (input.notes !== undefined) {
+    setClauses.push("notes = ?");
+    params.push(input.notes);
+  }
+  if (input.birthday !== undefined) {
+    setClauses.push("birthday = ?");
+    params.push(input.birthday);
+  }
+  if (input.company_id !== undefined) {
+    setClauses.push("company_id = ?");
+    params.push(input.company_id);
+  }
+  if (input.job_title !== undefined) {
+    setClauses.push("job_title = ?");
+    params.push(input.job_title);
+  }
+  if (input.source !== undefined) {
+    setClauses.push("source = ?");
+    params.push(input.source);
+  }
+  if (input.custom_fields !== undefined) {
+    setClauses.push("custom_fields = ?");
+    params.push(JSON.stringify(input.custom_fields));
+  }
+  params.push(id);
+  d.run(`UPDATE contacts SET ${setClauses.join(", ")} WHERE id = ?`, params);
+  logActivity(d, { contact_id: id, action: "contact.updated", details: `Updated contact: ${existing.display_name}` });
+  const row = d.query(`SELECT * FROM contacts WHERE id = ?`).get(id);
+  return loadContactDetails(d, rowToContact(row));
+}
+function deleteContact(id, db) {
+  const d = db || getDatabase();
+  const row = d.query(`SELECT * FROM contacts WHERE id = ?`).get(id);
+  if (!row)
+    throw new ContactNotFoundError(id);
+  logActivity(d, { contact_id: id, action: "contact.deleted", details: `Deleted contact: ${row.display_name}` });
+  d.run(`DELETE FROM contacts WHERE id = ?`, [id]);
+}
+function searchContacts(query, db) {
+  const d = db || getDatabase();
+  const ftsRows = d.query(`
+    SELECT c.* FROM contacts c
+    JOIN contacts_fts fts ON fts.id = c.id
+    WHERE contacts_fts MATCH ?
+    ORDER BY rank
+    LIMIT 50
+  `).all(`"${query.replace(/"/g, '""')}"*`);
+  const emailRows = d.query(`
+    SELECT DISTINCT c.* FROM contacts c
+    JOIN emails e ON e.contact_id = c.id
+    WHERE e.address LIKE ?
+    LIMIT 20
+  `).all(`%${query}%`);
+  const phoneRows = d.query(`
+    SELECT DISTINCT c.* FROM contacts c
+    JOIN phones p ON p.contact_id = c.id
+    WHERE p.number LIKE ?
+    LIMIT 20
+  `).all(`%${query}%`);
+  const seen = new Set;
+  const allRows = [];
+  for (const row of [...ftsRows, ...emailRows, ...phoneRows]) {
+    if (!seen.has(row.id)) {
+      seen.add(row.id);
+      allRows.push(row);
+    }
+  }
+  return allRows.map((row) => loadContactDetails(d, rowToContact(row)));
+}
+
+// src/db/companies.ts
+function rowToCompany2(row) {
+  return {
+    ...row,
+    custom_fields: JSON.parse(row.custom_fields || "{}")
+  };
+}
+function insertEmails2(db, companyId, emails) {
+  for (const e of emails) {
+    db.run(`INSERT INTO emails (id, contact_id, company_id, address, type, is_primary) VALUES (?, ?, ?, ?, ?, ?)`, [uuid(), null, companyId, e.address, e.type ?? "work", e.is_primary ? 1 : 0]);
+  }
+}
+function insertPhones2(db, companyId, phones) {
+  for (const p of phones) {
+    db.run(`INSERT INTO phones (id, contact_id, company_id, number, country_code, type, is_primary) VALUES (?, ?, ?, ?, ?, ?, ?)`, [uuid(), null, companyId, p.number, p.country_code ?? null, p.type ?? "work", p.is_primary ? 1 : 0]);
+  }
+}
+function insertAddresses2(db, companyId, addresses) {
+  for (const a of addresses) {
+    db.run(`INSERT INTO addresses (id, contact_id, company_id, type, street, city, state, zip, country, is_primary) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [uuid(), null, companyId, a.type ?? "physical", a.street ?? null, a.city ?? null, a.state ?? null, a.zip ?? null, a.country ?? null, a.is_primary ? 1 : 0]);
+  }
+}
+function insertSocialProfiles2(db, companyId, profiles) {
+  for (const s of profiles) {
+    db.run(`INSERT INTO social_profiles (id, contact_id, company_id, platform, handle, url, is_primary) VALUES (?, ?, ?, ?, ?, ?, ?)`, [uuid(), null, companyId, s.platform, s.handle ?? null, s.url ?? null, s.is_primary ? 1 : 0]);
+  }
+}
+function loadCompanyDetails(db, company) {
+  const emails = db.query(`SELECT * FROM emails WHERE company_id = ?`).all(company.id).map((row) => ({
+    ...row,
+    type: row.type,
+    is_primary: !!row.is_primary
+  }));
+  const phones = db.query(`SELECT * FROM phones WHERE company_id = ?`).all(company.id).map((row) => ({
+    ...row,
+    type: row.type,
+    is_primary: !!row.is_primary
+  }));
+  const addresses = db.query(`SELECT * FROM addresses WHERE company_id = ?`).all(company.id).map((row) => ({
+    ...row,
+    type: row.type,
+    is_primary: !!row.is_primary
+  }));
+  const social_profiles = db.query(`SELECT * FROM social_profiles WHERE company_id = ?`).all(company.id).map((row) => ({
+    ...row,
+    platform: row.platform,
+    is_primary: !!row.is_primary
+  }));
+  const tags = db.query(`
+    SELECT t.* FROM tags t
+    JOIN company_tags ct ON ct.tag_id = t.id
+    WHERE ct.company_id = ?
+  `).all(company.id);
+  const empCount = db.query(`SELECT COUNT(*) as count FROM contacts WHERE company_id = ?`).get(company.id);
+  return {
+    ...company,
+    emails,
+    phones,
+    addresses,
+    social_profiles,
+    tags,
+    employee_count: empCount.count
+  };
+}
+function createCompany(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO companies (id, name, domain, logo_url, description, industry, size, founded_year, notes, custom_fields, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.name,
+    input.domain ?? null,
+    input.logo_url ?? null,
+    input.description ?? null,
+    input.industry ?? null,
+    input.size ?? null,
+    input.founded_year ?? null,
+    input.notes ?? null,
+    JSON.stringify(input.custom_fields ?? {}),
+    timestamp,
+    timestamp
+  ]);
+  if (input.emails?.length)
+    insertEmails2(d, id, input.emails);
+  if (input.phones?.length)
+    insertPhones2(d, id, input.phones);
+  if (input.addresses?.length)
+    insertAddresses2(d, id, input.addresses);
+  if (input.social_profiles?.length)
+    insertSocialProfiles2(d, id, input.social_profiles);
+  if (input.tag_ids?.length) {
+    for (const tagId of input.tag_ids) {
+      d.run(`INSERT OR IGNORE INTO company_tags (company_id, tag_id) VALUES (?, ?)`, [id, tagId]);
+    }
+  }
+  logActivity(d, { company_id: id, action: "company.created", details: `Created company: ${input.name}` });
+  const row = d.query(`SELECT * FROM companies WHERE id = ?`).get(id);
+  return loadCompanyDetails(d, rowToCompany2(row));
+}
+function getCompany(id, db) {
+  const d = db || getDatabase();
+  const row = d.query(`SELECT * FROM companies WHERE id = ?`).get(id);
+  if (!row)
+    throw new CompanyNotFoundError(id);
+  return loadCompanyDetails(d, rowToCompany2(row));
+}
+function listCompanies(opts = {}, db) {
+  const d = db || getDatabase();
+  const {
+    limit = 50,
+    offset = 0,
+    industry,
+    tag_id,
+    order_by = "name",
+    order_dir = "asc"
+  } = opts;
+  const conditions = [];
+  const params = [];
+  if (industry) {
+    conditions.push("co.industry = ?");
+    params.push(industry);
+  }
+  if (tag_id) {
+    conditions.push("EXISTS (SELECT 1 FROM company_tags ct WHERE ct.company_id = co.id AND ct.tag_id = ?)");
+    params.push(tag_id);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const validOrderBy = ["name", "created_at", "updated_at"].includes(order_by) ? order_by : "name";
+  const validOrderDir = order_dir === "desc" ? "DESC" : "ASC";
+  const totalRow = d.query(`SELECT COUNT(*) as total FROM companies co ${where}`).get(...params);
+  const rows = d.query(`SELECT co.* FROM companies co ${where} ORDER BY co.${validOrderBy} ${validOrderDir} LIMIT ? OFFSET ?`).all(...params, limit, offset);
+  const companies = rows.map((row) => loadCompanyDetails(d, rowToCompany2(row)));
+  return { companies, total: totalRow.total };
+}
+function updateCompany(id, input, db) {
+  const d = db || getDatabase();
+  const existing = d.query(`SELECT * FROM companies WHERE id = ?`).get(id);
+  if (!existing)
+    throw new CompanyNotFoundError(id);
+  const setClauses = ["updated_at = ?"];
+  const params = [now()];
+  if (input.name !== undefined) {
+    setClauses.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.domain !== undefined) {
+    setClauses.push("domain = ?");
+    params.push(input.domain);
+  }
+  if (input.logo_url !== undefined) {
+    setClauses.push("logo_url = ?");
+    params.push(input.logo_url);
+  }
+  if (input.description !== undefined) {
+    setClauses.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.industry !== undefined) {
+    setClauses.push("industry = ?");
+    params.push(input.industry);
+  }
+  if (input.size !== undefined) {
+    setClauses.push("size = ?");
+    params.push(input.size);
+  }
+  if (input.founded_year !== undefined) {
+    setClauses.push("founded_year = ?");
+    params.push(input.founded_year);
+  }
+  if (input.notes !== undefined) {
+    setClauses.push("notes = ?");
+    params.push(input.notes);
+  }
+  if (input.custom_fields !== undefined) {
+    setClauses.push("custom_fields = ?");
+    params.push(JSON.stringify(input.custom_fields));
+  }
+  params.push(id);
+  d.run(`UPDATE companies SET ${setClauses.join(", ")} WHERE id = ?`, params);
+  logActivity(d, { company_id: id, action: "company.updated", details: `Updated company: ${existing.name}` });
+  const row = d.query(`SELECT * FROM companies WHERE id = ?`).get(id);
+  return loadCompanyDetails(d, rowToCompany2(row));
+}
+function deleteCompany(id, db) {
+  const d = db || getDatabase();
+  const row = d.query(`SELECT * FROM companies WHERE id = ?`).get(id);
+  if (!row)
+    throw new CompanyNotFoundError(id);
+  logActivity(d, { company_id: id, action: "company.deleted", details: `Deleted company: ${row.name}` });
+  d.run(`DELETE FROM companies WHERE id = ?`, [id]);
+}
+
+// src/db/tags.ts
+function rowToTag2(row) {
+  return { ...row };
+}
+function createTag(input, db) {
+  const d = db || getDatabase();
+  const existing = d.query(`SELECT id FROM tags WHERE name = ?`).get(input.name);
+  if (existing)
+    throw new DuplicateTagNameError(input.name);
+  const id = uuid();
+  d.run(`INSERT INTO tags (id, name, color, description) VALUES (?, ?, ?, ?)`, [id, input.name, input.color ?? "#6366f1", input.description ?? null]);
+  return rowToTag2(d.query(`SELECT * FROM tags WHERE id = ?`).get(id));
+}
+function listTags(db) {
+  const d = db || getDatabase();
+  return d.query(`SELECT * FROM tags ORDER BY name ASC`).all().map(rowToTag2);
+}
+function deleteTag(id, db) {
+  const d = db || getDatabase();
+  const row = d.query(`SELECT id FROM tags WHERE id = ?`).get(id);
+  if (!row)
+    throw new TagNotFoundError(id);
+  d.run(`DELETE FROM tags WHERE id = ?`, [id]);
+}
+
+// src/lib/import.ts
+function parseCsv(text) {
+  const lines = text.split(/\r?\n/);
+  if (lines.length < 2)
+    return [];
+  const headers = parseCsvLine(lines[0]);
+  const rows = [];
+  for (let i = 1;i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line)
+      continue;
+    const values = parseCsvLine(line);
+    const row = {};
+    headers.forEach((h, idx) => {
+      row[h.trim()] = values[idx]?.trim() ?? "";
+    });
+    rows.push(row);
+  }
+  return rows;
+}
+function parseCsvLine(line) {
+  const fields = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0;i < line.length; i++) {
+    const ch = line[i];
+    if (ch === '"') {
+      if (inQuotes && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else {
+        inQuotes = !inQuotes;
+      }
+    } else if (ch === "," && !inQuotes) {
+      fields.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  fields.push(current);
+  return fields;
+}
+function csvRowToContact(row) {
+  const firstName = row["First Name"] ?? row["first_name"] ?? row["Given Name"] ?? "";
+  const lastName = row["Last Name"] ?? row["last_name"] ?? row["Family Name"] ?? "";
+  const displayName = row["Name"] ?? row["display_name"] ?? row["Full Name"] ?? [firstName, lastName].filter(Boolean).join(" ") ?? "";
+  if (!displayName && !firstName && !lastName)
+    return null;
+  const contact = {
+    display_name: displayName || [firstName, lastName].filter(Boolean).join(" ") || "Unnamed",
+    first_name: firstName || undefined,
+    last_name: lastName || undefined,
+    job_title: row["Job Title"] ?? row["job_title"] ?? row["Title"] ?? undefined,
+    notes: row["Notes"] ?? row["notes"] ?? undefined,
+    birthday: row["Birthday"] ?? row["birthday"] ?? undefined,
+    source: "import"
+  };
+  const emails = [];
+  for (let i = 1;i <= 5; i++) {
+    const val = row[`Email ${i} - Value`] ?? row[`Email Address ${i}`] ?? (i === 1 ? row["Email"] ?? row["email"] ?? row["Email Address"] : undefined);
+    const rawType = row[`Email ${i} - Type`] ?? (i === 1 ? "work" : "other");
+    if (val) {
+      const type = rawType?.toLowerCase() === "personal" ? "personal" : rawType?.toLowerCase() === "other" ? "other" : "work";
+      emails.push({ address: val, type, is_primary: i === 1 });
+    }
+  }
+  if (emails.length)
+    contact.emails = emails;
+  const phones = [];
+  for (let i = 1;i <= 5; i++) {
+    const val = row[`Phone ${i} - Value`] ?? row[`Phone ${i}`] ?? (i === 1 ? row["Phone"] ?? row["phone"] ?? row["Mobile"] : undefined);
+    const rawType = row[`Phone ${i} - Type`] ?? (i === 1 ? "mobile" : "other");
+    if (val) {
+      const type = rawType?.toLowerCase().includes("mobile") || rawType?.toLowerCase().includes("cell") ? "mobile" : rawType?.toLowerCase().includes("work") ? "work" : rawType?.toLowerCase().includes("home") ? "home" : rawType?.toLowerCase().includes("fax") ? "fax" : "other";
+      phones.push({ number: val, type, is_primary: i === 1 });
+    }
+  }
+  if (phones.length)
+    contact.phones = phones;
+  return contact;
+}
+function importFromCsv(data) {
+  const rows = parseCsv(data);
+  return rows.map(csvRowToContact).filter(Boolean);
+}
+function parseVcf(data) {
+  const contacts = [];
+  const blocks = data.split(/BEGIN:VCARD/i).filter((b) => b.trim());
+  for (const block of blocks) {
+    try {
+      const contact = parseVcfBlock(`BEGIN:VCARD
+` + block);
+      if (contact)
+        contacts.push(contact);
+    } catch {}
+  }
+  return contacts;
+}
+function parseVcfBlock(block) {
+  const unfolded = block.replace(/\r?\n[ \t]/g, "");
+  const lines = unfolded.split(/\r?\n/).filter((l) => l.trim());
+  const contact = { source: "import" };
+  const emails = [];
+  const phones = [];
+  const addresses = [];
+  const socials = [];
+  for (const line of lines) {
+    if (/^BEGIN:VCARD$/i.test(line) || /^END:VCARD$/i.test(line) || /^VERSION:/i.test(line))
+      continue;
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1)
+      continue;
+    const propPart = line.slice(0, colonIdx);
+    const value = line.slice(colonIdx + 1).trim();
+    const semicolonIdx = propPart.indexOf(";");
+    const propName = (semicolonIdx === -1 ? propPart : propPart.slice(0, semicolonIdx)).toUpperCase();
+    const params = semicolonIdx !== -1 ? propPart.slice(semicolonIdx + 1) : "";
+    switch (propName) {
+      case "FN":
+        contact.display_name = decodeVcfValue(value);
+        break;
+      case "N": {
+        const parts = value.split(";");
+        contact.last_name = decodeVcfValue(parts[0] ?? "") || undefined;
+        contact.first_name = decodeVcfValue(parts[1] ?? "") || undefined;
+        break;
+      }
+      case "NICKNAME":
+        contact.nickname = decodeVcfValue(value) || undefined;
+        break;
+      case "TITLE":
+        contact.job_title = decodeVcfValue(value) || undefined;
+        break;
+      case "NOTE":
+        contact.notes = decodeVcfValue(value) || undefined;
+        break;
+      case "BDAY":
+        contact.birthday = value.replace(/^(\d{4})(\d{2})(\d{2})$/, "$1-$2-$3");
+        break;
+      case "EMAIL": {
+        const typeMatch = params.match(/TYPE=([^;]+)/i);
+        const rawLabel = typeMatch ? typeMatch[1].toLowerCase() : "work";
+        const type = rawLabel.includes("personal") ? "personal" : rawLabel.includes("other") ? "other" : "work";
+        const isPrimary = params.includes("PREF") || emails.length === 0;
+        emails.push({ address: decodeVcfValue(value), type, is_primary: isPrimary });
+        break;
+      }
+      case "TEL": {
+        const typeMatch = params.match(/TYPE=([^;]+)/i);
+        const rawLabel = typeMatch ? typeMatch[1].toLowerCase() : "mobile";
+        const type = rawLabel.includes("cell") || rawLabel.includes("mobile") ? "mobile" : rawLabel.includes("work") ? "work" : rawLabel.includes("home") ? "home" : rawLabel.includes("fax") ? "fax" : "other";
+        const isPrimary = params.includes("PREF") || phones.length === 0;
+        phones.push({ number: decodeVcfValue(value), type, is_primary: isPrimary });
+        break;
+      }
+      case "ADR": {
+        const parts = value.split(";");
+        const typeMatch = params.match(/TYPE=([^;]+)/i);
+        const rawLabel = typeMatch ? typeMatch[1].toLowerCase().split(",")[0] : "physical";
+        const type = rawLabel.includes("home") || rawLabel.includes("physical") ? "physical" : rawLabel.includes("mail") ? "mailing" : rawLabel.includes("bill") ? "billing" : "other";
+        addresses.push({
+          type,
+          street: decodeVcfValue(parts[2] ?? "") || undefined,
+          city: decodeVcfValue(parts[3] ?? "") || undefined,
+          state: decodeVcfValue(parts[4] ?? "") || undefined,
+          zip: decodeVcfValue(parts[5] ?? "") || undefined,
+          country: decodeVcfValue(parts[6] ?? "") || undefined,
+          is_primary: addresses.length === 0
+        });
+        break;
+      }
+      case "URL": {
+        const url = decodeVcfValue(value);
+        const platform = detectPlatform(url);
+        socials.push({ platform, url, handle: url });
+        break;
+      }
+      case "X-SOCIALPROFILE": {
+        const typeMatch = params.match(/TYPE=([^;]+)/i);
+        const platform = normalizePlatform(typeMatch?.[1] ?? "other");
+        socials.push({ platform, handle: decodeVcfValue(value), url: value });
+        break;
+      }
+    }
+  }
+  if (!contact.display_name) {
+    if (contact.first_name || contact.last_name) {
+      contact.display_name = [contact.first_name, contact.last_name].filter(Boolean).join(" ");
+    } else {
+      return null;
+    }
+  }
+  if (emails.length)
+    contact.emails = emails;
+  if (phones.length)
+    contact.phones = phones;
+  if (addresses.length)
+    contact.addresses = addresses;
+  if (socials.length)
+    contact.social_profiles = socials;
+  return contact;
+}
+function decodeVcfValue(val) {
+  return val.replace(/\\n/g, `
+`).replace(/\\,/g, ",").replace(/\\;/g, ";").replace(/\\\\/g, "\\");
+}
+function detectPlatform(url) {
+  const lower = url.toLowerCase();
+  if (lower.includes("twitter.com") || lower.includes("x.com"))
+    return "twitter";
+  if (lower.includes("linkedin.com"))
+    return "linkedin";
+  if (lower.includes("github.com"))
+    return "github";
+  if (lower.includes("instagram.com"))
+    return "instagram";
+  if (lower.includes("facebook.com"))
+    return "facebook";
+  if (lower.includes("youtube.com"))
+    return "youtube";
+  if (lower.includes("telegram"))
+    return "telegram";
+  if (lower.includes("discord"))
+    return "discord";
+  if (lower.includes("tiktok"))
+    return "tiktok";
+  if (lower.includes("bluesky") || lower.includes("bsky"))
+    return "bluesky";
+  return "other";
+}
+function normalizePlatform(raw) {
+  const lower = raw.toLowerCase();
+  const platforms = [
+    "twitter",
+    "linkedin",
+    "github",
+    "instagram",
+    "telegram",
+    "discord",
+    "youtube",
+    "tiktok",
+    "bluesky",
+    "facebook",
+    "whatsapp",
+    "snapchat",
+    "reddit"
+  ];
+  for (const p of platforms) {
+    if (lower.includes(p))
+      return p;
+  }
+  return "other";
+}
+function importFromJson(data) {
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    throw new Error("Invalid JSON");
+  }
+  if (!Array.isArray(parsed)) {
+    if (typeof parsed === "object" && parsed !== null) {
+      parsed = [parsed];
+    } else {
+      throw new Error("JSON must be an array of contacts");
+    }
+  }
+  return parsed.map((obj) => {
+    const displayName = obj.display_name ?? obj.name ?? [obj.first_name ?? "", obj.last_name ?? ""].filter(Boolean).join(" ") ?? "Unnamed";
+    return {
+      ...obj,
+      display_name: displayName,
+      source: "import"
+    };
+  });
+}
+async function importContacts(format, data) {
+  switch (format) {
+    case "csv":
+      return importFromCsv(data);
+    case "vcf":
+      return parseVcf(data);
+    case "json":
+      return importFromJson(data);
+    default:
+      throw new Error(`Unsupported import format: ${format}`);
+  }
+}
+
+// src/lib/export.ts
+function toJson(contacts) {
+  return JSON.stringify(contacts, null, 2);
+}
+function escapeCsvField(val) {
+  if (val == null)
+    return "";
+  const str = String(val);
+  if (str.includes(",") || str.includes('"') || str.includes(`
+`)) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+function toCsv(contacts) {
+  const headers = [
+    "First Name",
+    "Last Name",
+    "Name",
+    "Nickname",
+    "Job Title",
+    "Company",
+    "Email 1 - Value",
+    "Email 1 - Type",
+    "Email 2 - Value",
+    "Email 2 - Type",
+    "Phone 1 - Value",
+    "Phone 1 - Type",
+    "Phone 2 - Value",
+    "Phone 2 - Type",
+    "Address 1 - Street",
+    "Address 1 - City",
+    "Address 1 - State",
+    "Address 1 - Postal Code",
+    "Address 1 - Country",
+    "Address 1 - Type",
+    "Birthday",
+    "Notes",
+    "Tags"
+  ];
+  const rows = [headers.map(escapeCsvField).join(",")];
+  for (const c of contacts) {
+    const emails = c.emails ?? [];
+    const phones = c.phones ?? [];
+    const addrs = c.addresses ?? [];
+    const tags = (c.tags ?? []).map((t) => t.name).join(";");
+    const row = [
+      c.first_name,
+      c.last_name,
+      c.display_name,
+      c.nickname,
+      c.job_title,
+      c.company?.name,
+      emails[0]?.address,
+      emails[0]?.type,
+      emails[1]?.address,
+      emails[1]?.type,
+      phones[0]?.number,
+      phones[0]?.type,
+      phones[1]?.number,
+      phones[1]?.type,
+      addrs[0]?.street,
+      addrs[0]?.city,
+      addrs[0]?.state,
+      addrs[0]?.zip,
+      addrs[0]?.country,
+      addrs[0]?.type,
+      c.birthday,
+      c.notes,
+      tags
+    ];
+    rows.push(row.map(escapeCsvField).join(","));
+  }
+  return rows.join(`
+`);
+}
+function escapeVcfValue(val) {
+  if (!val)
+    return "";
+  return val.replace(/\\/g, "\\\\").replace(/,/g, "\\,").replace(/;/g, "\\;").replace(/\n/g, "\\n");
+}
+function foldVcfLine(line) {
+  if (line.length <= 75)
+    return line;
+  const parts = [line.slice(0, 75)];
+  let i = 75;
+  while (i < line.length) {
+    parts.push(" " + line.slice(i, i + 74));
+    i += 74;
+  }
+  return parts.join(`\r
+`);
+}
+function toVcf(contacts) {
+  const cards = [];
+  for (const c of contacts) {
+    const lines = ["BEGIN:VCARD", "VERSION:3.0"];
+    lines.push(`FN:${escapeVcfValue(c.display_name)}`);
+    lines.push(`N:${escapeVcfValue(c.last_name)};${escapeVcfValue(c.first_name)};;;`);
+    if (c.nickname)
+      lines.push(`NICKNAME:${escapeVcfValue(c.nickname)}`);
+    if (c.job_title)
+      lines.push(`TITLE:${escapeVcfValue(c.job_title)}`);
+    if (c.company?.name)
+      lines.push(`ORG:${escapeVcfValue(c.company.name)}`);
+    if (c.birthday)
+      lines.push(`BDAY:${c.birthday.replace(/-/g, "")}`);
+    for (let i = 0;i < (c.emails ?? []).length; i++) {
+      const e = c.emails[i];
+      const pref = i === 0 || e.is_primary ? ";PREF" : "";
+      lines.push(`EMAIL;TYPE=${e.type.toUpperCase()}${pref}:${escapeVcfValue(e.address)}`);
+    }
+    for (let i = 0;i < (c.phones ?? []).length; i++) {
+      const p = c.phones[i];
+      const pref = i === 0 || p.is_primary ? ";PREF" : "";
+      const vcfType = p.type === "mobile" ? "CELL" : p.type.toUpperCase();
+      lines.push(`TEL;TYPE=${vcfType}${pref}:${escapeVcfValue(p.number)}`);
+    }
+    for (let i = 0;i < (c.addresses ?? []).length; i++) {
+      const a = c.addresses[i];
+      const pref = i === 0 || a.is_primary ? ";PREF" : "";
+      lines.push(`ADR;TYPE=${a.type.toUpperCase()}${pref}:;;${escapeVcfValue(a.street)};${escapeVcfValue(a.city)};${escapeVcfValue(a.state)};${escapeVcfValue(a.zip)};${escapeVcfValue(a.country)}`);
+    }
+    for (const sp of c.social_profiles ?? []) {
+      if (sp.url)
+        lines.push(`URL;TYPE=${sp.platform.toUpperCase()}:${escapeVcfValue(sp.url)}`);
+      if (sp.handle)
+        lines.push(`X-SOCIALPROFILE;TYPE=${sp.platform.toLowerCase()}:${escapeVcfValue(sp.handle)}`);
+    }
+    if (c.notes)
+      lines.push(`NOTE:${escapeVcfValue(c.notes)}`);
+    if (c.tags && c.tags.length > 0) {
+      lines.push(`CATEGORIES:${c.tags.map((t) => escapeVcfValue(t.name)).join(",")}`);
+    }
+    lines.push(`UID:${c.id}`);
+    lines.push("END:VCARD");
+    cards.push(lines.map(foldVcfLine).join(`\r
+`));
+  }
+  return cards.join(`\r
+`);
+}
+async function exportContacts(format, contacts) {
+  switch (format) {
+    case "json":
+      return toJson(contacts);
+    case "csv":
+      return toCsv(contacts);
+    case "vcf":
+      return toVcf(contacts);
+    default:
+      throw new Error(`Unsupported export format: ${format}`);
+  }
+}
+
+// src/server/serve.ts
+var DASHBOARD_DIST = join2(import.meta.dir, "../../dashboard/dist");
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function apiError(message, status = 400) {
+  return json({ error: message }, status);
+}
+async function parseJson(req) {
+  try {
+    return await req.json();
+  } catch {
+    return null;
+  }
+}
+function getSegments(url) {
+  return url.pathname.split("/").filter(Boolean);
+}
+async function handleContacts(req, url, segments) {
+  const method = req.method;
+  const id = segments[2];
+  if (method === "GET" && !id) {
+    const q = url.searchParams.get("q");
+    if (q) {
+      const contacts = searchContacts(q);
+      return json(contacts);
+    }
+    const result = listContacts({
+      tag_id: url.searchParams.get("tag_id") ?? url.searchParams.get("tag") ?? undefined,
+      company_id: url.searchParams.get("company_id") ?? undefined,
+      limit: parseInt(url.searchParams.get("limit") ?? "50", 10),
+      offset: parseInt(url.searchParams.get("offset") ?? "0", 10)
+    });
+    return json(result);
+  }
+  if (method === "POST" && !id) {
+    const body = await parseJson(req);
+    if (!body || typeof body !== "object")
+      return apiError("Invalid body");
+    try {
+      const contact = createContact(body);
+      return json(contact, 201);
+    } catch (err) {
+      return apiError(err instanceof Error ? err.message : "Failed to create contact");
+    }
+  }
+  if (method === "GET" && id) {
+    try {
+      const contact = getContact(id);
+      return json(contact);
+    } catch {
+      return apiError("Contact not found", 404);
+    }
+  }
+  if (method === "PATCH" && id) {
+    const body = await parseJson(req);
+    if (!body || typeof body !== "object")
+      return apiError("Invalid body");
+    try {
+      const contact = updateContact(id, body);
+      return json(contact);
+    } catch {
+      return apiError("Contact not found", 404);
+    }
+  }
+  if (method === "DELETE" && id) {
+    try {
+      deleteContact(id);
+      return json({ ok: true });
+    } catch {
+      return apiError("Contact not found", 404);
+    }
+  }
+  return apiError("Method not allowed", 405);
+}
+async function handleCompanies(req, url, segments) {
+  const method = req.method;
+  const id = segments[2];
+  if (method === "GET" && !id) {
+    const result = listCompanies({
+      tag_id: url.searchParams.get("tag_id") ?? undefined,
+      industry: url.searchParams.get("industry") ?? undefined,
+      limit: parseInt(url.searchParams.get("limit") ?? "50", 10),
+      offset: parseInt(url.searchParams.get("offset") ?? "0", 10)
+    });
+    return json(result);
+  }
+  if (method === "POST" && !id) {
+    const body = await parseJson(req);
+    if (!body || typeof body !== "object")
+      return apiError("Invalid body");
+    try {
+      const company = createCompany(body);
+      return json(company, 201);
+    } catch (err) {
+      return apiError(err instanceof Error ? err.message : "Failed to create company");
+    }
+  }
+  if (method === "GET" && id) {
+    const company = getCompany(id);
+    if (!company)
+      return apiError("Company not found", 404);
+    return json(company);
+  }
+  if (method === "PATCH" && id) {
+    const body = await parseJson(req);
+    if (!body || typeof body !== "object")
+      return apiError("Invalid body");
+    try {
+      const company = updateCompany(id, body);
+      return json(company);
+    } catch {
+      return apiError("Company not found", 404);
+    }
+  }
+  if (method === "DELETE" && id) {
+    try {
+      deleteCompany(id);
+      return json({ ok: true });
+    } catch {
+      return apiError("Company not found", 404);
+    }
+  }
+  return apiError("Method not allowed", 405);
+}
+async function handleTags(req, _url, segments) {
+  const method = req.method;
+  const id = segments[2];
+  if (method === "GET" && !id) {
+    return json(listTags());
+  }
+  if (method === "POST" && !id) {
+    const body = await parseJson(req);
+    if (!body || typeof body !== "object")
+      return apiError("Invalid body");
+    const b = body;
+    if (!b.name)
+      return apiError("name is required");
+    const tag = createTag({ name: b.name, color: b.color, description: b.description });
+    return json(tag, 201);
+  }
+  if (method === "DELETE" && id) {
+    try {
+      deleteTag(id);
+      return json({ ok: true });
+    } catch {
+      return apiError("Tag not found", 404);
+    }
+  }
+  return apiError("Method not allowed", 405);
+}
+function handleStats() {
+  const db = getDatabase();
+  const contactCount = db.prepare("SELECT COUNT(*) as count FROM contacts").get().count;
+  const companyCount = db.prepare("SELECT COUNT(*) as count FROM companies").get().count;
+  const tagCount = db.prepare("SELECT COUNT(*) as count FROM tags").get().count;
+  return json({ contacts: contactCount, companies: companyCount, tags: tagCount });
+}
+async function handleImport(req) {
+  const body = await parseJson(req);
+  if (!body || typeof body !== "object")
+    return apiError("Invalid body");
+  const { format, data } = body;
+  if (!format || !data)
+    return apiError("format and data are required");
+  if (!["json", "csv", "vcf"].includes(format))
+    return apiError("format must be json, csv, or vcf");
+  try {
+    const inputs = await importContacts(format, data);
+    let importedCount = 0;
+    const errors = [];
+    for (const input of inputs) {
+      try {
+        createContact(input);
+        importedCount++;
+      } catch (err) {
+        errors.push(err instanceof Error ? err.message : String(err));
+      }
+    }
+    return json({ imported: importedCount, errors: errors.length, error_details: errors });
+  } catch (err) {
+    return apiError(err instanceof Error ? err.message : "Import failed");
+  }
+}
+async function handleExport(req) {
+  const url = new URL(req.url);
+  const format = url.searchParams.get("format") ?? "json";
+  if (!["json", "csv", "vcf"].includes(format))
+    return apiError("format must be json, csv, or vcf");
+  const { contacts } = listContacts({ limit: 1e5 });
+  const output = await exportContacts(format, contacts);
+  const contentTypes = {
+    json: "application/json",
+    csv: "text/csv",
+    vcf: "text/vcard"
+  };
+  return new Response(output, {
+    headers: {
+      "Content-Type": contentTypes[format] ?? "text/plain",
+      "Content-Disposition": `attachment; filename="contacts.${format}"`
+    }
+  });
+}
+function serveStaticFile(filePath) {
+  if (!existsSync2(filePath))
+    return null;
+  return new Response(Bun.file(filePath));
+}
+function startServer(port) {
+  Bun.serve({
+    port,
+    async fetch(req) {
+      const url = new URL(req.url);
+      const segments = getSegments(url);
+      const corsHeaders = {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, PATCH, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type"
+      };
+      if (req.method === "OPTIONS") {
+        return new Response(null, { status: 204, headers: corsHeaders });
+      }
+      let response;
+      try {
+        if (segments[0] === "api") {
+          switch (segments[1]) {
+            case "contacts":
+              response = await handleContacts(req, url, segments);
+              break;
+            case "companies":
+              response = await handleCompanies(req, url, segments);
+              break;
+            case "tags":
+              response = await handleTags(req, url, segments);
+              break;
+            case "stats":
+              response = handleStats();
+              break;
+            case "import":
+              response = req.method === "POST" ? await handleImport(req) : apiError("Method not allowed", 405);
+              break;
+            case "export":
+              response = req.method === "GET" ? await handleExport(req) : apiError("Method not allowed", 405);
+              break;
+            default:
+              response = apiError("Not found", 404);
+          }
+        } else {
+          const filePath = join2(DASHBOARD_DIST, url.pathname === "/" ? "index.html" : url.pathname);
+          response = serveStaticFile(filePath) ?? serveStaticFile(join2(DASHBOARD_DIST, "index.html")) ?? new Response("Not Found", { status: 404 });
+        }
+      } catch (err) {
+        console.error("Request error:", err);
+        response = apiError("Internal server error", 500);
+      }
+      const headers = new Headers(response.headers);
+      for (const [k, v] of Object.entries(corsHeaders)) {
+        headers.set(k, v);
+      }
+      return new Response(response.body, { status: response.status, headers });
+    }
+  });
+  console.log(`Contacts server running at http://localhost:${port}`);
+}
+
+// src/server/index.ts
+var DEFAULT_PORT = 19428;
+function parsePort() {
+  const portArg = process.argv.find((a) => a === "--port" || a.startsWith("--port="));
+  if (portArg) {
+    if (portArg.includes("=")) {
+      return parseInt(portArg.split("=")[1], 10) || DEFAULT_PORT;
+    }
+    const idx = process.argv.indexOf(portArg);
+    return parseInt(process.argv[idx + 1], 10) || DEFAULT_PORT;
+  }
+  return DEFAULT_PORT;
+}
+async function findFreePort(start) {
+  for (let port = start;port < start + 100; port++) {
+    try {
+      const server = Bun.serve({ port, fetch: () => new Response("") });
+      server.stop(true);
+      return port;
+    } catch {}
+  }
+  return start;
+}
+async function main() {
+  const requested = parsePort();
+  const port = await findFreePort(requested);
+  if (port !== requested) {
+    console.log(`Port ${requested} in use, using ${port}`);
+  }
+  startServer(port);
+}
+main();