openmates 0.27.0-alpha.1 → 0.27.0-alpha.11

package/dist/chunk-FRNW5Q2V.js

@@ -0,0 +1,1188 @@
+// src/storage.ts
+import {
+  chmodSync,
+  existsSync as existsSync2,
+  mkdirSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  rmSync,
+  renameSync,
+  writeFileSync
+} from "fs";
+import lockfile from "proper-lockfile";
+import { createHash as createHash2 } from "crypto";
+import { homedir as homedir2 } from "os";
+import { isAbsolute, join, resolve } from "path";
+
+// src/keychain.ts
+import { execFileSync } from "child_process";
+import {
+  createHash,
+  pbkdf2Sync,
+  createDecipheriv
+} from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { homedir, platform, userInfo } from "os";
+var KEYCHAIN_SERVICE = "OpenMates";
+var AES_GCM_IV_LENGTH = 12;
+var PBKDF2_ITERATIONS = 1e5;
+var KEYCHAIN_TIMEOUT_MS = 5e3;
+function storeMasterKey(key, hashedEmail, existingStorage) {
+  try {
+    keychainStore(key, hashedEmail);
+    return { type: "keychain" };
+  } catch (error) {
+    if (existingStorage === "keychain") {
+      throw new Error("Existing OS keyring entry is unavailable; local credential storage was preserved.", { cause: error });
+    }
+  }
+  return { type: "file" };
+}
+function retrieveMasterKey(type, hashedEmail, encryptedData) {
+  switch (type) {
+    case "keychain":
+      try {
+        return keychainRetrieve(hashedEmail);
+      } catch {
+        return null;
+      }
+    case "encrypted":
+      if (!encryptedData) return null;
+      try {
+        return decryptWithMachineKey(encryptedData);
+      } catch {
+        return null;
+      }
+    case "plaintext":
+    case "file":
+      return null;
+    default:
+      return null;
+  }
+}
+function deleteMasterKeyStrict(type, hashedEmail) {
+  if (type !== "keychain") return;
+  try {
+    keychainDelete(hashedEmail);
+  } catch (error) {
+    throw new Error("OS keyring cleanup failed; a stored key may remain.", { cause: error });
+  }
+}
+function keychainStore(key, account) {
+  const os = platform();
+  if (os === "darwin") {
+    execFileSync("security", [
+      "add-generic-password",
+      "-s",
+      KEYCHAIN_SERVICE,
+      "-a",
+      account,
+      "-w",
+      key,
+      "-U"
+    ], { timeout: KEYCHAIN_TIMEOUT_MS, stdio: "pipe" });
+    return;
+  }
+  if (os === "linux") {
+    execFileSync("secret-tool", [
+      "store",
+      "--label",
+      KEYCHAIN_SERVICE,
+      "service",
+      KEYCHAIN_SERVICE,
+      "account",
+      account
+    ], {
+      timeout: KEYCHAIN_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"],
+      input: key
+    });
+    return;
+  }
+  throw new Error(`Keychain not supported on ${os}`);
+}
+function keychainRetrieve(account) {
+  const os = platform();
+  if (os === "darwin") {
+    const result = execFileSync("security", [
+      "find-generic-password",
+      "-s",
+      KEYCHAIN_SERVICE,
+      "-a",
+      account,
+      "-w"
+    ], { timeout: KEYCHAIN_TIMEOUT_MS, stdio: "pipe", encoding: "utf-8" });
+    const value = result.trim();
+    return value || null;
+  }
+  if (os === "linux") {
+    const result = execFileSync("secret-tool", [
+      "lookup",
+      "service",
+      KEYCHAIN_SERVICE,
+      "account",
+      account
+    ], { timeout: KEYCHAIN_TIMEOUT_MS, stdio: "pipe", encoding: "utf-8" });
+    const value = result.trim();
+    return value || null;
+  }
+  throw new Error(`Keychain not supported on ${os}`);
+}
+function keychainDelete(account) {
+  const os = platform();
+  if (os === "darwin") {
+    execFileSync("security", [
+      "delete-generic-password",
+      "-s",
+      KEYCHAIN_SERVICE,
+      "-a",
+      account
+    ], { timeout: KEYCHAIN_TIMEOUT_MS, stdio: "pipe" });
+    return;
+  }
+  if (os === "linux") {
+    execFileSync("secret-tool", [
+      "clear",
+      "service",
+      KEYCHAIN_SERVICE,
+      "account",
+      account
+    ], { timeout: KEYCHAIN_TIMEOUT_MS, stdio: "pipe" });
+    return;
+  }
+  throw new Error(`Keychain not supported on ${os}`);
+}
+function deriveMachineKey() {
+  const entropy = getMachineEntropy();
+  const username = userInfo().username;
+  const salt = `OpenMates-machine-key-${username}`;
+  return pbkdf2Sync(entropy, salt, PBKDF2_ITERATIONS, 32, "sha256");
+}
+function getMachineEntropy() {
+  const os = platform();
+  if (os === "darwin") {
+    try {
+      const output = execFileSync("ioreg", [
+        "-rd1",
+        "-c",
+        "IOPlatformExpertDevice"
+      ], { timeout: KEYCHAIN_TIMEOUT_MS, encoding: "utf-8", stdio: "pipe" });
+      const match = output.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
+      if (match?.[1]) return match[1];
+    } catch {
+    }
+  }
+  if (os === "linux") {
+    try {
+      const machineIdPath = "/etc/machine-id";
+      if (existsSync(machineIdPath)) {
+        const id = readFileSync(machineIdPath, "utf-8").trim();
+        if (id) return id;
+      }
+    } catch {
+    }
+  }
+  return createHash("sha256").update(`${homedir()}-${userInfo().username}-${os}`).digest("hex");
+}
+function decryptWithMachineKey(encryptedB64) {
+  const key = deriveMachineKey();
+  const combined = Buffer.from(encryptedB64, "base64");
+  if (combined.length <= AES_GCM_IV_LENGTH + 16) {
+    throw new Error("Encrypted data too short");
+  }
+  const iv = combined.subarray(0, AES_GCM_IV_LENGTH);
+  const authTag = combined.subarray(combined.length - 16);
+  const ciphertext = combined.subarray(AES_GCM_IV_LENGTH, combined.length - 16);
+  const decipher = createDecipheriv("aes-256-gcm", key, iv);
+  decipher.setAuthTag(authTag);
+  const decrypted = Buffer.concat([
+    decipher.update(ciphertext),
+    decipher.final()
+  ]);
+  return decrypted.toString("utf-8");
+}
+
+// src/storage.ts
+var PROFILE_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var TRUSTED_ACCOUNT_FILE = "trusted_account.json";
+function resolveStateDir(options = {}) {
+  const homeDir = options.homeDir ?? homedir2();
+  const stateDir = options.stateDir ?? process.env.OPENMATES_STATE_DIR?.trim();
+  if (stateDir) {
+    if (!isAbsolute(stateDir)) throw new Error("OPENMATES_STATE_DIR must be an absolute path.");
+    return resolve(stateDir);
+  }
+  const profile = options.profile ?? process.env.OPENMATES_PROFILE?.trim();
+  if (!profile) return join(homeDir, ".openmates");
+  if (!PROFILE_NAME_PATTERN.test(profile)) {
+    throw new Error("OPENMATES_PROFILE must contain only lowercase letters, numbers, and hyphens.");
+  }
+  return join(homeDir, ".openmates", "profiles", profile);
+}
+function getStateDir() {
+  return resolveStateDir();
+}
+function resolveKeyStorageId(storageId, profile = process.env.OPENMATES_PROFILE?.trim()) {
+  if (!profile) return storageId;
+  if (!PROFILE_NAME_PATTERN.test(profile)) {
+    throw new Error("OPENMATES_PROFILE must contain only lowercase letters, numbers, and hyphens.");
+  }
+  return `profile:${profile}:${storageId}`;
+}
+function ensureStateDir() {
+  const dir = getStateDir();
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  chmodSync(dir, 448);
+  return dir;
+}
+function readJsonFile(filePath) {
+  if (!existsSync2(filePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync2(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeJsonFile(filePath, data) {
+  writeFileSync(filePath, `${JSON.stringify(data, null, 2)}
+`, {
+    mode: 384
+  });
+  chmodSync(filePath, 384);
+}
+function loadAnonymousId() {
+  const filePath = join(getStateDir(), "anonymous.json");
+  const data = readJsonFile(filePath);
+  return typeof data?.anonymousId === "string" && data.anonymousId.length > 0 ? data.anonymousId : null;
+}
+function saveAnonymousId(anonymousId) {
+  const filePath = join(ensureStateDir(), "anonymous.json");
+  writeJsonFile(filePath, {
+    anonymousId,
+    createdAt: Math.floor(Date.now() / 1e3)
+  });
+}
+var SESSION_LOCK_STALE_MS = 3e4;
+var SESSION_LOCK_POLL_MS = 50;
+async function withSessionRefreshLock(operation) {
+  const path = join(ensureStateDir(), "session.json");
+  const release = await lockfile.lock(`${path}.refresh`, {
+    realpath: false,
+    stale: SESSION_LOCK_STALE_MS,
+    retries: { retries: 600, factor: 1, minTimeout: SESSION_LOCK_POLL_MS, maxTimeout: SESSION_LOCK_POLL_MS }
+  });
+  try {
+    return await operation();
+  } finally {
+    await release();
+  }
+}
+function saveSession(session, options = {}) {
+  const path = join(ensureStateDir(), "session.json");
+  let release;
+  const waitCell = new Int32Array(new SharedArrayBuffer(4));
+  for (let attempt = 0; ; attempt++) {
+    try {
+      release = lockfile.lockSync(`${path}.write`, { realpath: false, stale: SESSION_LOCK_STALE_MS });
+      break;
+    } catch (error) {
+      if (error.code !== "ELOCKED" || attempt >= 100) throw error;
+      Atomics.wait(waitCell, 0, 0, SESSION_LOCK_POLL_MS);
+    }
+  }
+  try {
+    const current = readJsonFile(path);
+    if (current && !options.replace) {
+      if (current.sessionId !== session.sessionId || current.hashedEmail !== session.hashedEmail || current.apiUrl !== session.apiUrl) {
+        throw new Error("Login session changed in another process. Retry the command using the current profile.");
+      }
+      if (options.expectedRefreshToken !== void 0) {
+        if (current.cookies.auth_refresh_token !== options.expectedRefreshToken) {
+          throw new Error("Login credentials changed during refresh. Retry with the current profile.");
+        }
+      } else {
+        session.cookies = { ...current.cookies };
+        session.wsToken = current.wsToken;
+      }
+      if (typeof current.pairedSessionExpiresAt === "number") {
+        session.pairedSessionExpiresAt = Math.min(
+          current.pairedSessionExpiresAt,
+          session.pairedSessionExpiresAt ?? current.pairedSessionExpiresAt
+        );
+      }
+    }
+    writeSession(session, current?.hashedEmail === session.hashedEmail ? current : null);
+  } finally {
+    release();
+  }
+}
+function writeSession(session, previous) {
+  const filePath = join(ensureStateDir(), "session.json");
+  const result = storeMasterKey(
+    session.masterKeyExportedB64,
+    resolveKeyStorageId(session.hashedEmail),
+    previous?.masterKeyStorage
+  );
+  const onDisk = {
+    apiUrl: session.apiUrl,
+    sessionId: session.sessionId,
+    wsToken: session.wsToken,
+    cookies: session.cookies,
+    hashedEmail: session.hashedEmail,
+    userEmailSalt: session.userEmailSalt,
+    createdAt: session.createdAt,
+    authorizerDeviceName: session.authorizerDeviceName,
+    autoLogoutMinutes: session.autoLogoutMinutes,
+    pairedSessionExpiresAt: session.pairedSessionExpiresAt ?? null,
+    activeTeamId: session.activeTeamId ?? null,
+    masterKeyStorage: result.type
+  };
+  if (result.type === "encrypted") {
+    onDisk.masterKeyEncrypted = result.encryptedData;
+  } else if (result.type === "file" || result.type === "plaintext") {
+    onDisk.masterKeyExportedB64 = session.masterKeyExportedB64;
+  }
+  if (session.emailEncryptionKeyB64) {
+    const emailKeyResult = storeMasterKey(
+      session.emailEncryptionKeyB64,
+      resolveKeyStorageId(`${session.hashedEmail}:email`),
+      previous?.emailEncryptionKeyStorage
+    );
+    onDisk.emailEncryptionKeyStorage = emailKeyResult.type;
+    if (emailKeyResult.type === "encrypted") {
+      onDisk.emailEncryptionKeyEncrypted = emailKeyResult.encryptedData;
+    } else if (emailKeyResult.type === "file" || emailKeyResult.type === "plaintext") {
+      onDisk.emailEncryptionKeyB64 = session.emailEncryptionKeyB64;
+    }
+  }
+  const temporary = `${filePath}.${process.pid}.tmp`;
+  try {
+    writeJsonFile(temporary, onDisk);
+    renameSync(temporary, filePath);
+  } finally {
+    rmSync(temporary, { force: true });
+  }
+}
+function loadSession() {
+  const filePath = join(ensureStateDir(), "session.json");
+  const onDisk = readJsonFile(filePath);
+  if (!onDisk) return null;
+  if (typeof onDisk.pairedSessionExpiresAt === "number" && onDisk.pairedSessionExpiresAt <= Date.now()) {
+    purgeLocalPrivateData();
+    return null;
+  }
+  let masterKey = null;
+  if (!onDisk.masterKeyStorage) {
+    masterKey = onDisk.masterKeyExportedB64 ?? null;
+    return masterKey ? buildSession(onDisk, masterKey, getEmailEncryptionKeyFromDisk(onDisk)) : null;
+  }
+  switch (onDisk.masterKeyStorage) {
+    case "keychain":
+      masterKey = retrieveMasterKey("keychain", resolveKeyStorageId(onDisk.hashedEmail));
+      if (!masterKey) throw new Error("Existing OS keyring entry is unavailable; local session was preserved.");
+      break;
+    case "encrypted":
+      masterKey = retrieveMasterKey(
+        "encrypted",
+        resolveKeyStorageId(onDisk.hashedEmail),
+        onDisk.masterKeyEncrypted
+      );
+      break;
+    case "plaintext":
+    case "file":
+      masterKey = onDisk.masterKeyExportedB64 ?? null;
+      break;
+  }
+  if (!masterKey) {
+    process.stderr.write(
+      `Failed to retrieve master key \u2014 session invalid
+`
+    );
+    return null;
+  }
+  return buildSession(onDisk, masterKey, getEmailEncryptionKeyFromDisk(onDisk));
+}
+function getCredentialStorageMode() {
+  const onDisk = readJsonFile(join(getStateDir(), "session.json"));
+  if (!onDisk) return "none";
+  if (onDisk.masterKeyStorage === "keychain") return "os-keyring";
+  if (onDisk.masterKeyStorage === "encrypted") return "legacy-machine-id";
+  return "owner-only-file";
+}
+function clearSession() {
+  const filePath = join(ensureStateDir(), "session.json");
+  const onDisk = readJsonFile(filePath);
+  let cleanupError = null;
+  if (onDisk?.masterKeyStorage) {
+    try {
+      deleteMasterKeyStrict(onDisk.masterKeyStorage, resolveKeyStorageId(onDisk.hashedEmail));
+    } catch (error) {
+      cleanupError = error;
+    }
+  }
+  if (onDisk?.emailEncryptionKeyStorage) {
+    try {
+      deleteMasterKeyStrict(onDisk.emailEncryptionKeyStorage, resolveKeyStorageId(`${onDisk.hashedEmail}:email`));
+    } catch (error) {
+      cleanupError ??= error;
+    }
+  }
+  if (onDisk?.activeTeamId) {
+    deleteLocalTeamKey(onDisk.hashedEmail, onDisk.activeTeamId);
+  }
+  if (existsSync2(filePath)) {
+    rmSync(filePath);
+  }
+  if (cleanupError) throw cleanupError;
+}
+function purgeLocalPrivateData() {
+  const stateDir = ensureStateDir();
+  const sessionFilePath = join(stateDir, "session.json");
+  const onDisk = readJsonFile(sessionFilePath);
+  const hashedEmail = onDisk?.hashedEmail ?? null;
+  let cleanupError = null;
+  try {
+    clearSession();
+  } catch (error) {
+    cleanupError = error;
+  }
+  try {
+    purgeLocalTeamKeys(hashedEmail);
+  } catch (error) {
+    cleanupError ??= error;
+  }
+  try {
+    purgeSyncCaches(stateDir);
+  } catch (error) {
+    cleanupError ??= error;
+  }
+  if (cleanupError) throw cleanupError;
+}
+function purgeLocalTeamKeys(hashedEmail) {
+  const filePath = join(ensureStateDir(), LOCAL_TEAM_KEYS_FILE);
+  const keys = readJsonFile(filePath);
+  if (!keys) return;
+  let changed = false;
+  const prefix = hashedEmail ? resolveKeyStorageId(`${hashedEmail}:team:`) : null;
+  for (const [storageId, entry] of Object.entries(keys.teams)) {
+    if (prefix && !storageId.startsWith(prefix)) continue;
+    deleteMasterKeyStrict(entry.storage, storageId);
+    delete keys.teams[storageId];
+    changed = true;
+  }
+  if (!changed) return;
+  if (Object.keys(keys.teams).length === 0) {
+    rmSync(filePath, { force: true });
+    return;
+  }
+  writeJsonFile(filePath, keys);
+}
+function purgeSyncCaches(stateDir) {
+  rmSync(join(stateDir, "project_file_privacy"), { recursive: true, force: true });
+  for (const fileName of readdirSync(stateDir)) {
+    if (fileName === SYNC_CACHE_FILE || fileName.startsWith("sync_cache.team.") && fileName.endsWith(".json")) {
+      rmSync(join(stateDir, fileName), { force: true });
+    }
+  }
+}
+function getEmailEncryptionKeyFromDisk(onDisk) {
+  if (!onDisk.emailEncryptionKeyStorage) return onDisk.emailEncryptionKeyB64 ?? null;
+  switch (onDisk.emailEncryptionKeyStorage) {
+    case "keychain": {
+      const key = retrieveMasterKey("keychain", resolveKeyStorageId(`${onDisk.hashedEmail}:email`));
+      if (!key) throw new Error("Existing email keyring entry is unavailable; local session was preserved.");
+      return key;
+    }
+    case "encrypted":
+      return retrieveMasterKey(
+        "encrypted",
+        resolveKeyStorageId(`${onDisk.hashedEmail}:email`),
+        onDisk.emailEncryptionKeyEncrypted
+      );
+    case "plaintext":
+    case "file":
+      return onDisk.emailEncryptionKeyB64 ?? null;
+  }
+}
+function buildSession(onDisk, masterKey, emailEncryptionKey) {
+  return {
+    apiUrl: onDisk.apiUrl,
+    sessionId: onDisk.sessionId,
+    wsToken: onDisk.wsToken,
+    cookies: onDisk.cookies,
+    masterKeyExportedB64: masterKey,
+    emailEncryptionKeyB64: emailEncryptionKey,
+    hashedEmail: onDisk.hashedEmail,
+    userEmailSalt: onDisk.userEmailSalt,
+    createdAt: onDisk.createdAt,
+    authorizerDeviceName: onDisk.authorizerDeviceName,
+    autoLogoutMinutes: onDisk.autoLogoutMinutes,
+    pairedSessionExpiresAt: onDisk.pairedSessionExpiresAt ?? null,
+    activeTeamId: onDisk.activeTeamId ?? null
+  };
+}
+var SYNC_CACHE_FILE = "sync_cache.json";
+var LOCAL_TEAM_KEYS_FILE = "team_keys.json";
+function teamKeyStorageId(hashedEmail, teamId) {
+  const digest = createHash2("sha256").update(teamId).digest("hex").slice(0, 32);
+  return resolveKeyStorageId(`${hashedEmail}:team:${digest}`);
+}
+function saveLocalTeamKey(hashedEmail, teamId, teamKeyB64) {
+  const storageId = teamKeyStorageId(hashedEmail, teamId);
+  const filePath = join(ensureStateDir(), LOCAL_TEAM_KEYS_FILE);
+  const keys = readJsonFile(filePath) ?? { teams: {} };
+  const result = storeMasterKey(teamKeyB64, storageId, keys.teams[storageId]?.storage);
+  keys.teams[storageId] = {
+    storage: result.type,
+    ...result.type === "encrypted" ? { encryptedData: result.encryptedData } : {},
+    ...result.type === "file" || result.type === "plaintext" ? { plaintextKeyB64: teamKeyB64 } : {}
+  };
+  writeJsonFile(filePath, keys);
+}
+function loadLocalTeamKey(hashedEmail, teamId) {
+  const storageId = teamKeyStorageId(hashedEmail, teamId);
+  const filePath = join(ensureStateDir(), LOCAL_TEAM_KEYS_FILE);
+  const entry = readJsonFile(filePath)?.teams[storageId];
+  if (!entry) return null;
+  if (entry.storage === "plaintext" || entry.storage === "file") return entry.plaintextKeyB64 ?? null;
+  const key = retrieveMasterKey(entry.storage, storageId, entry.encryptedData);
+  if (entry.storage === "keychain" && !key) throw new Error("Existing team keyring entry is unavailable; local team key was preserved.");
+  return key;
+}
+function deleteLocalTeamKey(hashedEmail, teamId) {
+  const storageId = teamKeyStorageId(hashedEmail, teamId);
+  const filePath = join(ensureStateDir(), LOCAL_TEAM_KEYS_FILE);
+  const keys = readJsonFile(filePath);
+  if (keys?.teams[storageId]) {
+    deleteMasterKeyStrict(keys.teams[storageId].storage, storageId);
+    delete keys.teams[storageId];
+    writeJsonFile(filePath, keys);
+  }
+}
+function pruneLocalTeamArtifacts(hashedEmail, teamIds) {
+  const stateDir = ensureStateDir();
+  const allowedKeyIds = new Set(teamIds.map((teamId) => teamKeyStorageId(hashedEmail, teamId)));
+  const keysFilePath = join(stateDir, LOCAL_TEAM_KEYS_FILE);
+  const keys = readJsonFile(keysFilePath);
+  if (keys) {
+    let changed = false;
+    const prefix = resolveKeyStorageId(`${hashedEmail}:team:`);
+    for (const storageId of Object.keys(keys.teams)) {
+      if (storageId.startsWith(prefix) && !allowedKeyIds.has(storageId)) {
+        deleteMasterKeyStrict(keys.teams[storageId].storage, storageId);
+        delete keys.teams[storageId];
+        changed = true;
+      }
+    }
+    if (changed) writeJsonFile(keysFilePath, keys);
+  }
+  const allowedCacheFiles = new Set(teamIds.map((teamId) => syncCacheFile(teamId)));
+  for (const fileName of readdirSync(stateDir)) {
+    if (fileName.startsWith("sync_cache.team.") && fileName.endsWith(".json") && !allowedCacheFiles.has(fileName)) {
+      rmSync(join(stateDir, fileName), { force: true });
+    }
+  }
+}
+function syncCacheFile(teamId) {
+  if (!teamId) return SYNC_CACHE_FILE;
+  const digest = createHash2("sha256").update(teamId).digest("hex").slice(0, 32);
+  return `sync_cache.team.${digest}.json`;
+}
+function saveSyncCache(cache, teamId) {
+  const filePath = join(ensureStateDir(), syncCacheFile(teamId));
+  writeJsonFile(filePath, cache);
+}
+function loadSyncCache(teamId) {
+  const filePath = join(ensureStateDir(), syncCacheFile(teamId));
+  return readJsonFile(filePath);
+}
+function clearSyncCache(teamId) {
+  const filePath = join(ensureStateDir(), syncCacheFile(teamId));
+  if (existsSync2(filePath)) {
+    rmSync(filePath);
+  }
+}
+function isSyncCacheFresh(maxAgeMs = 3e5, teamId) {
+  const cache = loadSyncCache(teamId);
+  if (!cache) return false;
+  return Date.now() - cache.syncedAt < maxAgeMs;
+}
+function loadTrustedAccountId() {
+  const trusted = readJsonFile(join(getStateDir(), TRUSTED_ACCOUNT_FILE));
+  return typeof trusted?.accountId === "string" && trusted.accountId.trim() ? trusted.accountId.trim() : null;
+}
+function saveTrustedAccountId(accountId) {
+  const normalized = accountId.trim();
+  if (!normalized) throw new Error("Cannot trust an empty OpenMates account ID.");
+  const existing = loadTrustedAccountId();
+  if (existing && existing !== normalized) {
+    throw new Error("OpenMates account mismatch: this CLI profile is already trusted for another account.");
+  }
+  writeJsonFile(join(ensureStateDir(), TRUSTED_ACCOUNT_FILE), { accountId: normalized });
+}
+function assertTrustedAccountId(expectedAccountId, actualAccountId) {
+  if (!expectedAccountId) {
+    throw new Error("This CLI profile is not trusted yet. Run `openmates login` and approve the intended account.");
+  }
+  if (expectedAccountId !== actualAccountId) {
+    throw new Error("OpenMates account mismatch: refusing authenticated access from this CLI profile.");
+  }
+}
+
+// src/privacyWorker.ts
+import { createHash as createHash4 } from "crypto";
+import { spawn } from "child_process";
+import { chmod as chmod2, lstat as lstat2, readFile as readFile2, rm as rm2 } from "fs/promises";
+import { availableParallelism as availableParallelism2, freemem } from "os";
+import { createConnection, createServer } from "net";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import lockfile3 from "proper-lockfile";
+
+// src/privacyModel.ts
+import { createHash as createHash3, randomUUID } from "crypto";
+import { createReadStream } from "fs";
+import { chmod, copyFile, lstat, mkdir, open, readFile, rename, rm, statfs, writeFile } from "fs/promises";
+import { availableParallelism, homedir as homedir3, totalmem } from "os";
+import { dirname, join as join2, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+import lockfile2 from "proper-lockfile";
+var ENHANCED_ANONYMIZATION_LABEL = "Enhanced personal data anonymization (offline AI model)";
+var PRIVACY_MODEL = {
+  revision: "935d86882f4b5dc6e0eef05aae48ae5ba0a82a7a",
+  bytes: 1637572192,
+  sha256: "80efc1803eda7c095a79741d2008c07e2e0a57b01bac8825fbeb448fd097998c",
+  url: "https://huggingface.co/LocalAI-io/privacy-filter-GGUF/resolve/935d86882f4b5dc6e0eef05aae48ae5ba0a82a7a/privacy-filter-q8.gguf"
+};
+var defaults = () => ({ version: 1, enabled: false, documents: false, projects: [], offerSeen: false, idleSeconds: 120 });
+function privacyRoot() {
+  return resolve2(process.env.OPENMATES_PRIVACY_DIR?.trim() || join2(homedir3(), ".openmates", "privacy-model"));
+}
+function privacyModelPath() {
+  return join2(privacyRoot(), PRIVACY_MODEL.revision, "model.gguf");
+}
+function privacySocketPath() {
+  return join2(privacyRoot(), "worker.sock");
+}
+function privacyProfile() {
+  return createHash3("sha256").update(resolveStateDir()).digest("hex");
+}
+function privacyRuntimeDirectory() {
+  return fileURLToPath(new URL("../fixtures/privacy-runtime/linux-arm64/", import.meta.url));
+}
+function privacyError(code) {
+  return Object.assign(new Error(`${ENHANCED_ANONYMIZATION_LABEL}: ${code}. No enhanced-mode text was sent. Retry, or explicitly disable this mode with 'openmates privacy disable'.`), { code });
+}
+async function privateDirectory(path) {
+  await mkdir(path, { recursive: true, mode: 448 });
+  const s = await lstat(path);
+  if (!s.isDirectory() || s.isSymbolicLink() || process.getuid && s.uid !== process.getuid()) throw privacyError("privacy_unsafe_directory");
+  await chmod(path, 448);
+}
+async function readPrivateJson(path) {
+  try {
+    const s = await lstat(path);
+    if (!s.isFile() || s.isSymbolicLink() || s.mode & 63 || process.getuid && s.uid !== process.getuid()) throw privacyError("privacy_unsafe_state");
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function writePrivateJson(path, value) {
+  await privateDirectory(dirname(path));
+  const temporary = path + "." + randomUUID();
+  try {
+    await writeFile(temporary, JSON.stringify(value) + "\n", { flag: "wx", mode: 384 });
+    await rename(temporary, path);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+async function readPrivacyPreferences() {
+  const data = await readPrivateJson(join2(resolveStateDir(), "privacy-preferences.json"));
+  if (!data) return defaults();
+  if (data.version !== 1 || typeof data.enabled !== "boolean" || typeof data.documents !== "boolean" || !Array.isArray(data.projects) || data.projects.length > 512 || data.projects.some((id) => typeof id !== "string" || !/^[0-9a-f-]{36}$/i.test(id))) throw privacyError("privacy_invalid_preferences");
+  return { ...defaults(), ...data, projects: [...data.projects], idleSeconds: Math.max(15, Math.min(3600, Number(data.idleSeconds) || 120)) };
+}
+async function updatePrivacyPreferences(change) {
+  const directory = resolveStateDir();
+  await privateDirectory(directory);
+  const release = await lockfile2.lock(directory, { lockfilePath: join2(directory, "privacy-preferences.lock"), retries: { retries: 10, minTimeout: 50, maxTimeout: 100 }, stale: 3e4 });
+  try {
+    const value = change(await readPrivacyPreferences());
+    await writePrivateJson(join2(directory, "privacy-preferences.json"), value);
+    return value;
+  } finally {
+    await release();
+  }
+}
+function enhancedScopeEnabled(preferences, scope) {
+  return preferences.enabled && (scope.kind === "message" || scope.kind === "document" && preferences.documents || scope.kind === "project" && !!scope.projectId && preferences.projects.includes(scope.projectId));
+}
+async function privacyCapability() {
+  if (process.platform !== "linux" || process.arch !== "arm64") return { supported: false, reason: "The first packaged runtime supports Linux ARM64." };
+  const features = await readFile("/proc/cpuinfo", "utf8").catch(() => "");
+  if (!/\basimddp\b/.test(features) || !/\basimdhp\b/.test(features)) return { supported: false, reason: "CPU FP16 and dot-product instructions are required." };
+  if (totalmem() < 4 * 2 ** 30 || availableParallelism() < 2) return { supported: false, reason: "At least two CPU cores and 4 GB RAM are required; 8 GB is recommended for development." };
+  try {
+    await lstat(join2(privacyRuntimeDirectory(), "manifest.json"));
+  } catch {
+    return { supported: false, reason: "The packaged native runtime is unavailable in this CLI build." };
+  }
+  return { supported: true };
+}
+async function fileDigest(path) {
+  const hash = createHash3("sha256");
+  for await (const chunk of createReadStream(path)) hash.update(chunk);
+  return hash.digest("hex");
+}
+async function verifyInstalledModel() {
+  const path = privacyModelPath();
+  const s = await lstat(path);
+  if (!s.isFile() || s.isSymbolicLink() || s.mode & 63 || s.size !== PRIVACY_MODEL.bytes || process.getuid && s.uid !== process.getuid() || await fileDigest(path) !== PRIVACY_MODEL.sha256) throw privacyError("privacy_model_integrity_failed");
+}
+async function verifyPrivacyRuntime() {
+  const directory = privacyRuntimeDirectory();
+  const manifest = JSON.parse(await readFile(join2(directory, "manifest.json"), "utf8"));
+  if (manifest.revision !== "735a6c28607ee82afc3a670383f41b55266a3b9a" || manifest.protocol !== 1 || !manifest.files?.length) throw privacyError("privacy_runtime_integrity_failed");
+  for (const item of manifest.files) {
+    if (!/^[A-Za-z0-9._-]+$/.test(item.name)) throw privacyError("privacy_runtime_integrity_failed");
+    const path = join2(directory, item.name);
+    const s = await lstat(path);
+    if (!s.isFile() || s.isSymbolicLink() || s.size !== item.bytes || await fileDigest(path) !== item.sha256) throw privacyError("privacy_runtime_integrity_failed");
+  }
+  return join2(directory, "openmates-pii-worker");
+}
+async function privacyStatus() {
+  const [preferences, capability] = await Promise.all([readPrivacyPreferences(), privacyCapability()]);
+  let installed = false;
+  try {
+    const s = await lstat(privacyModelPath());
+    installed = s.isFile() && !s.isSymbolicLink() && s.size === PRIVACY_MODEL.bytes;
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  return {
+    feature: ENHANCED_ANONYMIZATION_LABEL,
+    state: !capability.supported ? "unsupported" : !installed ? "not_installed" : preferences.enabled ? "installed_enabled" : "installed_disabled",
+    reason: capability.reason,
+    model_bytes: PRIVACY_MODEL.bytes,
+    memory_gib: 2,
+    local_only: true,
+    messages: preferences.enabled,
+    documents: preferences.enabled && preferences.documents,
+    projects: preferences.projects,
+    installed,
+    idle_seconds: preferences.idleSeconds
+  };
+}
+async function claimPrivacyOffer() {
+  if (!(await privacyCapability()).supported) return false;
+  await privateDirectory(privacyRoot());
+  const path = join2(privacyRoot(), "tui-offer-seen.json");
+  try {
+    const file = await open(path, "wx", 384);
+    try {
+      await file.writeFile(JSON.stringify({ seen: true }) + "\n");
+    } finally {
+      await file.close();
+    }
+    return !(await privacyStatus()).installed;
+  } catch (error) {
+    if (error.code === "EEXIST") return false;
+    throw error;
+  }
+}
+async function installPrivacyModel(options = {}) {
+  const capability = await privacyCapability();
+  if (!capability.supported) throw new Error(capability.reason);
+  await verifyPrivacyRuntime();
+  await privateDirectory(privacyRoot());
+  const release = await lockfile2.lock(privacyRoot(), { lockfilePath: join2(privacyRoot(), "install.lock"), stale: 6e4, update: 1e4 });
+  try {
+    const directory = dirname(privacyModelPath());
+    await privateDirectory(directory);
+    try {
+      await verifyInstalledModel();
+      if (!options.downloadOnly) await updatePrivacyPreferences((p) => ({ ...p, enabled: true, offerSeen: true }));
+      return;
+    } catch (error) {
+      if (error.code !== "ENOENT" && error.code !== "privacy_model_integrity_failed") throw error;
+    }
+    const space = await statfs(directory);
+    if (Number(space.bavail) * Number(space.bsize) < 4 * 2 ** 30) throw new Error("Keep at least 4 GiB free for installation and safe updates.");
+    const partial = join2(directory, "download.part");
+    try {
+      const stage = await lstat(partial);
+      if (!stage.isFile() || stage.isSymbolicLink() || stage.mode & 63 || process.getuid && stage.uid !== process.getuid()) throw privacyError("privacy_unsafe_download");
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    if (options.modelFile) {
+      await copyFile(resolve2(options.modelFile), partial);
+      await chmod(partial, 384);
+    } else {
+      let received = 0;
+      try {
+        const s = await lstat(partial);
+        if (!s.isFile() || s.isSymbolicLink() || s.mode & 63) throw privacyError("privacy_unsafe_download");
+        received = s.size;
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+      if (received > PRIVACY_MODEL.bytes) {
+        await rm(partial);
+        received = 0;
+      }
+      if (received < PRIVACY_MODEL.bytes) {
+        const response = await fetch(PRIVACY_MODEL.url, { headers: received ? { Range: `bytes=${received}-` } : {}, signal: AbortSignal.timeout(30 * 6e4) });
+        if (!(response.status === 200 || response.status === 206) || !response.body) throw new Error("Model download failed. Retry to resume it.");
+        if (response.status === 200) received = 0;
+        if (response.status === 206 && !response.headers.get("content-range")?.startsWith(`bytes ${received}-`)) throw privacyError("privacy_invalid_download_range");
+        const file = await open(partial, received ? "a" : "w", 384);
+        try {
+          for await (const chunk of response.body) {
+            received += chunk.length;
+            if (received > PRIVACY_MODEL.bytes) throw privacyError("privacy_invalid_download_size");
+            await file.writeFile(chunk);
+            options.progress?.(received, PRIVACY_MODEL.bytes);
+          }
+          await file.sync();
+        } finally {
+          await file.close();
+        }
+      }
+    }
+    if ((await lstat(partial)).size !== PRIVACY_MODEL.bytes || await fileDigest(partial) !== PRIVACY_MODEL.sha256) {
+      await rm(partial, { force: true });
+      throw privacyError("privacy_model_integrity_failed");
+    }
+    await rename(partial, privacyModelPath());
+    await writePrivateJson(join2(directory, "installation.json"), { sha256: PRIVACY_MODEL.sha256, bytes: PRIVACY_MODEL.bytes, revision: PRIVACY_MODEL.revision });
+    if (!options.downloadOnly) await updatePrivacyPreferences((p) => ({ ...p, enabled: true, offerSeen: true }));
+  } finally {
+    await release();
+  }
+}
+
+// src/privacyWorker.ts
+var MAX_TEXT = 1024 * 1024;
+var MAX_WIRE = 8 * MAX_TEXT;
+var TIMEOUT = 5 * 6e4;
+var NativeWorker = class {
+  child;
+  ready;
+  buffer = Buffer.alloc(0);
+  waiting = [];
+  failed = false;
+  loaded = false;
+  constructor(executable) {
+    this.child = spawn(executable, [privacyModelPath(), String(Math.max(1, Math.min(4, availableParallelism2() - 1)))], {
+      cwd: privacyRoot(),
+      env: { LANG: "C.UTF-8", LD_LIBRARY_PATH: privacyRuntimeDirectory() },
+      stdio: "pipe"
+    });
+    this.child.stderr.resume();
+    this.ready = this.frame().then((reply) => {
+      this.loaded = reply.ready === true;
+      return reply;
+    });
+    this.child.stdout.on("data", (chunk) => {
+      this.buffer = Buffer.concat([this.buffer, chunk]);
+      while (this.buffer.length >= 4) {
+        const size = this.buffer.readUInt32BE(0);
+        if (size > MAX_WIRE) {
+          this.fail();
+          return;
+        }
+        if (this.buffer.length < size + 4) break;
+        const payload = this.buffer.subarray(4, size + 4);
+        this.buffer = this.buffer.subarray(size + 4);
+        const next = this.waiting.shift();
+        if (!next) {
+          this.fail();
+          return;
+        }
+        try {
+          next.resolve(JSON.parse(payload.toString("utf8")));
+        } catch {
+          next.reject(privacyError("privacy_worker_protocol_failed"));
+          this.fail();
+        }
+      }
+    });
+    this.child.on("error", () => this.fail());
+    this.child.on("exit", () => this.fail());
+  }
+  frame() {
+    if (this.failed) return Promise.reject(privacyError("privacy_worker_failed"));
+    return new Promise((resolve3, reject) => this.waiting.push({ resolve: resolve3, reject }));
+  }
+  fail() {
+    this.failed = true;
+    this.child.kill("SIGKILL");
+    for (const waiter of this.waiting.splice(0)) waiter.reject(privacyError("privacy_worker_failed"));
+  }
+  async scan(text) {
+    if (!(await this.ready).ready) throw privacyError("privacy_worker_protocol_failed");
+    const payload = Buffer.from(text, "utf8");
+    const header = Buffer.alloc(4);
+    header.writeUInt32BE(payload.length);
+    const pending = this.frame();
+    this.child.stdin.write(Buffer.concat([header, payload]));
+    const reply = await pending;
+    if (reply.error || !Array.isArray(reply.spans)) throw privacyError("privacy_worker_failed");
+    return reply.spans;
+  }
+};
+async function privacyRpc(request, timeout = TIMEOUT) {
+  const path = privacySocketPath();
+  const info = await lstat2(path);
+  if (!info.isSocket() || info.mode & 63 || process.getuid && info.uid !== process.getuid()) throw privacyError("privacy_unsafe_socket");
+  return new Promise((resolveReply, reject) => {
+    const socket = createConnection(path);
+    let data = "";
+    const timer = setTimeout(() => {
+      socket.destroy();
+      reject(privacyError("privacy_scan_timed_out"));
+    }, timeout);
+    const finish = (error, reply) => {
+      clearTimeout(timer);
+      socket.destroy();
+      if (error) reject(error);
+      else resolveReply(reply);
+    };
+    socket.on("connect", () => socket.write(JSON.stringify(request) + "\n"));
+    socket.on("data", (chunk) => {
+      data += chunk.toString("utf8");
+      if (Buffer.byteLength(data) > MAX_WIRE) {
+        finish(privacyError("privacy_worker_protocol_failed"));
+        return;
+      }
+      const end = data.indexOf("\n");
+      if (end === -1) return;
+      try {
+        const reply = JSON.parse(data.slice(0, end));
+        finish(reply.error ? privacyError(reply.error) : void 0, reply);
+      } catch {
+        finish(privacyError("privacy_worker_protocol_failed"));
+      }
+    });
+    socket.on("error", () => finish(privacyError("privacy_worker_unavailable")));
+    socket.on("end", () => {
+      if (!data.includes("\n")) finish(privacyError("privacy_worker_unavailable"));
+    });
+  });
+}
+async function ensurePrivacyDaemon() {
+  try {
+    const reply = await privacyRpc({ op: "status" }, 1e3);
+    if (reply.protocol === 1 && reply.model === PRIVACY_MODEL.sha256) return;
+  } catch {
+  }
+  if (!(await privacyStatus()).installed) throw privacyError("privacy_model_not_installed");
+  const root = privacyRoot();
+  await privateDirectory(root);
+  const unlock = await lockfile3.lock(root, { lockfilePath: root + "/worker-start.lock", stale: 3e4, retries: { retries: 40, minTimeout: 100, maxTimeout: 200 } });
+  try {
+    try {
+      const reply = await privacyRpc({ op: "status" }, 1e3);
+      if (reply.protocol === 1 && reply.model === PRIVACY_MODEL.sha256) return;
+      await stopPrivacyDaemon();
+    } catch {
+    }
+    await rm2(privacySocketPath(), { force: true });
+    const entry = fileURLToPath2(new URL("./privacyDaemon.js", import.meta.url));
+    const child = spawn(process.execPath, [entry], { detached: true, stdio: "ignore", env: { PATH: process.env.PATH, LANG: "C.UTF-8", OPENMATES_PRIVACY_DIR: root } });
+    child.unref();
+    const start = Date.now();
+    while (Date.now() - start < 1e4) {
+      await new Promise((resolveWait) => setTimeout(resolveWait, 100));
+      try {
+        const reply = await privacyRpc({ op: "status" }, 1e3);
+        if (reply.protocol === 1 && reply.model === PRIVACY_MODEL.sha256) return;
+        await stopPrivacyDaemon();
+      } catch {
+      }
+    }
+    throw privacyError("privacy_worker_unavailable");
+  } finally {
+    await unlock();
+  }
+}
+async function stopPrivacyDaemon() {
+  try {
+    await privacyRpc({ op: "stop" }, 1e3);
+  } catch {
+  }
+  for (let i = 0; i < 20; i++) {
+    try {
+      await lstat2(privacySocketPath());
+    } catch {
+      return;
+    }
+    await new Promise((done) => setTimeout(done, 50));
+  }
+}
+async function runPrivacyDaemon() {
+  await privateDirectory(privacyRoot());
+  let native = null;
+  let initializing = null;
+  const cache = /* @__PURE__ */ new Map();
+  let tail = Promise.resolve();
+  let queued = 0;
+  let pendingBytes = 0;
+  let idle;
+  const close = async () => {
+    native?.fail();
+    cache.clear();
+    server.close();
+    await rm2(privacySocketPath(), { force: true });
+    process.exit(0);
+  };
+  const armIdle = (seconds = 120) => {
+    clearTimeout(idle);
+    idle = setTimeout(() => {
+      if (!queued) void close();
+    }, seconds * 1e3);
+  };
+  const getNative = () => initializing ??= (async () => {
+    const memory = await readFile2("/proc/meminfo", "utf8").catch(() => "");
+    const available = Number(/^MemAvailable:\s+(\d+)/m.exec(memory)?.[1] ?? 0) * 1024 || freemem();
+    if (available < 2.5 * 2 ** 30) throw privacyError("privacy_insufficient_available_memory");
+    await verifyInstalledModel();
+    const executable = await verifyPrivacyRuntime();
+    native = new NativeWorker(executable);
+    await native.ready;
+    return native;
+  })();
+  const watchdog = setInterval(() => {
+    if (!native?.child.pid) return;
+    void readFile2(`/proc/${native.child.pid}/status`, "utf8").then((data) => {
+      const rss = Number(/^VmRSS:\s+(\d+)/m.exec(data)?.[1] ?? 0) * 1024;
+      if (rss > 3 * 2 ** 30) native?.fail();
+    }).catch(() => {
+    });
+  }, 1e3);
+  watchdog.unref();
+  const server = createServer((socket) => {
+    let data = Buffer.alloc(0);
+    let accepted = false;
+    socket.setTimeout(TIMEOUT, () => socket.destroy());
+    socket.on("error", () => {
+    });
+    socket.on("data", (chunk) => {
+      if (accepted) return;
+      data = Buffer.concat([data, chunk]);
+      if (data.length > MAX_WIRE) {
+        socket.destroy();
+        return;
+      }
+      const end = data.indexOf(10);
+      if (end < 0) return;
+      accepted = true;
+      let request;
+      try {
+        request = JSON.parse(data.subarray(0, end).toString("utf8"));
+      } catch {
+        socket.destroy();
+        return;
+      }
+      data.fill(0);
+      data = Buffer.alloc(0);
+      if (request.op === "status") {
+        socket.end(JSON.stringify({ protocol: 1, model: PRIVACY_MODEL.sha256, state: native?.failed ? "failed" : native?.loaded ? "ready" : initializing ? "loading" : "installed_enabled" }) + "\n");
+        return;
+      }
+      if (request.op === "stop") {
+        socket.end('{"state":"stopped"}\n');
+        void close();
+        return;
+      }
+      if (request.op !== "scan" || typeof request.text !== "string" || !/^[a-f0-9]{64}$/.test(request.scope ?? "") || Buffer.byteLength(request.text) > MAX_TEXT || queued >= 8 || pendingBytes + Buffer.byteLength(request.text) > 4 * MAX_TEXT) {
+        socket.end('{"error":"privacy_request_rejected"}\n');
+        return;
+      }
+      const text = request.text;
+      request.text = void 0;
+      const bytes = Buffer.byteLength(text);
+      pendingBytes += bytes;
+      queued++;
+      clearTimeout(idle);
+      const key = request.scope + ":" + createHash4("sha256").update(text).digest("hex");
+      tail = tail.catch(() => {
+      }).then(async () => {
+        try {
+          let spans = cache.get(key);
+          if (!spans) {
+            spans = await (await getNative()).scan(text);
+            if (cache.size >= 128) cache.delete(cache.keys().next().value);
+            cache.set(key, spans);
+          }
+          socket.end(JSON.stringify({ spans }) + "\n");
+        } catch {
+          socket.end('{"error":"privacy_scan_failed"}\n');
+        } finally {
+          queued--;
+          pendingBytes -= bytes;
+          armIdle(Math.max(15, Math.min(3600, request.idleSeconds || 120)));
+        }
+      });
+    });
+  });
+  await new Promise((resolveListen, reject) => {
+    server.once("error", reject);
+    server.listen(privacySocketPath(), () => {
+      void chmod2(privacySocketPath(), 384).then(resolveListen, reject);
+    });
+  });
+  armIdle();
+  process.once("SIGTERM", () => {
+    void close();
+  });
+  process.once("SIGINT", () => {
+    void close();
+  });
+}
+
+export {
+  resolveStateDir,
+  loadAnonymousId,
+  saveAnonymousId,
+  withSessionRefreshLock,
+  saveSession,
+  loadSession,
+  getCredentialStorageMode,
+  purgeLocalPrivateData,
+  saveLocalTeamKey,
+  loadLocalTeamKey,
+  pruneLocalTeamArtifacts,
+  saveSyncCache,
+  loadSyncCache,
+  clearSyncCache,
+  isSyncCacheFresh,
+  loadTrustedAccountId,
+  saveTrustedAccountId,
+  assertTrustedAccountId,
+  ENHANCED_ANONYMIZATION_LABEL,
+  privacyModelPath,
+  privacyProfile,
+  privacyError,
+  readPrivacyPreferences,
+  updatePrivacyPreferences,
+  enhancedScopeEnabled,
+  privacyCapability,
+  verifyInstalledModel,
+  verifyPrivacyRuntime,
+  privacyStatus,
+  claimPrivacyOffer,
+  installPrivacyModel,
+  privacyRpc,
+  ensurePrivacyDaemon,
+  stopPrivacyDaemon,
+  runPrivacyDaemon
+};