@remnic/capture-audio 9.24.0

package/dist/index.js

@@ -0,0 +1,405 @@
+// openclaw-engram: Local-first memory plugin
+import {
+  CAPTURE_AUDIO_VERSION,
+  CaptureConfigError,
+  CaptureInputError,
+  ConversationAssembler,
+  DEFAULT_CONVERSATION_GAP_MINUTES,
+  DEFAULT_HOST,
+  DEFAULT_PORT,
+  DEFAULT_SERVICE_LABEL,
+  HELPER_BIN_ENV,
+  REPLAY_COMMIT_BATCH,
+  SELF_SPEAKER_ID,
+  SPOOL_SCHEMA_VERSION,
+  SpeakerClusterer,
+  Spool,
+  assembleConversations,
+  assertValidTimezone,
+  bearerFromHeader,
+  buildHelperArgs,
+  buildWhisperArgs,
+  captureBaseDir,
+  capturePaths,
+  chunkStableId,
+  cosineSimilarity,
+  createChunkProcessor,
+  createLiveCapture,
+  createNativeCaptureRunner,
+  createRequestHandler,
+  decodeCursor,
+  dedupeCrossChannel,
+  defaultDaemonConfig,
+  downloadWhisperModel,
+  encodeCursor,
+  enrollSelf,
+  enumerateDevices,
+  expandTilde,
+  generateToken,
+  helperPackageSpecifier,
+  ingestReplayDir,
+  ingestReplayDirResponsive,
+  installService,
+  isLoopbackHost,
+  isProcessAlive,
+  loadDaemonConfig,
+  loadOrCreateToken,
+  parseChunkEvent,
+  parseDaemonConfig,
+  parseLimit,
+  parseTranscriptDate,
+  parseWhisperJson,
+  planService,
+  pruneExpiredRawAudio,
+  readPidFile,
+  readPidRecord,
+  removePidFile,
+  removePidFileIfOwner,
+  renderLaunchAgent,
+  renderSystemdUnit,
+  resolveHelperBinary,
+  resolveModelPath,
+  runCapture,
+  runWhisperCli,
+  serializeDaemonConfig,
+  startDaemon,
+  superviseReplay,
+  tokensMatch,
+  transcribeWithWhisper,
+  uninstallService,
+  whisperModelUrl,
+  wordJaccard,
+  writePidFile
+} from "./chunk-BRVXKUZY.js";
+
+// src/vad.ts
+import { statSync } from "fs";
+function sileroVadConfig(input) {
+  if (typeof input.modelPath !== "string" || input.modelPath.trim() === "") {
+    throw new CaptureConfigError("Silero VAD modelPath must be a non-empty string");
+  }
+  if (!Number.isFinite(input.minSpeechMs) || input.minSpeechMs <= 0) {
+    throw new CaptureConfigError("Silero VAD minSpeechMs must be positive");
+  }
+  const minSilenceMs = input.minSilenceMs ?? 500;
+  const maxSpeechMs = input.maxSpeechMs ?? 3e4;
+  const threshold = input.threshold ?? 0.5;
+  const threads = input.threads ?? 1;
+  if (!Number.isFinite(minSilenceMs) || minSilenceMs < 0 || !Number.isFinite(maxSpeechMs) || maxSpeechMs <= 0) {
+    throw new CaptureConfigError("Silero VAD duration settings are invalid");
+  }
+  if (maxSpeechMs < input.minSpeechMs) {
+    throw new CaptureConfigError("Silero VAD maxSpeechMs must be greater than or equal to minSpeechMs");
+  }
+  if (!Number.isFinite(threshold) || threshold <= 0 || threshold >= 1) {
+    throw new CaptureConfigError("Silero VAD threshold must be between 0 and 1");
+  }
+  if (!Number.isInteger(threads) || threads <= 0) {
+    throw new CaptureConfigError("Silero VAD threads must be a positive integer");
+  }
+  return {
+    config: {
+      sileroVad: {
+        model: expandTilde(input.modelPath),
+        threshold,
+        minSpeechDuration: input.minSpeechMs / 1e3,
+        minSilenceDuration: minSilenceMs / 1e3,
+        maxSpeechDuration: maxSpeechMs / 1e3,
+        windowSize: 512
+      },
+      sampleRate: 16e3,
+      debug: false,
+      numThreads: threads
+    },
+    bufferSeconds: 60
+  };
+}
+function resolveSherpaExport(module) {
+  const candidates = [module, module?.default];
+  for (const candidate of candidates) {
+    if (candidate && typeof candidate === "object" && typeof candidate.Vad === "function") {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function loadSherpaOnnx(importModule = (specifier) => import(specifier)) {
+  const specifier = "sherpa-onnx-node";
+  let module;
+  try {
+    module = await importModule(specifier);
+  } catch (error) {
+    const err = error;
+    const message = error instanceof Error ? error.message : "";
+    const packageMissing = err.code === "ERR_MODULE_NOT_FOUND" && err.requireStack === void 0 && message.includes(`package '${specifier}'`);
+    if (packageMissing) {
+      throw new CaptureConfigError(
+        "Silero VAD requires optional dependency sherpa-onnx-node; install it before enabling VAD"
+      );
+    }
+    throw new CaptureConfigError(
+      "Silero VAD could not load the installed sherpa-onnx-node native runtime; verify its native build and shared-library dependencies"
+    );
+  }
+  const resolved = resolveSherpaExport(module);
+  if (!resolved) {
+    throw new CaptureConfigError("sherpa-onnx-node does not expose the Vad API required by capture-audio");
+  }
+  return resolved;
+}
+function isRegularFile(filePath) {
+  try {
+    return statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+async function createSileroVad(input, load = loadSherpaOnnx, exists = isRegularFile) {
+  const { config, bufferSeconds } = sileroVadConfig(input);
+  const modelPath = expandTilde(input.modelPath);
+  if (!exists(modelPath)) {
+    throw new CaptureConfigError(`Silero VAD model not found at ${modelPath}; set vad.modelPath to a readable model file`);
+  }
+  const { Vad } = await load();
+  return new Vad(config, bufferSeconds);
+}
+
+// src/connector.ts
+import { readFileSync } from "fs";
+import {
+  registerWearableConnector,
+  getWearableConnector
+} from "@remnic/core";
+var DESKTOP_SOURCE_ID = "desktop";
+var DESKTOP_DISPLAY_NAME = "Desktop audio";
+var DEFAULT_BASE_URL = `http://${DEFAULT_HOST}:${DEFAULT_PORT}`;
+var PROBE_TIMEOUT_MS = 15e3;
+function withTimeout(signal) {
+  const timeout = AbortSignal.timeout(PROBE_TIMEOUT_MS);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+var DesktopDaemonError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DesktopDaemonError";
+  }
+};
+function baseUrlIsLoopback(baseUrl) {
+  try {
+    return isLoopbackHost(new URL(baseUrl).hostname);
+  } catch {
+    return false;
+  }
+}
+function resolveCaptureAudioToken(configured, baseUrl, env = process.env) {
+  if (typeof configured === "string" && configured.trim().length > 0) return configured.trim();
+  const fromEnv = env.REMNIC_CAPTURE_AUDIO_TOKEN;
+  if (typeof fromEnv === "string" && fromEnv.trim().length > 0) return fromEnv.trim();
+  if (baseUrlIsLoopback(baseUrl)) {
+    try {
+      const token = readFileSync(capturePaths().tokenPath, "utf8").trim();
+      if (token.length > 0) return token;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function daemonSegmentToWearable(seg) {
+  return {
+    text: seg.textRaw,
+    // The wearables speaker registry owns naming; the connector only
+    // supplies the stable per-source key (spk_<n> | self | "unknown").
+    speakerKey: seg.speakerKey ?? "unknown",
+    isWearer: seg.isWearer,
+    startIso: seg.startUtc,
+    endIso: seg.endUtc
+  };
+}
+function daemonConversationToWearable(conv) {
+  return {
+    id: conv.id,
+    source: DESKTOP_SOURCE_ID,
+    startIso: conv.startedAtUtc,
+    endIso: conv.endedAtUtc ?? void 0,
+    segments: conv.segments.map(daemonSegmentToWearable)
+  };
+}
+function trimTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) end--;
+  return value.slice(0, end);
+}
+var DesktopClient = class {
+  #baseUrl;
+  #getToken;
+  constructor(options) {
+    this.#baseUrl = trimTrailingSlashes(options.baseUrl);
+    this.#getToken = options.getToken;
+  }
+  #headers() {
+    const token = this.#getToken();
+    return token ? { authorization: `Bearer ${token}` } : {};
+  }
+  async verifyAuth(signal) {
+    let res;
+    try {
+      res = await fetch(`${this.#baseUrl}/v1/health`, { headers: this.#headers(), signal: withTimeout(signal) });
+    } catch (err) {
+      if (signal?.aborted) throw err;
+      return { ok: false, detail: "unreachable" };
+    }
+    if (res.status === 401) return { ok: false, detail: "unauthorized" };
+    if (!res.ok) return { ok: false, detail: `HTTP ${res.status}` };
+    let body;
+    try {
+      body = await res.json();
+    } catch (err) {
+      if (signal?.aborted) throw err;
+      body = {};
+    }
+    if (body.ok === true) {
+      return { ok: true, detail: typeof body.version === "string" ? `capture-audio ${body.version}` : void 0 };
+    }
+    return { ok: false, detail: "unhealthy" };
+  }
+  async fetchConversations(opts) {
+    let res;
+    try {
+      const url = new URL(`${this.#baseUrl}/v1/conversations`);
+      url.searchParams.set("date", opts.date);
+      url.searchParams.set("timezone", opts.timezone);
+      if (opts.cursor) url.searchParams.set("cursor", opts.cursor);
+      res = await fetch(url, { headers: this.#headers(), signal: withTimeout(opts.signal) });
+    } catch (err) {
+      if (opts.signal?.aborted) throw err;
+      throw new DesktopDaemonError(
+        `desktop capture daemon unreachable at ${this.#baseUrl} (is remnic-capture-audio running?)`
+      );
+    }
+    if (!res.ok) {
+      throw new DesktopDaemonError(`desktop capture daemon returned HTTP ${res.status}`);
+    }
+    let page;
+    try {
+      page = await res.json();
+    } catch (err) {
+      if (opts.signal?.aborted) throw err;
+      throw new DesktopDaemonError("desktop capture daemon returned a non-JSON conversations response");
+    }
+    if (!page || !Array.isArray(page.conversations)) {
+      throw new DesktopDaemonError("desktop capture daemon returned a malformed conversations page");
+    }
+    return {
+      conversations: page.conversations.map(daemonConversationToWearable),
+      nextCursor: page.nextCursor ?? null
+    };
+  }
+};
+function createDesktopConnector(options) {
+  const baseUrl = options.settings.baseUrl?.trim() || DEFAULT_BASE_URL;
+  let client = null;
+  const getClient = () => {
+    if (!client) {
+      client = new DesktopClient({ baseUrl, getToken: () => resolveCaptureAudioToken(options.settings.apiKey, baseUrl) });
+    }
+    return client;
+  };
+  return {
+    id: DESKTOP_SOURCE_ID,
+    displayName: DESKTOP_DISPLAY_NAME,
+    verifyAuth: (signal) => getClient().verifyAuth(signal),
+    fetchConversations: (opts) => getClient().fetchConversations(opts)
+  };
+}
+var wearableConnectorRegistration = {
+  id: DESKTOP_SOURCE_ID,
+  displayName: DESKTOP_DISPLAY_NAME,
+  factory: createDesktopConnector
+};
+function ensureDesktopConnectorRegistered() {
+  if (getWearableConnector(DESKTOP_SOURCE_ID) !== void 0) return false;
+  registerWearableConnector(wearableConnectorRegistration);
+  return true;
+}
+ensureDesktopConnectorRegistered();
+export {
+  CAPTURE_AUDIO_VERSION,
+  CaptureConfigError,
+  CaptureInputError,
+  ConversationAssembler,
+  DEFAULT_CONVERSATION_GAP_MINUTES,
+  DEFAULT_HOST,
+  DEFAULT_PORT,
+  DEFAULT_SERVICE_LABEL,
+  DESKTOP_SOURCE_ID,
+  DesktopDaemonError,
+  HELPER_BIN_ENV,
+  REPLAY_COMMIT_BATCH,
+  SELF_SPEAKER_ID,
+  SPOOL_SCHEMA_VERSION,
+  SpeakerClusterer,
+  Spool,
+  assembleConversations,
+  assertValidTimezone,
+  bearerFromHeader,
+  buildHelperArgs,
+  buildWhisperArgs,
+  captureBaseDir,
+  capturePaths,
+  chunkStableId,
+  cosineSimilarity,
+  createChunkProcessor,
+  createDesktopConnector,
+  createLiveCapture,
+  createNativeCaptureRunner,
+  createRequestHandler,
+  createSileroVad,
+  daemonConversationToWearable,
+  decodeCursor,
+  dedupeCrossChannel,
+  defaultDaemonConfig,
+  downloadWhisperModel,
+  encodeCursor,
+  enrollSelf,
+  ensureDesktopConnectorRegistered,
+  enumerateDevices,
+  generateToken,
+  helperPackageSpecifier,
+  ingestReplayDir,
+  ingestReplayDirResponsive,
+  installService,
+  isProcessAlive,
+  loadDaemonConfig,
+  loadOrCreateToken,
+  loadSherpaOnnx,
+  parseChunkEvent,
+  parseDaemonConfig,
+  parseLimit,
+  parseTranscriptDate,
+  parseWhisperJson,
+  planService,
+  pruneExpiredRawAudio,
+  readPidFile,
+  readPidRecord,
+  removePidFile,
+  removePidFileIfOwner,
+  renderLaunchAgent,
+  renderSystemdUnit,
+  resolveCaptureAudioToken,
+  resolveHelperBinary,
+  resolveModelPath,
+  runCapture,
+  runWhisperCli,
+  serializeDaemonConfig,
+  sileroVadConfig,
+  startDaemon,
+  superviseReplay,
+  tokensMatch,
+  transcribeWithWhisper,
+  uninstallService,
+  wearableConnectorRegistration,
+  whisperModelUrl,
+  wordJaccard,
+  writePidFile
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/vad.ts","../src/connector.ts"],"sourcesContent":["import { statSync } from \"node:fs\";\n\nimport { CaptureConfigError } from \"./errors.js\";\nimport { expandTilde } from \"./paths.js\";\n\n\nexport interface SileroVadInput {\n  modelPath: string;\n  minSpeechMs: number;\n  minSilenceMs?: number;\n  maxSpeechMs?: number;\n  threshold?: number;\n  threads?: number;\n}\n\nexport interface SherpaOnnxModule {\n  Vad: new (config: unknown, bufferSeconds: number) => unknown;\n}\n\nexport function sileroVadConfig(input: SileroVadInput): { config: object; bufferSeconds: number } {\n  if (typeof input.modelPath !== \"string\" || input.modelPath.trim() === \"\") {\n    throw new CaptureConfigError(\"Silero VAD modelPath must be a non-empty string\");\n  }\n  if (!Number.isFinite(input.minSpeechMs) || input.minSpeechMs <= 0) {\n    throw new CaptureConfigError(\"Silero VAD minSpeechMs must be positive\");\n  }\n  const minSilenceMs = input.minSilenceMs ?? 500;\n  const maxSpeechMs = input.maxSpeechMs ?? 30_000;\n  const threshold = input.threshold ?? 0.5;\n  const threads = input.threads ?? 1;\n  if (!Number.isFinite(minSilenceMs) || minSilenceMs < 0 || !Number.isFinite(maxSpeechMs) || maxSpeechMs <= 0) {\n    throw new CaptureConfigError(\"Silero VAD duration settings are invalid\");\n  }\n  if (maxSpeechMs < input.minSpeechMs) {\n    throw new CaptureConfigError(\"Silero VAD maxSpeechMs must be greater than or equal to minSpeechMs\");\n  }\n  if (!Number.isFinite(threshold) || threshold <= 0 || threshold >= 1) {\n    throw new CaptureConfigError(\"Silero VAD threshold must be between 0 and 1\");\n  }\n  if (!Number.isInteger(threads) || threads <= 0) {\n    throw new CaptureConfigError(\"Silero VAD threads must be a positive integer\");\n  }\n  return {\n    config: {\n      sileroVad: {\n        model: expandTilde(input.modelPath),\n        threshold,\n        minSpeechDuration: input.minSpeechMs / 1_000,\n        minSilenceDuration: minSilenceMs / 1_000,\n        maxSpeechDuration: maxSpeechMs / 1_000,\n        windowSize: 512,\n      },\n      sampleRate: 16_000,\n      debug: false,\n      numThreads: threads,\n    },\n    bufferSeconds: 60,\n  };\n}\n\nexport function resolveSherpaExport(module: unknown): SherpaOnnxModule | null {\n  const candidates = [module, (module as { default?: unknown } | null)?.default];\n  for (const candidate of candidates) {\n    if (candidate && typeof candidate === \"object\" && typeof (candidate as SherpaOnnxModule).Vad === \"function\") {\n      return candidate as SherpaOnnxModule;\n    }\n  }\n  return null;\n}\n\nexport async function loadSherpaOnnx(\n  importModule: (specifier: string) => Promise<unknown> = (specifier) => import(specifier),\n): Promise<SherpaOnnxModule> {\n  // Computed specifier keeps the optional sherpa-onnx-node peer out of the static\n  // dependency graph so the package builds and runs without it installed.\n  const specifier = \"sherpa-onnx-\" + \"node\";\n  let module: unknown;\n  try {\n    module = await importModule(specifier);\n  } catch (error) {\n    // A genuinely absent package surfaces as ERR_MODULE_NOT_FOUND naming the\n    // specifier as a package, with no require stack. An installed-but-broken\n    // package (missing native .node, dlopen failure) has a different code\n    // and/or a require stack, so it must NOT be reported as \"not installed\".\n    const err = error as NodeJS.ErrnoException & { requireStack?: unknown };\n    const message = error instanceof Error ? error.message : \"\";\n    const packageMissing =\n      err.code === \"ERR_MODULE_NOT_FOUND\" &&\n      err.requireStack === undefined &&\n      message.includes(`package '${specifier}'`);\n    if (packageMissing) {\n      throw new CaptureConfigError(\n        \"Silero VAD requires optional dependency sherpa-onnx-node; install it before enabling VAD\",\n      );\n    }\n    // Installed but unusable. Report that distinctly, but keep the message\n    // operator-safe: never echo the raw error (it can leak absolute native\n    // library paths), per the CaptureConfigError contract.\n    throw new CaptureConfigError(\n      \"Silero VAD could not load the installed sherpa-onnx-node native runtime; verify its native build and shared-library dependencies\",\n    );\n  }\n  const resolved = resolveSherpaExport(module);\n  if (!resolved) {\n    throw new CaptureConfigError(\"sherpa-onnx-node does not expose the Vad API required by capture-audio\");\n  }\n  return resolved;\n}\n\nfunction isRegularFile(filePath: string): boolean {\n  try {\n    return statSync(filePath).isFile();\n  } catch {\n    return false;\n  }\n}\n\nexport async function createSileroVad(\n  input: SileroVadInput,\n  load: () => Promise<SherpaOnnxModule> = loadSherpaOnnx,\n  exists: (path: string) => boolean = isRegularFile,\n): Promise<unknown> {\n  const { config, bufferSeconds } = sileroVadConfig(input);\n  const modelPath = expandTilde(input.modelPath);\n  if (!exists(modelPath)) {\n    throw new CaptureConfigError(`Silero VAD model not found at ${modelPath}; set vad.modelPath to a readable model file`);\n  }\n  const { Vad } = await load();\n  return new Vad(config, bufferSeconds);\n}\n","/**\n * `desktop` wearable source connector (issue #1897, component 4).\n *\n * À-la-carte optional companion of @remnic/core: installing core alone\n * never pulls this in; core discovers it at runtime via a\n * computed-specifier dynamic import (registry entry {id:\"desktop\",\n * suffix:\"capture-audio\"}) or via a direct import of @remnic/capture-audio,\n * which self-registers idempotently.\n *\n * The connector is a pure API client + normalizer over the capture-audio\n * daemon's loopback HTTP API: no file IO beyond reading the local token,\n * no memory writes, no pipeline behavior (all of that stays in core so\n * desktop audio gets the same cleanup/corrections/trust gating as every\n * other wearable source).\n *\n * Token resolution (in order): settings.apiKey (config) ->\n * REMNIC_CAPTURE_AUDIO_TOKEN env -> the daemon's local token file\n * (~/.remnic/capture/token) when the base URL is loopback.\n */\n\nimport { readFileSync } from \"node:fs\";\n\nimport {\n  registerWearableConnector,\n  getWearableConnector,\n  type WearableAuthCheck,\n  type WearableConnectorFactoryOptions,\n  type WearableConnectorRegistration,\n  type WearableConversation,\n  type WearableFetchOptions,\n  type WearableFetchPage,\n  type WearableSourceConnector,\n  type WearableTranscriptSegment,\n} from \"@remnic/core\";\n\nimport { DEFAULT_HOST, DEFAULT_PORT } from \"./constants.js\";\nimport { capturePaths } from \"./paths.js\";\nimport { isLoopbackHost } from \"./util.js\";\nimport type { ConversationPage, DaemonConversation, DaemonSegment } from \"./spool.js\";\n\nexport const DESKTOP_SOURCE_ID = \"desktop\";\nexport const DESKTOP_DISPLAY_NAME = \"Desktop audio\";\nconst DEFAULT_BASE_URL = `http://${DEFAULT_HOST}:${DEFAULT_PORT}`;\n\n/** Bounded probe timeout so a wedged daemon reports unreachable instead of hanging. */\nconst PROBE_TIMEOUT_MS = 15_000;\n\nfunction withTimeout(signal: AbortSignal | undefined): AbortSignal {\n  const timeout = AbortSignal.timeout(PROBE_TIMEOUT_MS);\n  return signal ? AbortSignal.any([signal, timeout]) : timeout;\n}\n\n/** Error raised for a genuine backend failure (never for an empty day). */\nexport class DesktopDaemonError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"DesktopDaemonError\";\n  }\n}\n\nfunction baseUrlIsLoopback(baseUrl: string): boolean {\n  try {\n    return isLoopbackHost(new URL(baseUrl).hostname);\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Resolve the daemon bearer token. The local token file is read ONLY for\n * a loopback base URL — a remote reader must supply the token explicitly\n * (config/env), never inherit this machine's local token.\n */\nexport function resolveCaptureAudioToken(\n  configured: string | undefined,\n  baseUrl: string,\n  env: NodeJS.ProcessEnv = process.env,\n): string | undefined {\n  if (typeof configured === \"string\" && configured.trim().length > 0) return configured.trim();\n  const fromEnv = env.REMNIC_CAPTURE_AUDIO_TOKEN;\n  if (typeof fromEnv === \"string\" && fromEnv.trim().length > 0) return fromEnv.trim();\n  if (baseUrlIsLoopback(baseUrl)) {\n    try {\n      const token = readFileSync(capturePaths().tokenPath, \"utf8\").trim();\n      if (token.length > 0) return token;\n    } catch {\n      // no local token file — treat as unauthenticated (health will 401)\n    }\n  }\n  return undefined;\n}\n\nfunction daemonSegmentToWearable(seg: DaemonSegment): WearableTranscriptSegment {\n  return {\n    text: seg.textRaw,\n    // The wearables speaker registry owns naming; the connector only\n    // supplies the stable per-source key (spk_<n> | self | \"unknown\").\n    speakerKey: seg.speakerKey ?? \"unknown\",\n    isWearer: seg.isWearer,\n    startIso: seg.startUtc,\n    endIso: seg.endUtc,\n  };\n}\n\nexport function daemonConversationToWearable(conv: DaemonConversation): WearableConversation {\n  return {\n    id: conv.id,\n    source: DESKTOP_SOURCE_ID,\n    startIso: conv.startedAtUtc,\n    endIso: conv.endedAtUtc ?? undefined,\n    segments: conv.segments.map(daemonSegmentToWearable),\n  };\n}\n\ninterface DesktopClientOptions {\n  baseUrl: string;\n  /** Resolved per request so env / token-file rotation applies without a rebuild. */\n  getToken: () => string | undefined;\n}\n\n/** Linear trailing-slash trim (avoids a backtracking regex on the base URL). */\nfunction trimTrailingSlashes(value: string): string {\n  let end = value.length;\n  while (end > 0 && value.charCodeAt(end - 1) === 47 /* \"/\" */) end--;\n  return value.slice(0, end);\n}\n\nclass DesktopClient {\n  #baseUrl: string;\n  #getToken: () => string | undefined;\n\n  constructor(options: DesktopClientOptions) {\n    this.#baseUrl = trimTrailingSlashes(options.baseUrl);\n    this.#getToken = options.getToken;\n  }\n\n  #headers(): Record<string, string> {\n    const token = this.#getToken();\n    return token ? { authorization: `Bearer ${token}` } : {};\n  }\n\n  async verifyAuth(signal?: AbortSignal): Promise<WearableAuthCheck> {\n    let res: Response;\n    try {\n      res = await fetch(`${this.#baseUrl}/v1/health`, { headers: this.#headers(), signal: withTimeout(signal) });\n    } catch (err) {\n      // Honor caller cancellation; do not mislabel a deliberate abort.\n      if (signal?.aborted) throw err;\n      // Timeout / connection refused / DNS / offline: the daemon isn't\n      // reachable. This is NOT an auth failure and must never throw (AC2).\n      return { ok: false, detail: \"unreachable\" };\n    }\n    if (res.status === 401) return { ok: false, detail: \"unauthorized\" };\n    if (!res.ok) return { ok: false, detail: `HTTP ${res.status}` };\n    let body: { ok?: unknown; version?: unknown };\n    try {\n      body = (await res.json()) as { ok?: unknown; version?: unknown };\n    } catch (err) {\n      // Honor caller cancellation during the body read; a non-JSON body\n      // otherwise just reads as unhealthy (never throws for that, AC2).\n      if (signal?.aborted) throw err;\n      body = {};\n    }\n    if (body.ok === true) {\n      return { ok: true, detail: typeof body.version === \"string\" ? `capture-audio ${body.version}` : undefined };\n    }\n    return { ok: false, detail: \"unhealthy\" };\n  }\n\n  async fetchConversations(opts: WearableFetchOptions): Promise<WearableFetchPage> {\n    let res: Response;\n    try {\n      const url = new URL(`${this.#baseUrl}/v1/conversations`);\n      url.searchParams.set(\"date\", opts.date);\n      url.searchParams.set(\"timezone\", opts.timezone);\n      if (opts.cursor) url.searchParams.set(\"cursor\", opts.cursor);\n      res = await fetch(url, { headers: this.#headers(), signal: withTimeout(opts.signal) });\n    } catch (err) {\n      // Honor caller cancellation instead of reporting a daemon fault.\n      if (opts.signal?.aborted) throw err;\n      // Timeout, offline daemon, or a malformed configured baseUrl all\n      // surface consistently as unreachable (never a raw TypeError).\n      throw new DesktopDaemonError(\n        `desktop capture daemon unreachable at ${this.#baseUrl} (is remnic-capture-audio running?)`,\n      );\n    }\n    if (!res.ok) {\n      // A non-2xx is a backend/auth failure, distinct from an empty day.\n      throw new DesktopDaemonError(`desktop capture daemon returned HTTP ${res.status}`);\n    }\n    let page: ConversationPage;\n    try {\n      page = (await res.json()) as ConversationPage;\n    } catch (err) {\n      // Honor caller cancellation that lands mid-body-read.\n      if (opts.signal?.aborted) throw err;\n      // A 200 with an empty/non-JSON body is a backend fault, not an empty day.\n      throw new DesktopDaemonError(\"desktop capture daemon returned a non-JSON conversations response\");\n    }\n    if (!page || !Array.isArray(page.conversations)) {\n      throw new DesktopDaemonError(\"desktop capture daemon returned a malformed conversations page\");\n    }\n    return {\n      conversations: page.conversations.map(daemonConversationToWearable),\n      nextCursor: page.nextCursor ?? null,\n    };\n  }\n}\n\nexport function createDesktopConnector(options: WearableConnectorFactoryOptions): WearableSourceConnector {\n  const baseUrl = options.settings.baseUrl?.trim() || DEFAULT_BASE_URL;\n  // One client per connector, but the token is resolved per request (below)\n  // so env / on-disk token rotation takes effect without a rebuild.\n  let client: DesktopClient | null = null;\n  const getClient = (): DesktopClient => {\n    if (!client) {\n      client = new DesktopClient({ baseUrl, getToken: () => resolveCaptureAudioToken(options.settings.apiKey, baseUrl) });\n    }\n    return client;\n  };\n  return {\n    id: DESKTOP_SOURCE_ID,\n    displayName: DESKTOP_DISPLAY_NAME,\n    verifyAuth: (signal?: AbortSignal) => getClient().verifyAuth(signal),\n    fetchConversations: (opts: WearableFetchOptions) => getClient().fetchConversations(opts),\n  };\n}\n\nexport const wearableConnectorRegistration: WearableConnectorRegistration = {\n  id: DESKTOP_SOURCE_ID,\n  displayName: DESKTOP_DISPLAY_NAME,\n  factory: createDesktopConnector,\n};\n\n/** Idempotently register the desktop connector with the core registry. */\nexport function ensureDesktopConnectorRegistered(): boolean {\n  if (getWearableConnector(DESKTOP_SOURCE_ID) !== undefined) return false;\n  registerWearableConnector(wearableConnectorRegistration);\n  return true;\n}\n\nensureDesktopConnectorRegistered();\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@remnic/capture-audio",
+  "version": "9.24.0",
+  "description": "Desktop audio capture daemon for Remnic — local spool, loopback HTTP API, and replay ingestion for the wearable source `desktop` (à-la-carte)",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "remnic-capture-audio": "./dist/cli-bin.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/cli-bin.ts --format esm --dts",
+    "precheck-types": "node ../../scripts/ensure-bench-build-deps.mjs",
+    "check-types": "tsc --noEmit",
+    "test": "NODE_OPTIONS=\"${NODE_OPTIONS:+$NODE_OPTIONS }--conditions=remnic-source\" tsx --test src/config.test.ts src/validate.test.ts src/token.test.ts src/spool.test.ts src/replay.test.ts src/daemon.test.ts src/cli.test.ts src/stt.test.ts src/model.test.ts src/janitor.test.ts src/vad.test.ts src/dedup.test.ts src/assembly.test.ts src/diarization.test.ts src/connector.test.ts src/e2e.test.ts src/native.test.ts src/processor.test.ts src/capture.test.ts src/service.test.ts src/enroll.test.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "devDependencies": {
+    "@remnic/core": "workspace:*",
+    "@types/node": "^22.10.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "tsx": "^4.0.0"
+  },
+  "peerDependencies": {
+    "@remnic/core": "^9.24.0",
+    "sherpa-onnx-node": "*",
+    "@remnic/capture-native-darwin-arm64": "^9.24.0",
+    "@remnic/capture-native-darwin-x64": "^9.24.0"
+  },
+  "peerDependenciesMeta": {
+    "sherpa-onnx-node": {
+      "optional": true
+    },
+    "@remnic/capture-native-darwin-arm64": {
+      "optional": true
+    },
+    "@remnic/capture-native-darwin-x64": {
+      "optional": true
+    }
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/joshuaswarren/remnic.git",
+    "directory": "packages/capture-audio"
+  },
+  "keywords": [
+    "remnic",
+    "memory",
+    "wearable",
+    "desktop",
+    "audio",
+    "capture",
+    "transcript"
+  ]
+}