@vellumai/assistant 0.7.1 → 0.7.2

package/src/calls/twilio-rest.ts

@@ -6,6 +6,15 @@
  * config handler. Uses fetch() directly — no twilio npm package.
  */
 
+import {
+  lookupIncomingPhoneNumberSid,
+  twilioAuthHeader,
+  twilioBaseUrl,
+  TwilioRestError,
+  type TwilioWebhookUrls,
+  updatePhoneNumberWebhooks as updateTwilioPhoneNumberWebhooks,
+} from "@vellumai/twilio-client";
+
 import { loadConfig } from "../config/loader.js";
 import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
@@ -56,20 +65,7 @@ export async function hasTwilioCredentials(): Promise<boolean> {
   }
 }
 
-/** Build the HTTP Basic auth header for Twilio API requests. */
-export function twilioAuthHeader(
-  accountSid: string,
-  authToken: string,
-): string {
-  return (
-    "Basic " + Buffer.from(`${accountSid}:${authToken}`).toString("base64")
-  );
-}
-
-/** Build the Twilio REST API base URL for a given account. */
-export function twilioBaseUrl(accountSid: string): string {
-  return `https://api.twilio.com/2010-04-01/Accounts/${accountSid}`;
-}
+export { twilioAuthHeader, twilioBaseUrl };
 
 export interface TwilioPhoneNumber {
   phoneNumber: string;
@@ -210,9 +206,13 @@ export async function provisionPhoneNumber(
   };
 }
 
-export interface WebhookUrls {
-  voiceUrl: string;
-  statusCallbackUrl: string;
+export type WebhookUrls = TwilioWebhookUrls;
+
+function rethrowAsProviderError(err: unknown): never {
+  if (err instanceof TwilioRestError) {
+    throw new ProviderError(err.message, "twilio", err.status);
+  }
+  throw err;
 }
 
 /**
@@ -227,69 +227,15 @@ export async function updatePhoneNumberWebhooks(
   phoneNumber: string,
   webhooks: WebhookUrls,
 ): Promise<void> {
-  // First, find the SID for this phone number
-  const listRes = await fetch(
-    `${twilioBaseUrl(
+  try {
+    await updateTwilioPhoneNumberWebhooks({
       accountSid,
-    )}/IncomingPhoneNumbers.json?PhoneNumber=${encodeURIComponent(
+      authToken,
       phoneNumber,
-    )}`,
-    {
-      method: "GET",
-      headers: { Authorization: twilioAuthHeader(accountSid, authToken) },
-    },
-  );
-
-  if (!listRes.ok) {
-    const text = await listRes.text();
-    throw new ProviderError(
-      `Twilio API error ${listRes.status} looking up phone number: ${text}`,
-      "twilio",
-      listRes.status,
-    );
-  }
-
-  const listData = (await listRes.json()) as {
-    incoming_phone_numbers: Array<{ sid: string; phone_number: string }>;
-  };
-
-  const match = listData.incoming_phone_numbers.find(
-    (n) => n.phone_number === phoneNumber,
-  );
-  if (!match) {
-    throw new ProviderError(
-      `Phone number ${phoneNumber} not found on Twilio account ${accountSid}`,
-      "twilio",
-    );
-  }
-
-  // Update the phone number's webhook configuration
-  const body = new URLSearchParams({
-    VoiceUrl: webhooks.voiceUrl,
-    VoiceMethod: "POST",
-    StatusCallback: webhooks.statusCallbackUrl,
-    StatusCallbackMethod: "POST",
-  });
-
-  const updateRes = await fetch(
-    `${twilioBaseUrl(accountSid)}/IncomingPhoneNumbers/${match.sid}.json`,
-    {
-      method: "POST",
-      headers: {
-        Authorization: twilioAuthHeader(accountSid, authToken),
-        "Content-Type": "application/x-www-form-urlencoded",
-      },
-      body: body.toString(),
-    },
-  );
-
-  if (!updateRes.ok) {
-    const text = await updateRes.text();
-    throw new ProviderError(
-      `Twilio API error ${updateRes.status} updating webhooks: ${text}`,
-      "twilio",
-      updateRes.status,
-    );
+      webhooks,
+    });
+  } catch (err) {
+    rethrowAsProviderError(err);
   }
 }
 
@@ -302,35 +248,17 @@ async function getPhoneNumberSid(
   authToken: string,
   phoneNumber: string,
 ): Promise<string | null> {
-  const res = await fetch(
-    `${twilioBaseUrl(
-      accountSid,
-    )}/IncomingPhoneNumbers.json?PhoneNumber=${encodeURIComponent(
-      phoneNumber,
-    )}`,
-    {
-      method: "GET",
-      headers: { Authorization: twilioAuthHeader(accountSid, authToken) },
-    },
-  );
-
-  if (!res.ok) {
-    const text = await res.text();
-    throw new ProviderError(
-      `Twilio API error ${res.status} looking up phone number SID: ${text}`,
-      "twilio",
-      res.status,
+  try {
+    return (
+      (await lookupIncomingPhoneNumberSid({
+        accountSid,
+        authToken,
+        phoneNumber,
+      })) ?? null
     );
+  } catch (err) {
+    rethrowAsProviderError(err);
   }
-
-  const data = (await res.json()) as {
-    incoming_phone_numbers: Array<{ sid: string; phone_number: string }>;
-  };
-
-  const match = data.incoming_phone_numbers.find(
-    (n) => n.phone_number === phoneNumber,
-  );
-  return match?.sid ?? null;
 }
 
 /**

package/src/calls/twilio-routes.ts

@@ -21,11 +21,13 @@
  *   server-side.
  */
 
-import { loadConfig } from "../config/loader.js";
 import {
-  getTwilioMediaStreamUrl,
-  getTwilioRelayUrl,
-} from "../inbound/public-ingress-urls.js";
+  buildTwilioMediaStreamUrl,
+  buildTwilioRelayUrl,
+  TWILIO_PUBLIC_BASE_URL_PLACEHOLDER,
+} from "@vellumai/service-contracts/twilio-ingress";
+
+import { loadConfig } from "../config/loader.js";
 import { getProviderEntry } from "../providers/speech-to-text/provider-catalog.js";
 import {
   BadRequestError,
@@ -444,7 +446,6 @@ function buildVoiceWebhookTwiml(
     // calls don't fail entirely on a misconfigured provider.
     return buildConversationRelayTwiml(
       callSessionId,
-      cfg,
       profile,
       sessionContext,
       verificationSessionId,
@@ -457,7 +458,6 @@ function buildVoiceWebhookTwiml(
   if (strategy.strategy === "conversation-relay-native") {
     return buildConversationRelayTwiml(
       callSessionId,
-      cfg,
       profile,
       sessionContext,
       verificationSessionId,
@@ -500,7 +500,6 @@ function buildVoiceWebhookTwiml(
     // through the relay server which supports it natively.
     return buildConversationRelayTwiml(
       callSessionId,
-      cfg,
       profile,
       sessionContext,
       verificationSessionId,
@@ -508,7 +507,7 @@ function buildVoiceWebhookTwiml(
     );
   }
 
-  return buildMediaStreamTwiml(callSessionId, cfg, verificationSessionId);
+  return buildMediaStreamTwiml(callSessionId, verificationSessionId);
 }
 
 /**
@@ -516,7 +515,6 @@ function buildVoiceWebhookTwiml(
  */
 function buildConversationRelayTwiml(
   callSessionId: string,
-  cfg: ReturnType<typeof loadConfig>,
   profile: ReturnType<typeof resolveVoiceQualityProfile>,
   sessionContext: {
     task: string | null;
@@ -538,7 +536,7 @@ function buildConversationRelayTwiml(
     interruptSensitivity: profile.interruptSensitivity,
   };
 
-  const relayUrl = getTwilioRelayUrl(cfg);
+  const relayUrl = buildTwilioRelayUrl(TWILIO_PUBLIC_BASE_URL_PLACEHOLDER);
   const welcomeGreeting = buildWelcomeGreeting(sessionContext?.task ?? null);
   const relayToken = TWILIO_RELAY_TOKEN_PLACEHOLDER;
 
@@ -572,10 +570,11 @@ function buildConversationRelayTwiml(
  */
 function buildMediaStreamTwiml(
   callSessionId: string,
-  cfg: ReturnType<typeof loadConfig>,
   verificationSessionId: string | null | undefined,
 ): string {
-  const streamUrl = getTwilioMediaStreamUrl(cfg);
+  const streamUrl = buildTwilioMediaStreamUrl(
+    TWILIO_PUBLIC_BASE_URL_PLACEHOLDER,
+  );
   const relayToken = TWILIO_RELAY_TOKEN_PLACEHOLDER;
 
   const customParameters: Record<string, string> | undefined =

package/src/channels/types.ts

@@ -91,17 +91,18 @@ export function isInteractiveInterface(id: InterfaceId): boolean {
 
 /**
  * Host proxy capabilities that an interface can support. The macOS client
- * supports all four; the chrome-extension interface only supports
+ * supports all five; the chrome-extension interface only supports
  * host_browser (via the Chrome DevTools Protocol proxy).
  */
 export type HostProxyCapability =
   | "host_bash"
   | "host_file"
   | "host_cu"
-  | "host_browser";
+  | "host_browser"
+  | "host_app_control";
 
 /**
- * Interfaces that support the full desktop host-proxy set (all four
+ * Interfaces that support the full desktop host-proxy set (all five
  * `HostProxyCapability` values). This is the capability-level identity used
  * by the discriminated transport metadata union and by the
  * `supportsHostProxy(id)` type predicate.
@@ -135,10 +136,10 @@ export function supportsHostProxy(
   id: InterfaceId,
   capability?: HostProxyCapability,
 ): boolean {
-  // macOS supports all four host proxy capabilities including host_browser.
-  // The host_browser proxy is provisioned via the assistant event hub. When no
-  // extension is connected, browser tools fall through to cdp-inspect/local
-  // via the CDP factory's candidate chain.
+  // macOS supports all five host proxy capabilities including host_browser
+  // and host_app_control. The host_browser proxy is provisioned via the
+  // assistant event hub. When no extension is connected, browser tools fall
+  // through to cdp-inspect/local via the CDP factory's candidate chain.
   if (id === "macos") return true;
   if (id === "chrome-extension" && capability === "host_browser") return true;
   return false;

package/src/cli/commands/__tests__/backup.test.ts

@@ -9,7 +9,6 @@
  * or via a commander program (for end-to-end arg parsing).
  */
 
-import { Readable } from "node:stream";
 import {
   afterEach,
   beforeEach,
@@ -130,8 +129,8 @@ let mockDaemonRunning = false;
 const recoveryCallOrder: string[] = [];
 
 /** Number of times each recovery helper was invoked. */
-let mockResetDbCalls = 0;
-let mockInvalidateConfigCacheCalls = 0;
+let _mockResetDbCalls = 0;
+let _mockInvalidateConfigCacheCalls = 0;
 
 /** Log calls captured by the mocked logger. */
 let mockLogInfo: string[] = [];
@@ -167,7 +166,7 @@ mock.module("../../../config/loader.js", () => ({
     backup: getComputedBackupConfig(),
   }),
   invalidateConfigCache: () => {
-    mockInvalidateConfigCacheCalls += 1;
+    _mockInvalidateConfigCacheCalls += 1;
     recoveryCallOrder.push("invalidateConfigCache");
   },
 }));
@@ -178,7 +177,7 @@ mock.module("../../../daemon/daemon-control.js", () => ({
 
 mock.module("../../../memory/db-connection.js", () => ({
   resetDb: () => {
-    mockResetDbCalls += 1;
+    _mockResetDbCalls += 1;
     recoveryCallOrder.push("resetDb");
   },
 }));
@@ -323,9 +322,6 @@ const {
   handleDestinationsList,
   handleStatus,
   handleList,
-  handleCreate,
-  handleVerify,
-  handleRestore,
   registerBackupCommand,
 } = backupMod;
 
@@ -342,8 +338,8 @@ beforeEach(() => {
   mockLogError = [];
   mockCreateShouldThrow = null;
   mockDaemonRunning = false;
-  mockResetDbCalls = 0;
-  mockInvalidateConfigCacheCalls = 0;
+  _mockResetDbCalls = 0;
+  _mockInvalidateConfigCacheCalls = 0;
   recoveryCallOrder.length = 0;
   process.exitCode = 0;
   mockVerifyResult = { valid: true };
@@ -768,273 +764,6 @@ describe("handleList", () => {
 // create
 // ---------------------------------------------------------------------------
 
-describe("handleCreate", () => {
-  test("renders successful snapshot result with empty offsite", async () => {
-    await handleCreate();
-    const out = mockLogInfo.join("\n");
-    expect(out).toContain("Created snapshot:");
-    expect(out).toContain("backup-20260411-093000.vbundle");
-    expect(out).toContain("offsite: (none)");
-  });
-
-  test("renders per-destination outcome mix (ok, skipped, error)", async () => {
-    mockCreateSnapshotResult = {
-      ...mockCreateSnapshotResult,
-      offsite: [
-        {
-          destination: { path: "/ok", encrypt: true },
-          entry: {
-            path: "/ok/f.vbundle.enc",
-            filename: "f.vbundle.enc",
-            createdAt: new Date(),
-            sizeBytes: 100,
-            encrypted: true,
-          },
-        },
-        {
-          destination: { path: "/skipped", encrypt: true },
-          entry: null,
-          skipped: "parent-missing",
-        },
-        {
-          destination: { path: "/broken", encrypt: false },
-          entry: null,
-          error: "disk full",
-        },
-      ],
-    };
-    await handleCreate();
-    const out = mockLogInfo.join("\n");
-    expect(out).toContain("ok       /ok");
-    expect(out).toContain("skipped  /skipped");
-    expect(out).toContain("error    /broken");
-    expect(out).toContain("disk full");
-  });
-
-  test("concurrency error prints clear message", async () => {
-    mockCreateShouldThrow = new Error("snapshot in progress");
-    await handleCreate();
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) =>
-        m.toLowerCase().includes("already running"),
-      ),
-    ).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// verify
-// ---------------------------------------------------------------------------
-
-describe("handleVerify", () => {
-  test("returns valid result from verifySnapshot", async () => {
-    mockVerifyResult = {
-      valid: true,
-      manifest: {
-        schema_version: "1.0.0",
-        created_at: "2026-04-11T09:30:00Z",
-        source: "backup-worker",
-        files: [],
-        manifest_sha256: "abc",
-      },
-    };
-    await handleVerify("/tmp/local/backup.vbundle");
-    const out = mockLogInfo.join("\n");
-    expect(out).toContain("OK:");
-    expect(out).toContain("1.0.0");
-    expect(process.exitCode).toBe(0);
-  });
-
-  test("propagates invalid result with error details", async () => {
-    mockVerifyResult = { valid: false, error: "bad checksum" };
-    await handleVerify("/tmp/local/backup.vbundle");
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) => m.includes("Invalid:")),
-    ).toBe(true);
-    expect(
-      mockLogError.some((m) => m.includes("bad checksum")),
-    ).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// restore
-// ---------------------------------------------------------------------------
-
-/**
- * Replace `process.stdin` with a readable stream that emits the given line.
- * `readline.createInterface` consumes this as a single line so prompt-based
- * confirmation tests stay deterministic.
- */
-function stubStdin(input: string): () => void {
-  const original = process.stdin;
-  const stream = Readable.from([input + "\n"]) as NodeJS.ReadableStream;
-  Object.defineProperty(process, "stdin", {
-    value: stream,
-    writable: true,
-    configurable: true,
-  });
-  return () => {
-    Object.defineProperty(process, "stdin", {
-      value: original,
-      writable: true,
-      configurable: true,
-    });
-  };
-}
-
-describe("handleRestore", () => {
-  test("--yes flag bypasses confirmation and calls restoreFromSnapshot", async () => {
-    await handleRestore({
-      path: "/tmp/local/backup-20260411-093000.vbundle",
-      yes: true,
-    });
-    expect(process.exitCode).toBe(0);
-    const out = mockLogInfo.join("\n");
-    expect(out).toContain("Restored from");
-    expect(out).toContain("files restored: 42");
-  });
-
-  test("without --yes and 'n' answer aborts", async () => {
-    const restore = stubStdin("n");
-    try {
-      await handleRestore({
-        path: "/tmp/local/backup-20260411-093000.vbundle",
-      });
-    } finally {
-      restore();
-    }
-    expect(process.exitCode).toBe(0);
-    const out = mockLogInfo.join("\n");
-    expect(out).toContain("Restore cancelled");
-  });
-
-  test("without --path and without --latest errors", async () => {
-    await handleRestore({});
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) => m.includes("--path")),
-    ).toBe(true);
-  });
-
-  test("both --path and --latest errors", async () => {
-    await handleRestore({
-      path: "/tmp/x.vbundle",
-      latest: true,
-      yes: true,
-    });
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) => m.includes("Cannot combine")),
-    ).toBe(true);
-  });
-
-  test("--latest with no local snapshots errors", async () => {
-    mockSnapshots["/tmp/local"] = [];
-    await handleRestore({ latest: true, yes: true });
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) => m.includes("No local snapshots")),
-    ).toBe(true);
-  });
-
-  test("--latest picks newest local snapshot", async () => {
-    mockSnapshots["/tmp/local"] = [
-      {
-        path: "/tmp/local/newest.vbundle",
-        filename: "newest.vbundle",
-        createdAt: new Date("2026-04-11T12:00:00Z"),
-        sizeBytes: 1024,
-        encrypted: false,
-      },
-      {
-        path: "/tmp/local/older.vbundle",
-        filename: "older.vbundle",
-        createdAt: new Date("2026-04-10T12:00:00Z"),
-        sizeBytes: 1024,
-        encrypted: false,
-      },
-    ];
-    await handleRestore({ latest: true, yes: true });
-    expect(process.exitCode).toBe(0);
-    expect(mockLogInfo.some((m) => m.includes("newest.vbundle"))).toBe(
-      true,
-    );
-  });
-
-  test("refuses to run while the assistant is running (no --force)", async () => {
-    // Safety gate: the CLI must refuse to restore against a live assistant
-    // unless --force is passed. Restoring under a running assistant is
-    // dangerous — the open SQLite handle, cached config, and cached trust
-    // rules all contradict the on-disk state after the bundle is written.
-    mockDaemonRunning = true;
-
-    await handleRestore({
-      path: "/tmp/local/backup-20260411-093000.vbundle",
-      yes: true,
-    });
-
-    expect(process.exitCode).toBe(1);
-    expect(
-      mockLogError.some((m) =>
-        m.toLowerCase().includes("assistant is running"),
-      ),
-    ).toBe(true);
-    // restoreFromSnapshot must not have been called — the safety gate
-    // bails before reaching the recovery sequence.
-    expect(mockResetDbCalls).toBe(0);
-    expect(recoveryCallOrder).toEqual([]);
-  });
-
-  test("--force overrides the daemon-running refusal and still runs recovery sequence", async () => {
-    mockDaemonRunning = true;
-
-    await handleRestore({
-      path: "/tmp/local/backup-20260411-093000.vbundle",
-      yes: true,
-      force: true,
-    });
-
-    expect(process.exitCode).toBe(0);
-    // Recovery sequence must still run even with --force — the flag only
-    // overrides the running-assistant refusal, not the DB reset or cache
-    // invalidation.
-    expect(mockResetDbCalls).toBe(1);
-    expect(mockInvalidateConfigCacheCalls).toBe(1);
-    expect(recoveryCallOrder).toEqual([
-      "resetDb",
-      "restoreFromSnapshot",
-      "invalidateConfigCache",    ]);
-  });
-
-  test("successful restore runs resetDb, restore, then cache invalidation in order", async () => {
-    // Regression test for the restore-corrupts-daemon-state gap. The CLI
-    // handler must mirror the HTTP handler's recovery sequence so an
-    // in-process CLI invocation leaves the shared runtime in a consistent
-    // state.
-    mockDaemonRunning = false;
-
-    await handleRestore({
-      path: "/tmp/local/backup-20260411-093000.vbundle",
-      yes: true,
-    });
-
-    expect(process.exitCode).toBe(0);
-    expect(mockResetDbCalls).toBe(1);
-    expect(mockInvalidateConfigCacheCalls).toBe(1);
-    expect(recoveryCallOrder).toEqual([
-      "resetDb",
-      "restoreFromSnapshot",
-      "invalidateConfigCache",    ]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// End-to-end: via Commander program
-// ---------------------------------------------------------------------------
-
 async function runProgram(
   args: string[],
 ): Promise<{ exitCode: number }> {