@notis_ai/cli 0.2.0-beta.16.1 → 0.2.0-beta.160.1

package/src/runtime/skill-sync-service.js

@@ -0,0 +1,109 @@
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { isValidProfileName, loadConfig } from './profiles.js';
+import { withSkillSyncLock } from './sync-skills.js';
+
+export const SKILL_SYNC_SERVICE_LABEL = 'ai.notis.skills-sync';
+const bundlePath = fileURLToPath(new URL('../../dist/skill-sync-worker.mjs', import.meta.url));
+
+function atomicWrite(target, value, mode = 0o600) {
+  mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
+  const temporary = `${target}.${process.pid}.tmp`;
+  writeFileSync(temporary, value, { mode });
+  renameSync(temporary, target);
+}
+
+function xml(value) {
+  return String(value).replaceAll('&', '&amp;').replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&apos;');
+}
+
+export async function maybeInstallSkillSyncService(runtime, {
+  config = loadConfig(), install = installSkillSyncService,
+  fetchSettings, refresh,
+} = {}) {
+  if (process.platform !== 'darwin' || runtime.credentialKind !== 'oauth'
+    || config.current_profile !== runtime.profileName
+    || !['https://api.notis.ai', 'https://api-beta.notis.ai'].includes(runtime.apiBase)) return;
+  // Ordinary commands must not steal another explicitly bound account's job.
+  const plist = join(homedir(), 'Library', 'LaunchAgents', `${SKILL_SYNC_SERVICE_LABEL}.plist`);
+  if (existsSync(plist)) {
+    const saved = readFileSync(plist, 'utf8');
+    if (runtime.oauthUserId && [runtime.profileName, runtime.apiBase, runtime.oauthUserId]
+      .every(value => saved.includes(`<string>${xml(value)}</string>`))) return install(runtime);
+    return;
+  }
+  const refreshCredential = refresh || (await import('./oauth.js')).ensureFreshOAuthCredential;
+  await refreshCredential(runtime);
+  const getSettings = fetchSettings || (await import('../../dist/skill-sync/index.js')).fetchSyncSettings;
+  const settings = await getSettings(runtime.apiBase, runtime.jwt);
+  if (settings.sync_enabled && settings.user_id === runtime.oauthUserId) return install(runtime);
+}
+
+export async function installSkillSyncService(runtime, options = {}) {
+  if ((options.platform || process.platform) !== 'darwin') return { status: 'unsupported_platform' };
+  if (runtime.credentialKind !== 'oauth' || !runtime.oauthUserId
+    || !['https://api.notis.ai', 'https://api-beta.notis.ai'].includes(runtime.apiBase)) {
+    return { status: 'skipped_non_personal_profile' };
+  }
+  // Registration upgrades must not kill a worker holding the filesystem lock,
+  // nor race another CLI registering the same LaunchAgent.
+  return withSkillSyncLock(() => installSkillSyncServiceLocked(runtime, options),
+    options.home ? { home: options.home } : {});
+}
+
+async function installSkillSyncServiceLocked(runtime, {
+  home = homedir(), platform = process.platform, nodePath = process.execPath,
+  source = bundlePath, run = spawnSync, uid = process.getuid?.(),
+} = {}) {
+  // A single explicitly selected personal account owns global agent folders.
+  // Development and hosted credentials must never enroll a machine-wide job.
+  if (platform !== 'darwin') return { status: 'unsupported_platform' };
+  if (runtime.credentialKind !== 'oauth' || runtime.envCredentialOverride
+    || !isValidProfileName(runtime.profileName)
+    || !['https://api.notis.ai', 'https://api-beta.notis.ai'].includes(runtime.apiBase)) {
+    return { status: 'skipped_non_personal_profile' };
+  }
+  const root = join(home, '.notis', 'skills', 'service');
+  const bundle = readFileSync(source);
+  const digest = createHash('sha256').update(bundle).digest('hex');
+  const installedBundle = join(root, 'runtime', digest, 'worker.mjs');
+  if (!existsSync(installedBundle)
+    || !readFileSync(installedBundle).equals(bundle)) atomicWrite(installedBundle, bundle, 0o500);
+  const args = [nodePath, installedBundle, runtime.profileName, runtime.apiBase, runtime.oauthUserId];
+  if (!runtime.oauthUserId) return { status: 'skipped_missing_account' };
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<key>Label</key><string>${SKILL_SYNC_SERVICE_LABEL}</string>
+<key>ProgramArguments</key><array>${args.map(value => `<string>${xml(value)}</string>`).join('')}</array>
+<key>WorkingDirectory</key><string>${xml(root)}</string>
+<key>StartInterval</key><integer>60</integer>
+<key>ProcessType</key><string>Background</string>
+</dict></plist>
+`;
+  const plistPath = join(home, 'Library', 'LaunchAgents', `${SKILL_SYNC_SERVICE_LABEL}.plist`);
+  const domain = `gui/${uid}`;
+  const target = `${domain}/${SKILL_SYNC_SERVICE_LABEL}`;
+  const unchanged = existsSync(plistPath) && readFileSync(plistPath, 'utf8') === plist;
+  const loaded = run('/bin/launchctl', ['print', target], { encoding: 'utf8', timeout: 5000 });
+  if (unchanged && loaded.status === 0) return { status: 'installed', intervalSeconds: 60, profile: runtime.profileName };
+  if (loaded.status === 0) {
+    const stopped = run('/bin/launchctl', ['bootout', target], { encoding: 'utf8', timeout: 5000 });
+    if (stopped.status !== 0) throw new Error('Could not update the existing automatic skill sync job');
+  }
+  atomicWrite(plistPath, plist);
+  let started;
+  // launchd may finish tearing down an old registration after bootout returns.
+  for (let attempt = 0; attempt < 10; attempt++) {
+    started = run('/bin/launchctl', ['bootstrap', domain, plistPath], { encoding: 'utf8', timeout: 5000 });
+    if (started.status === 0) break;
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  if (started?.status !== 0) throw new Error('Could not register automatic skill sync with macOS');
+  return { status: 'installed', intervalSeconds: 60, profile: runtime.profileName };
+}

package/src/runtime/store-screenshot.js

@@ -0,0 +1,143 @@
+import { fileURLToPath } from 'node:url';
+
+const STORE_SCREENSHOT_ASPECT = 16 / 10;
+const SHARED_BACKDROP_PATH = fileURLToPath(
+  new URL('./assets/store-screenshot-dark.png', import.meta.url),
+);
+
+const ACCENT_PALETTES = {
+  blue: { glow: '#4f7cff', glow2: '#274690' },
+  violet: { glow: '#9b87f5', glow2: '#5038a1' },
+  emerald: { glow: '#34d399', glow2: '#176b55' },
+  amber: { glow: '#f2a94a', glow2: '#8b4f20' },
+  rose: { glow: '#fb7185', glow2: '#8f3048' },
+  sky: { glow: '#38bdf8', glow2: '#176887' },
+  fuchsia: { glow: '#d946ef', glow2: '#772786' },
+  teal: { glow: '#2dd4bf', glow2: '#176e68' },
+};
+
+const ACCENT_NAMES = Object.keys(ACCENT_PALETTES);
+
+async function loadSharp() {
+  return (await import('sharp')).default;
+}
+
+function stableHash(value) {
+  let hash = 2166136261;
+  for (const character of String(value || 'notis-app')) {
+    hash ^= character.codePointAt(0);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
+export function resolveStoreScreenshotAccent(accent, seed = 'notis-app') {
+  if (accent && ACCENT_PALETTES[accent]) {
+    return accent;
+  }
+  return ACCENT_NAMES[stableHash(seed) % ACCENT_NAMES.length];
+}
+
+export function storeScreenshotLayout(width = 2000, height = 1250) {
+  const horizontalInset = Math.max(48, Math.round(width * 0.06));
+  const verticalInset = Math.max(40, Math.round(height * 0.06));
+  let cardWidth = width - horizontalInset * 2;
+  let cardHeight = Math.round(cardWidth / STORE_SCREENSHOT_ASPECT);
+  const maximumCardHeight = height - verticalInset * 2;
+  if (cardHeight > maximumCardHeight) {
+    cardHeight = maximumCardHeight;
+    cardWidth = Math.round(cardHeight * STORE_SCREENSHOT_ASPECT);
+  }
+  const cardLeft = Math.round((width - cardWidth) / 2);
+  const cardTop = Math.round((height - cardHeight) / 2) - Math.round(height * 0.008);
+  return {
+    width,
+    height,
+    cardWidth,
+    cardHeight,
+    cardLeft,
+    cardTop,
+    radius: Math.max(18, Math.round(width * 0.016)),
+  };
+}
+
+async function backdropImage(layout) {
+  const sharp = await loadSharp();
+  return sharp(SHARED_BACKDROP_PATH)
+    .resize(layout.width, layout.height, { fit: 'cover', position: 'centre' })
+    .png()
+    .toBuffer();
+}
+
+function roundedRectSvg(width, height, radius, { fill = '#ffffff', stroke = null } = {}) {
+  const strokeAttribute = stroke
+    ? ` fill="none" stroke="${stroke}" stroke-width="2"`
+    : ` fill="${fill}"`;
+  return Buffer.from(
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}"><rect x="1" y="1" width="${width - 2}" height="${height - 2}" rx="${radius}" ry="${radius}"${strokeAttribute}/></svg>`,
+  );
+}
+
+/**
+ * Composite a truthful browser capture into the deterministic Store frame.
+ * The source pixels are only resized/cropped; the app UI is never redrawn.
+ */
+export async function composeStoreScreenshot({
+  inputPath,
+  outputPath,
+  width = 2000,
+  height = 1250,
+  accent = null,
+  seed = 'notis-app',
+  focused = false,
+  theme = 'light',
+}) {
+  const sharp = await loadSharp();
+  const resolvedTheme = theme === 'dark' ? 'dark' : 'light';
+  const layout = storeScreenshotLayout(width, height);
+  const resolvedAccent = resolveStoreScreenshotAccent(accent, seed);
+
+  const roundedCapture = await sharp(inputPath)
+    .resize(layout.cardWidth, layout.cardHeight, {
+      fit: 'cover',
+      position: focused ? 'top' : 'centre',
+    })
+    .composite([{
+      input: roundedRectSvg(layout.cardWidth, layout.cardHeight, layout.radius),
+      blend: 'dest-in',
+    }])
+    .png()
+    .toBuffer();
+
+  const border = roundedRectSvg(
+    layout.cardWidth,
+    layout.cardHeight,
+    layout.radius,
+    { stroke: resolvedTheme === 'dark' ? '#FFFFFF2A' : '#0F172A22' },
+  );
+
+  await sharp(await backdropImage(layout))
+    .composite([
+      { input: roundedCapture, left: layout.cardLeft, top: layout.cardTop },
+      { input: border, left: layout.cardLeft, top: layout.cardTop },
+    ])
+    .png({
+      compressionLevel: 9,
+      adaptiveFiltering: true,
+    })
+    .toFile(outputPath);
+
+  return {
+    mode: 'framed',
+    accent: resolvedAccent,
+    focused: Boolean(focused),
+    theme: resolvedTheme,
+    card: {
+      left: layout.cardLeft,
+      top: layout.cardTop,
+      width: layout.cardWidth,
+      height: layout.cardHeight,
+      radius: layout.radius,
+    },
+  };
+}

package/src/runtime/sync-skills.d.ts

@@ -0,0 +1,37 @@
+import type { BaseSkillReconcileResult } from './base-skills.js';
+
+export interface ReconcileAllSkillsResult {
+  baseSkills: string[];
+  baseInstalled: number;
+  baseLinked: number;
+  baseBackups: string[];
+}
+
+export interface SkillSyncLockOptions {
+  home?: string;
+  timeoutMs?: number;
+  staleMs?: number;
+  pollMs?: number;
+  now?: () => number;
+}
+
+export function withSkillSyncLock<T>(
+  callback: () => Promise<T> | T,
+  options?: SkillSyncLockOptions,
+): Promise<T>;
+
+export function reconcileAllSkills<T extends object>(options: {
+  serverUrl: string;
+  jwt: string;
+  honorSyncEnabled: boolean;
+  userId?: string | null;
+  home?: string;
+  runAccountSync: (
+    serverUrl: string,
+    jwt: string,
+    dependencies: Record<string, never>,
+    options: { honorSyncEnabled: boolean },
+  ) => Promise<T>;
+  reconcileBase?: (options: { userId?: string | null; home?: string }) => BaseSkillReconcileResult;
+  lockOptions?: Omit<SkillSyncLockOptions, 'home'>;
+}): Promise<T & ReconcileAllSkillsResult>;

package/src/runtime/sync-skills.js

@@ -0,0 +1,231 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+import { reconcileBaseSkills } from './base-skills.js';
+
+const DEFAULT_LOCK_TIMEOUT_MS = 30_000;
+const DEFAULT_LOCK_STALE_MS = 10 * 60_000;
+const DEFAULT_LOCK_POLL_MS = 50;
+
+async function lockSnapshot(lockDirectory) {
+  try {
+    const [raw, metadata] = await Promise.all([
+      readFile(join(lockDirectory, 'owner'), 'utf8').catch(() => ''),
+      stat(lockDirectory),
+    ]);
+    let owner = {};
+    try {
+      owner = raw ? JSON.parse(raw) : {};
+    } catch {
+      // A process can die between mkdir and the atomic owner write. Preserve
+      // the directory mtime as a reclaimable ownerless lease.
+    }
+    return {
+      id: typeof owner.id === 'string' ? owner.id : null,
+      pid: Number.isInteger(Number(owner.pid)) ? Number(owner.pid) : null,
+      at: Number.isFinite(Number(owner.at)) ? Number(owner.at) : metadata.mtimeMs,
+      mtimeMs: metadata.mtimeMs,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function sameLockSnapshot(left, right) {
+  return Boolean(
+    left
+    && right
+    && left.id === right.id
+    && left.pid === right.pid
+    && left.at === right.at
+    && left.mtimeMs === right.mtimeMs,
+  );
+}
+
+function processIsAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === 'EPERM';
+  }
+}
+
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+async function quarantineStaleLock(lockDirectory, snapshot) {
+  const quarantineRoot = join(dirname(lockDirectory), '.stale-operation-locks');
+  const snapshotToken = createHash('sha256')
+    .update(JSON.stringify(snapshot))
+    .digest('hex');
+  await mkdir(quarantineRoot, { recursive: true, mode: 0o700 });
+  try {
+    // The deterministic destination is the compare-and-swap guard. If two
+    // waiters observed the same stale owner, only one can move it here. The
+    // retained non-empty tombstone prevents the loser from ever moving a new
+    // live lock that appeared at the shared pathname in the meantime.
+    await rename(lockDirectory, join(quarantineRoot, snapshotToken));
+    return true;
+  } catch (error) {
+    if (['EEXIST', 'ENOTEMPTY', 'ENOENT'].includes(error?.code)) return false;
+    throw error;
+  }
+}
+
+async function writeLockOwnerAtomically(lockDirectory, owner) {
+  const temporaryOwnerPath = join(lockDirectory, `.owner.${owner.id}.tmp`);
+  const ownerPath = join(lockDirectory, 'owner');
+  await writeFile(temporaryOwnerPath, JSON.stringify(owner), { mode: 0o600 });
+  await rename(temporaryOwnerPath, ownerPath);
+}
+
+async function releaseOwnedLock(lockDirectory, ownerId) {
+  const owner = await lockSnapshot(lockDirectory);
+  if (owner?.id !== ownerId) return;
+
+  const quarantineRoot = join(dirname(lockDirectory), '.stale-operation-locks');
+  const releasedDirectory = join(quarantineRoot, `released.${ownerId}`);
+  await mkdir(quarantineRoot, { recursive: true, mode: 0o700 });
+  try {
+    // Moving the owned directory releases the shared pathname atomically.
+    // Delete only the private destination so a waiter can safely acquire a new
+    // lock without racing this owner's recursive cleanup.
+    await rename(lockDirectory, releasedDirectory);
+  } catch (error) {
+    if (error?.code === 'ENOENT') return;
+    throw error;
+  }
+  await rm(releasedDirectory, { recursive: true, force: true });
+}
+
+/** Serialize Desktop and terminal skill sync across processes on one Mac. */
+export async function withSkillSyncLock(callback, {
+  home = homedir(),
+  timeoutMs = DEFAULT_LOCK_TIMEOUT_MS,
+  staleMs = DEFAULT_LOCK_STALE_MS,
+  pollMs = DEFAULT_LOCK_POLL_MS,
+  now = () => Date.now(),
+} = {}) {
+  const lockDirectory = join(home, '.notis', 'skills', '.operation-lock');
+  const ownerId = `${process.pid}.${randomUUID()}`;
+  const deadline = now() + timeoutMs;
+  await mkdir(dirname(lockDirectory), { recursive: true, mode: 0o700 });
+
+  for (;;) {
+    try {
+      await mkdir(lockDirectory, { mode: 0o700 });
+      try {
+        await writeLockOwnerAtomically(lockDirectory, {
+          id: ownerId,
+          pid: process.pid,
+          at: now(),
+        });
+      } catch (error) {
+        // This process exclusively created the directory and has not yet
+        // published an owner, so it is safe to undo a failed acquisition.
+        await rm(lockDirectory, { recursive: true, force: true });
+        throw error;
+      }
+      break;
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error;
+    }
+
+    const observed = await lockSnapshot(lockDirectory);
+    if (
+      observed
+      && now() - observed.at > staleMs
+      && !processIsAlive(observed.pid)
+    ) {
+      // Require an unchanged observation interval before stealing. This avoids
+      // racing a holder that is publishing or refreshing its owner lease.
+      await delay(Math.max(pollMs, 10));
+      const current = await lockSnapshot(lockDirectory);
+      if (sameLockSnapshot(observed, current) && !processIsAlive(current?.pid)) {
+        if (await quarantineStaleLock(lockDirectory, current)) continue;
+      }
+    }
+    if (now() >= deadline) {
+      throw new Error('Timed out waiting for another Notis skill sync to finish.');
+    }
+    await delay(pollMs);
+  }
+
+  const heartbeatMs = Math.max(10, Math.min(30_000, Math.floor(staleMs / 3)));
+  let heartbeatStopped = false;
+  let heartbeatInFlight = Promise.resolve();
+  const refreshHeartbeat = async () => {
+      if (heartbeatStopped) return;
+      const temporaryOwnerPath = join(lockDirectory, `.owner.${ownerId}.tmp`);
+      await writeFile(
+        temporaryOwnerPath,
+        JSON.stringify({ id: ownerId, pid: process.pid, at: now() }),
+        { mode: 0o600 },
+      );
+      const owner = await lockSnapshot(lockDirectory);
+      if (owner?.id !== ownerId) {
+        await rm(temporaryOwnerPath, { force: true });
+        return;
+      }
+      // If a stale-lock reclaimer moved this directory after the ownership
+      // check, the source path disappears and rename fails instead of
+      // overwriting the owner of a newly acquired lock at the shared path.
+      await rename(temporaryOwnerPath, join(lockDirectory, 'owner'));
+  };
+  const heartbeat = setInterval(() => {
+    // Serialize refreshes and retain the active promise so cleanup cannot race
+    // a temporary owner write that was already in flight when the interval was
+    // cleared.
+    heartbeatInFlight = heartbeatInFlight
+      .then(refreshHeartbeat)
+      .catch(() => undefined);
+  }, heartbeatMs);
+  heartbeat.unref?.();
+
+  try {
+    return await callback();
+  } finally {
+    heartbeatStopped = true;
+    clearInterval(heartbeat);
+    await heartbeatInFlight;
+    await releaseOwnedLock(lockDirectory, ownerId);
+  }
+}
+
+/**
+ * Shared CLI-owned orchestration for base-skill installation plus account sync.
+ * Desktop injects the source engine that webpack bundles; the CLI command
+ * injects the generated dist engine used by the published package.
+ */
+export async function reconcileAllSkills({
+  serverUrl,
+  jwt,
+  honorSyncEnabled,
+  userId = null,
+  home,
+  runAccountSync,
+  reconcileBase = reconcileBaseSkills,
+  lockOptions = {},
+}) {
+  return withSkillSyncLock(async () => {
+    const base = reconcileBase({ userId, ...(home ? { home } : {}) });
+    const account = await runAccountSync(
+      serverUrl,
+      jwt,
+      {},
+      { honorSyncEnabled },
+    );
+    return {
+      ...account,
+      baseSkills: base.skills,
+      baseInstalled: base.installed,
+      baseLinked: base.linked,
+      baseBackups: base.backups,
+    };
+  }, { ...lockOptions, ...(home ? { home } : {}) });
+}

package/src/runtime/telemetry.js

@@ -0,0 +1,92 @@
+const ERROR_CATEGORIES = new Map([
+  [2, 'usage'],
+  [3, 'auth'],
+  [4, 'network'],
+  [5, 'conflict'],
+  [6, 'backend'],
+  [7, 'unexpected'],
+  [8, 'payment'],
+]);
+
+export function cliDurationBucket(durationMs) {
+  if (durationMs < 1_000) return 'under_1s';
+  if (durationMs < 5_000) return '1s_to_5s';
+  if (durationMs < 30_000) return '5s_to_30s';
+  return 'over_30s';
+}
+
+export function cliBackendKind(spec) {
+  const value = String(spec?.backend_call?.type || '').toLowerCase();
+  if (value === 'tool') return 'tool';
+  if (value === 'http') return 'http';
+  if (value === 'local') return 'local';
+  if (value.includes('health')) return 'health';
+  if (value.includes('local')) return 'local';
+  return 'other';
+}
+
+export function buildCliTelemetryPayload({
+  spec,
+  runtime,
+  result,
+  durationMs,
+  error,
+}) {
+  return {
+    command_id: spec.command_path.join('.'),
+    backend_kind: cliBackendKind(spec),
+    result,
+    error_category: result === 'failed'
+      ? (ERROR_CATEGORIES.get(Number(error?.exitCode)) || 'unexpected')
+      : 'none',
+    duration_bucket: cliDurationBucket(durationMs),
+    cli_version: runtime.cliVersion,
+    agent_mode: Boolean(runtime.agentMode),
+  };
+}
+
+export async function reportCliCommand({
+  spec,
+  runtime,
+  result,
+  durationMs,
+  error = null,
+  fetchImpl = globalThis.fetch,
+}) {
+  // Backend tool calls emit authoritative surface/tool telemetry server-side.
+  // This client event exists only for local commands that otherwise leave no
+  // observable runtime boundary.
+  if (
+    cliBackendKind(spec) !== 'local'
+    || !runtime?.jwt
+    || !runtime?.apiBase
+    || typeof fetchImpl !== 'function'
+  ) {
+    return false;
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 1_500);
+  try {
+    const response = await fetchImpl(`${runtime.apiBase}/cli_telemetry`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${runtime.jwt}`,
+        'Content-Type': 'application/json',
+        'X-Notis-CLI-Version': runtime.cliVersion,
+      },
+      body: JSON.stringify(buildCliTelemetryPayload({
+        spec,
+        runtime,
+        result,
+        durationMs,
+        error,
+      })),
+      signal: controller.signal,
+    });
+    return response.ok;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timeout);
+  }
+}