contacts: owners' contacts on their desk phones, copy builtin contacts to Contrack (C6)

Spec 11 §6.2: a phone's directory is the extensions, its owner's own contacts (accepted shares
included), then the company's, in both modes. In Contrack mode, contacts from before Contrack
are offered for copying (contrack.toCopy, POST …/copy-to-contrack: one Contrack bulk import,
skipping what's already there; the builtin rows stay). Tested against a fake and a real
Contrack 2.0.2.

apps/api/src/contacts/book.ts

@@ -6,6 +6,7 @@ import { asc, eq, isNull, or, sql } from 'drizzle-orm';
 import {
   normalizeNumber,
   type ContactBookDto,
+  type ContactCopyResult,
   type ContactData,
   type ContactDto,
   type ContactImportResult,
@@ -17,6 +18,7 @@ import {
   ContrackError,
   contrackBook,
   contrackCreate,
+  contrackBulk,
   contrackSettings,
   needToken,
   type Contrack,
@@ -101,10 +103,38 @@ export async function readBooks(db: Db, userId: string | null): Promise<ContactB
       publicUrl: c.publicUrl,
       connected: !!own.book && !own.book.error,
       error: own.book?.error ?? null,
+      toCopy:
+        own.book && !own.book.error
+          ? (await notInContrack(db, userId, own.book.contacts)).length
+          : 0,
     },
   };
 }
 
+/** This book's builtin contacts that its Contrack account doesn't have yet. */
+async function notInContrack(db: Db, owner: Owner, have: ContactDto[]): Promise<ContactData[]> {
+  const rows = (await db.select().from(contacts).where(inBook(owner))).map(toDto);
+  return rows.filter((r) => !have.some((h) => isDuplicate(h, r)));
+}
+
+/**
+ * "Copy my contacts to Contrack" (11 §5, C6): the builtin book's contacts that aren't there yet,
+ * in one Contrack import. The builtin ones stay, for switching back.
+ */
+export async function copyToContrack(db: Db, owner: Owner): Promise<ContactCopyResult> {
+  const c = await contrackSettings(db);
+  if (!c)
+    throw new HttpError(409, 'contrack', 'Contacts are not in Contrack (Settings → Contacts)');
+  const b = await contrackBook(db, c, owner);
+  if (!b) asHttp(needToken(owner));
+  if (b!.error) throw new HttpError(502, 'contrack', b!.error);
+  const all = (await db.select().from(contacts).where(inBook(owner))).length;
+  const fresh = await notInContrack(db, owner, b!.contacts);
+  if (!fresh.length) return { added: 0, duplicates: all, failed: 0 };
+  const r = await contrackBulk(db, c, owner, fresh).catch(asHttp);
+  return { added: r.count, duplicates: all - fresh.length, failed: r.failed };
+}
+
 /** One contact added by hand (or from a call): a row, or a Contrack contact. */
 export async function createContact(db: Db, owner: Owner, d: ContactData): Promise<ContactDto> {
   const clean = { ...d, numbers: cleanNumbers(d) };

apps/api/src/contacts/contrack.ts

@@ -2,6 +2,7 @@
 // Contrack (11 §4): a self-hosted contact manager beside the PBX. We call a handful of its REST
 // routes with a person's (or the company account's) personal token, and keep each book in memory
 // for 5 minutes, so name lookups don't wait on it.
+import { randomUUID } from 'node:crypto';
 import { eq } from 'drizzle-orm';
 import { normalizeNumber, type ContactData, type ContactDto } from '@selfphoneng/shared';
 import { AiError, assertLocalUrl } from '../ai/client.ts';
@@ -36,6 +37,7 @@ async function ctk<T>(
     r = await fetch(url, {
       ...init,
       headers: {
+        ...(init.headers as Record<string, string> | undefined),
         Authorization: `Bearer ${token}`,
         ...(init.body ? { 'Content-Type': 'application/json' } : {}),
       },
@@ -204,6 +206,31 @@ export async function contrackCreate(
   return toDto(c, row, owner === null ? 'company' : 'mine');
 }
 
+/** Many contacts into a Contrack book in one import (11 §5, C6); 5,000 at most. */
+export async function contrackBulk(
+  db: Db,
+  c: Contrack,
+  owner: string | null,
+  list: ContactData[],
+): Promise<{ count: number; failed: number }> {
+  const token = await tokenFor(db, c, owner);
+  if (!token) throw needToken(owner);
+  const r = await ctk<{ count: number; failed: number }>(c.url, token, 'api/contacts/bulk', {
+    method: 'POST',
+    headers: { 'X-Import-Id': randomUUID() },
+    body: JSON.stringify(
+      list.slice(0, 5000).map((d) => ({
+        name: d.name,
+        ...(d.company ? { company: d.company } : {}),
+        ...(d.email ? { emails: [{ email: d.email }] } : {}),
+        phones: d.numbers.map((n) => ({ phone: n.number, ...(n.label ? { label: n.label } : {}) })),
+      })),
+    ),
+  });
+  forgetBook(owner);
+  return { count: r.count, failed: typeof r.failed === 'number' ? r.failed : 0 };
+}
+
 /** A timeline entry on a contact (11 §4.4); answers its id. */
 export async function contrackInteraction(
   c: Contrack,