yaver-feedback-react-native 0.9.2 → 0.9.3

package/src/_core/device.ts

@@ -41,10 +41,6 @@ export interface CoreDevice {
   runnerDown: boolean;
   /** Unix ms of the latest heartbeat the agent sent to Convex. */
   lastHeartbeat: number;
-  isGuest: boolean;
-  hostName?: string;
-  hostEmail?: string;
-  accessScope?: 'owner' | 'shared-scoped' | 'shared-legacy';
   /** Primary LAN IP (or tunnel host) the agent advertised. */
   quicHost: string;
   quicPort: number;
@@ -75,10 +71,6 @@ function normHost(host: string | undefined): string {
 export function deviceIdentityKey(d: CoreDevice): string {
   if (d.hwid) return `hwid:${d.hwid}`;
   if (d.publicKey) return `pub:${d.publicKey}`;
-  if (d.isGuest) {
-    const scope = d.hostEmail || d.hostName || 'guest';
-    return `guest:${scope}:${d.deviceId || d.name}`;
-  }
   const n = normName(d.name);
   const os = String(d.platform || '').trim().toLowerCase();
   if (n && os) return `host:${os}:${n}`;
@@ -87,7 +79,6 @@ export function deviceIdentityKey(d: CoreDevice): string {
 }
 
 export function deviceAliasKey(d: CoreDevice): string | null {
-  if (d.isGuest) return null;
   const n = normName(d.name);
   const os = String(d.platform || '').trim().toLowerCase();
   if (!n || !os) return null;
@@ -95,7 +86,6 @@ export function deviceAliasKey(d: CoreDevice): string | null {
 }
 
 export function deviceEndpointKey(d: CoreDevice): string | null {
-  if (d.isGuest) return null;
   const h = normHost(d.quicHost);
   if (!h) return null;
   return `${h}:${d.quicPort || 0}`;
@@ -212,11 +202,10 @@ export function collapseDevices(devices: CoreDevice[]): CoreDevice[] {
 // ── Freshness + target pick ───────────────────────────────────────────
 
 /**
- * "Fresh" matches the mobile app: online + heartbeat within
- * HEARTBEAT_STALE_MS. Clients read Convex's `isOnline` first (the backend
- * applies the same gate from the server clock), then use this helper when
- * they need the phone-side freshness opinion too — e.g. for auto-connect
- * picks.
+ * "Fresh" matches the mobile app: online + heartbeat < 90 s. Clients
+ * read Convex's `isOnline` first (backend already applies its own 90 s
+ * gate from the server clock), then use this helper when they need the
+ * phone-side freshness opinion too — e.g. for auto-connect picks.
  */
 export function isDeviceFresh(d: CoreDevice, now = Date.now()): boolean {
   if (!d.isOnline) return false;
@@ -225,20 +214,11 @@ export function isDeviceFresh(d: CoreDevice, now = Date.now()): boolean {
 }
 
 /**
- * Choose the best candidate for an auto-connect attempt.
- *
- * An explicit `preferredDeviceId` is honoured by id ALONE, or not at all:
- *   - A missing `quicHost` is not grounds to reroute. Relay transport
- *     addresses a device by id (`<relay>/d/<deviceId>`), so the entry is
- *     still reachable off-LAN — which is precisely when quicHost is absent.
- *   - If the id is not in the list, return null. Falling through to another
- *     machine silently lands the user's fix on the wrong host: they pick the
- *     Mac mini, the commit shows up on the laptop, and nothing reports an
- *     error. Not connecting is the better failure — the caller surfaces
- *     "selected machine missing, re-select it".
- *
- * With no preference, fall back: fresh + quicHost → online + quicHost →
- * first with a quicHost.
+ * Choose the best candidate for an auto-connect attempt. Preference:
+ *   1. explicit `preferredDeviceId`, by identity alone; missing means fail
+ *   2. fresh (online + recent heartbeat) + has a quicHost
+ *   3. online + has a quicHost
+ *   4. first with a quicHost
  */
 export function pickTargetDevice(
   devices: CoreDevice[],
@@ -246,7 +226,10 @@ export function pickTargetDevice(
 ): CoreDevice | null {
   if (!devices.length) return null;
   if (preferredDeviceId) {
-    return devices.find((d) => d.deviceId === preferredDeviceId) ?? null;
+    // An off-LAN device normally has no quicHost; the relay addresses it by
+    // id. Never fall through to a different healthy machine after the user
+    // selected one explicitly — failure is safer than misrouting their work.
+    return devices.find((d) => d.deviceId === preferredDeviceId) || null;
   }
   const fresh = devices.find((d) => isDeviceFresh(d) && d.quicHost);
   if (fresh) return fresh;

package/src/_core/endpoints.ts

@@ -65,13 +65,6 @@ export const CONVEX_ENDPOINTS = {
   authLogin: '/auth/login',
   userSettings: '/settings',
   platformConfig: '/config',
-  guestsList: '/guests/list',
-  guestsHosts: '/guests/hosts',
-  guestsAllowed: '/guests/allowed',
-  guestsInvite: '/guests/invite',
-  guestsAccept: '/guests/accept',
-  guestsAcceptCode: '/guests/accept-code',
-  guestsRevoke: '/guests/revoke',
 } as const;
 
 /** Routes on a relay server. */

package/src/_core/index.ts

@@ -18,3 +18,7 @@
 export * from './constants';
 export * from './endpoints';
 export * from './device';
+export * from './ansi';
+export * from './trace';
+export * from './remoteless';
+export * from './buildFeedbackPrompt';

package/src/_core/remoteless.ts

@@ -0,0 +1,110 @@
+// AUTO-SYNCED from shared/client-core/src/remoteless.ts.
+// DO NOT EDIT IN PLACE. Edit the source and re-run
+// scripts/sync-client-core.sh. CI checks drift via `--check`.
+
+// One pure decision for every client surface that can explicitly select, or
+// fall back to, a local or hosted DeepSeek lane. Remoteless is bounded capacity
+// and never becomes the default ahead of configured devices and runners.
+
+export type RemotelessCapability =
+  | "analysis-chat" | "code-edit" | "git-read" | "git-commit" | "git-push"
+  | "static-preflight" | "existing-web-artifact"
+  | "dev-server" | "web-build" | "flutter-render" | "native-build"
+  | "simulator" | "shell" | "test" | "deploy" | "container";
+
+export type RemotelessSupport = "supported" | "bounded" | "unavailable";
+
+export type RemotelessCapabilityResult = {
+  capability: RemotelessCapability;
+  support: RemotelessSupport;
+  code: string;
+  summary: string;
+  detail: string;
+  route: { label: string; path: "/devices" | "/cloud-onboarding" };
+  alternateRoute?: { label: string; path: "/devices" | "/cloud-onboarding" };
+};
+
+export type ExecutionCandidate = {
+  id: string;
+  name: string;
+  role: "explicit" | "primary" | "secondary" | "focused";
+  connected: boolean;
+};
+
+export type RemotelessPlacement =
+  | { lane: "remote"; target: ExecutionCandidate; degraded: boolean; banner: string | null }
+  | { lane: "remoteless"; capability: RemotelessCapabilityResult; banner: string }
+  | { lane: "blocked"; capability: RemotelessCapabilityResult; banner: string };
+
+const LOCAL_SUPPORT: Record<RemotelessCapability, RemotelessSupport> = {
+  "analysis-chat": "supported", "code-edit": "bounded", "git-read": "supported", "git-commit": "bounded",
+  "git-push": "bounded", "static-preflight": "supported",
+  "existing-web-artifact": "supported", "dev-server": "unavailable",
+  "web-build": "unavailable", "flutter-render": "unavailable",
+  "native-build": "unavailable", simulator: "unavailable", shell: "unavailable",
+  test: "unavailable", deploy: "unavailable", container: "unavailable",
+};
+
+const LABELS: Record<RemotelessCapability, string> = {
+  "analysis-chat": "analysis and chat", "code-edit": "editing", "git-read": "Git inspection", "git-commit": "Git commit",
+  "git-push": "Git push", "static-preflight": "static preflight",
+  "existing-web-artifact": "an existing web artifact", "dev-server": "a dev server",
+  "web-build": "a web build", "flutter-render": "Flutter rendering",
+  "native-build": "a native build", simulator: "a simulator", shell: "shell commands",
+  test: "tests", deploy: "deployment", container: "containers",
+};
+
+export function remotelessCapability(capability: RemotelessCapability, surface: "ios" | "android" | "web" | "companion"): RemotelessCapabilityResult {
+  const support = capability === "analysis-chat" ? "supported" : surface === "ios" || surface === "android"
+    ? LOCAL_SUPPORT[capability]
+    : capability === "existing-web-artifact" ? "supported" : "unavailable";
+  const label = LABELS[capability];
+  const host = surface === "ios" ? "iPhone/iPad" : surface === "android" ? "Android device" : surface === "web" ? "browser" : "companion device";
+  if (support === "supported") return {
+    capability, support, code: `remoteless.${capability}.supported`,
+    summary: `${label} can run on this device`,
+    detail: `${label} does not require a remote shell or build toolchain.`,
+    route: { label: "Choose a device", path: "/devices" },
+  };
+  if (support === "bounded") return {
+    capability, support, code: `remoteless.${capability}.bounded`,
+    summary: `${label} is available on this device with limits`,
+    detail: `${label} can run locally, but background execution is bounded and interrupted work returns to Review.`,
+    route: { label: "Choose a device", path: "/devices" },
+  };
+  return {
+    capability, support, code: `remoteless.${capability}.unavailable`,
+    summary: `${label} needs another execution target`,
+    detail: capability === "flutter-render"
+      ? `The ${host} can display an already-built Flutter web artifact, but Yaver's remoteless runtime has no Flutter SDK, shell, dev server, or simulator. Build and serve it on your primary/secondary device or Cloud Workspace.`
+      : `Yaver's remoteless runtime on this ${host} cannot provide ${label}: it has no general shell, package manager, persistent process host, simulator, native SDK, or container runtime. Use an eligible primary/secondary device or Cloud Workspace.`,
+    route: { label: "Choose a capable device", path: "/devices" },
+    alternateRoute: { label: "Use Cloud Workspace", path: "/cloud-onboarding" },
+  };
+}
+
+export function resolveRemotelessPlacement(input: {
+  capability: RemotelessCapability;
+  surface: "ios" | "android" | "web" | "companion";
+  candidates: ExecutionCandidate[];
+  forceLocal?: boolean;
+}): RemotelessPlacement {
+  const capability = remotelessCapability(input.capability, input.surface);
+  if (!input.forceLocal) {
+    // Enforce precedence here instead of trusting every surface to construct
+    // its array correctly. Within a role, caller order remains significant
+    // (for example project-assigned primary before account-wide primary).
+    const target = (["explicit", "primary", "secondary", "focused"] as const)
+      .map((role) => input.candidates.find((candidate) => candidate.role === role && candidate.connected))
+      .find((candidate): candidate is ExecutionCandidate => !!candidate);
+    if (target) {
+      const degraded = target.role === "secondary";
+      return { lane: "remote", target, degraded, banner: degraded ? `Using secondary · ${target.name} · primary unavailable` : null };
+    }
+  }
+  const configured = input.candidates.filter((candidate) => candidate.role !== "focused");
+  const reason = configured.length ? "Primary and secondary devices are unavailable." : "No eligible remote device is configured.";
+  if (capability.support === "unavailable") return { lane: "blocked", capability, banner: `${reason} ${capability.summary}.` };
+  if (input.forceLocal) return { lane: "remoteless", capability, banner: `No remote box selected · ${capability.summary}.` };
+  return { lane: "remoteless", capability, banner: `Remoteless fallback · ${reason} ${capability.summary}.` };
+}

package/src/_core/trace.test.ts

@@ -0,0 +1,58 @@
+// AUTO-SYNCED from shared/client-core/src/trace.test.ts.
+// DO NOT EDIT IN PLACE. Edit the source and re-run
+// scripts/sync-client-core.sh. CI checks drift via `--check`.
+
+/**
+ * trace.test.ts — guards for the shared trace assembler.
+ *
+ * Run: npx tsx shared/client-core/src/trace.test.ts
+ */
+import { assembleTrace } from "./trace";
+
+let failures = 0;
+const eq = (got: unknown, want: unknown, label: string) => {
+  if (JSON.stringify(got) === JSON.stringify(want)) console.log(`ok   ${label}`);
+  else { console.error(`FAIL ${label}:\n  got  ${JSON.stringify(got)}\n  want ${JSON.stringify(want)}`); failures++; }
+};
+const ok = (c: unknown, label: string) => eq(Boolean(c), true, label);
+
+{
+  const t = assembleTrace({
+    surface: "web",
+    surfaceVersion: "1.1.164",
+    agentVersion: "1.99.409",
+    device: "ubuntu-4gb-hel1-1 (2ed7da41…)",
+    relay: "public-free",
+    task: { id: "abc123", status: "failed", runner: "opencode", model: "deepseek/deepseek-v4-flash", title: "build" },
+    error: "flutter exited before becoming ready",
+    raw: "the raw failure bytes",
+    logTail: "line1\nline2",
+    ts: 1700000000000,
+  });
+  ok(t.includes("surface: web"), "surface line present");
+  ok(t.includes("agent.version: 1.99.409"), "agent version present");
+  ok(t.includes("task: abc123 status=failed runner=opencode"), "task line present");
+  ok(t.includes("error: flutter exited before becoming ready"), "error present");
+  ok(t.includes("log-tail:\nline1\nline2"), "log tail present under its label");
+  ok(t.includes("ts: 1700000000000"), "timestamp present");
+}
+{
+  // No invented fields when absent.
+  const t = assembleTrace({ surface: "mobile", task: { id: "x" } });
+  ok(!t.includes("agent.version"), "no agent.version when absent");
+  ok(!t.includes("error:"), "no error when absent");
+  ok(t.includes("surface: mobile"), "surface still present");
+}
+{
+  // Secrets are redacted.
+  const t = assembleTrace({ surface: "web", error: "failed with token=abc123xyz" });
+  ok(t.includes("[redacted]") && !t.includes("abc123xyz"), "token redacted from error");
+  const t2 = assembleTrace({ surface: "mobile", raw: "Authorization: Bearer deadbeef" });
+  ok(t2.includes("[redacted]") && !t2.includes("deadbeef"), "bearer redacted from raw");
+}
+
+if (failures > 0) {
+  console.error(`\n${failures} FAILURE(s)`);
+  process.exit(1);
+}
+console.log("\nall trace tests pass");

package/src/_core/trace.ts

@@ -0,0 +1,75 @@
+// AUTO-SYNCED from shared/client-core/src/trace.ts.
+// DO NOT EDIT IN PLACE. Edit the source and re-run
+// scripts/sync-client-core.sh. CI checks drift via `--check`.
+
+/**
+ * trace.ts — one shared paste-ready trace assembler for every surface.
+ *
+ * WHY (2026-08-09): a crash/failure on web, mobile, or the console used to
+ * copy different things — RawFailureBanner copied just `failure.raw`, the
+ * mobile Logs sheet copied `combinedLogText`, RuntimeLab copied raw console
+ * lines. None carried the surface identity, versions, task id, runner/model,
+ * or the log tail, so pasting into an issue or a vibing follow-up lost the
+ * context that makes a bug reproducible. One assembler here gives every
+ * surface the SAME structured blob (surface → versions → device/relay →
+ * task → error → log tail), so web and mobile can never drift
+ * (AGENTS.md: one shared classifier, no copies). Mirrored into
+ * mobile/src/_core and web/lib/_core by scripts/sync-client-core.sh.
+ */
+
+export interface TraceContext {
+  /** Surface name: "web" | "mobile" | "console" | "cli" | "watch" ... */
+  surface: string;
+  /** e.g. web build label, mobile JS bundle version, cli version. */
+  surfaceVersion?: string;
+  /** Agent version reported by /info (e.g. "1.99.409"). */
+  agentVersion?: string;
+  /** Device the task ran on (name + id). */
+  device?: string;
+  /** Relay region / id if known. */
+  relay?: string;
+  /** Task identity + lifecycle. */
+  task?: {
+    id: string;
+    status?: string;
+    runner?: string;
+    model?: string;
+    title?: string;
+  };
+  /** The human-readable error (already extracted/named). */
+  error?: string;
+  /** Raw failure blob (the undecorated original). */
+  raw?: string;
+  /** Log tail — last N lines of the relevant log (agent/relay/runtime). */
+  logTail?: string;
+  /** When the trace was captured (ms epoch). */
+  ts?: number;
+}
+
+const MASK = /token\s*[=:]\s*\S+|Bearer\s+\S+|api[_-]?key\s*[=:]\s*\S+|password\s*[=:]\s*\S+/gi;
+
+function sanitize(s: string): string {
+  return String(s || "").replace(MASK, "[redacted]");
+}
+
+/**
+ * Assemble a paste-ready trace. Every present field becomes one labelled
+ * line; nothing is ever invented. Returns a plain-text blob.
+ */
+export function assembleTrace(ctx: TraceContext): string {
+  const out: string[] = [];
+  out.push("--- Yaver trace ---");
+  out.push(`surface: ${sanitize(ctx.surface)}`);
+  if (ctx.surfaceVersion) out.push(`surface.version: ${sanitize(ctx.surfaceVersion)}`);
+  if (ctx.agentVersion) out.push(`agent.version: ${sanitize(ctx.agentVersion)}`);
+  if (ctx.device) out.push(`device: ${sanitize(ctx.device)}`);
+  if (ctx.relay) out.push(`relay: ${sanitize(ctx.relay)}`);
+  if (ctx.task) {
+    out.push(`task: ${sanitize(ctx.task.id)}${ctx.task.status ? ` status=${sanitize(ctx.task.status)}` : ""}${ctx.task.runner ? ` runner=${sanitize(ctx.task.runner)}` : ""}${ctx.task.model ? ` model=${sanitize(ctx.task.model)}` : ""}${ctx.task.title ? ` title=${sanitize(ctx.task.title)}` : ""}`);
+  }
+  if (ctx.error) out.push(`error: ${sanitize(ctx.error)}`);
+  if (ctx.raw) out.push(`raw: ${sanitize(ctx.raw)}`);
+  if (ctx.logTail) out.push(`log-tail:\n${sanitize(ctx.logTail)}`);
+  out.push(`ts: ${ctx.ts ?? Date.now()}`);
+  return out.join("\n");
+}

package/src/auth.ts

@@ -10,7 +10,7 @@
  *     (`yaver://oauth-callback`) the Yaver mobile app uses.
  *   - Email / password sign-up + login (no 2FA flow — for SDK simplicity).
  *   - Token validation.
- *   - `/devices/list` → owned + shared (guest) remote dev machines.
+ *   - `/devices/list` → owner remote dev machines.
  *
  * Mobile-only. A web equivalent will ship as a separate `yaver-web-feedback`
  * package; do not import this module from a browser bundle.
@@ -399,7 +399,7 @@ export async function loginWithEmail(
   return { token: data.token, userId: data.userId };
 }
 
-// ─── Devices (owned + shared) ─────────────────────────────────────────
+// ─── Owner devices ────────────────────────────────────────────────────
 
 export interface RemoteDevice {
   deviceId: string;
@@ -409,12 +409,6 @@ export interface RemoteDevice {
   needsAuth: boolean;
   runnerDown: boolean;
   lastHeartbeat: number;
-  isGuest: boolean;
-  hostUserId?: string;
-  hostName?: string;
-  hostEmail?: string;
-  hostUserIdString?: string;
-  accessScope: 'owner' | 'shared-scoped' | 'shared-legacy';
   quicHost: string;
   quicPort: number;
   /** Agent HTTP port — preferred over quicPort when present. */
@@ -432,7 +426,6 @@ export interface RemoteDevice {
 
 export interface DeviceList {
   owned: RemoteDevice[];
-  shared: RemoteDevice[];
 }
 
 export interface DeviceReachability {
@@ -440,52 +433,9 @@ export interface DeviceReachability {
   url?: string;
 }
 
-export interface GuestInvitation {
-  hostUserId: string;
-  hostName: string;
-  hostEmail: string;
-  hostUserIdString?: string;
-  createdAt: number;
-  expiresAt: number;
-  inviteCode?: string;
-}
-
-export interface ActiveGuestHost {
-  hostUserId: string;
-  hostName: string;
-  hostEmail: string;
-  grantedAt: number;
-}
-
-export interface GuestHostsResponse {
-  pending: GuestInvitation[];
-  active: ActiveGuestHost[];
-}
-
-export interface InvitationHostDevice {
-  deviceId: string;
-  name: string;
-  platform: string;
-  lastHeartbeat?: number;
-  proposed: boolean;
-}
-
-export interface InvitationPreview {
-  inviteCode: string;
-  hostUserId: string;
-  hostName: string;
-  hostEmail: string;
-  hostUserIdString?: string;
-  proposedDeviceIds?: string[];
-  hostDevices: InvitationHostDevice[];
-  invitedByUserId?: boolean;
-  expiresAt: number;
-  createdAt: number;
-}
-
 /**
- * Fetch the set of remote dev machines this user can reach. Splits into
- * owned (user is the host) vs shared (host invited them as a guest).
+ * Fetch the signed-in owner's remote dev machines. Legacy non-owner rows are
+ * discarded even if a stale backend still returns them.
  *
  * Collapses duplicate rows before splitting — Convex can return multiple
  * rows per physical machine after a re-pair or hostname change, and the
@@ -498,7 +448,7 @@ export async function listReachableDevices(
     const res = await fetch(`${convexSiteUrl}/devices/list`, {
       headers: { Authorization: `Bearer ${token}` },
     });
-    if (!res.ok) return { owned: [], shared: [] };
+    if (!res.ok) return { owned: [] };
     const data = await res.json();
     const raw = (data.devices ?? []) as any[];
     // Normalise Convex field names → SDK's RemoteDevice shape. The
@@ -512,12 +462,6 @@ export async function listReachableDevices(
       needsAuth: !!d.needsAuth,
       runnerDown: !!d.runnerDown,
       lastHeartbeat: d.lastHeartbeat ?? 0,
-      isGuest: !!d.isGuest,
-      hostUserId: d.hostUserId,
-      hostName: d.hostName,
-      hostEmail: d.hostEmail,
-      hostUserIdString: d.hostUserIdString,
-      accessScope: d.accessScope ?? 'owner',
       quicHost: d.quicHost ?? d.host ?? '',
       quicPort: d.quicPort ?? 0,
       httpPort: d.httpPort ?? d.quicPort,
@@ -532,12 +476,9 @@ export async function listReachableDevices(
     // Lazy require so Jest + tree-shakers don't choke on a circular import.
     const { collapseRemoteDevices } = require('./deviceDedup') as typeof import('./deviceDedup');
     const deduped = collapseRemoteDevices(normalised);
-    return {
-      owned: deduped.filter((d) => !d.isGuest),
-      shared: deduped.filter((d) => d.isGuest),
-    };
+    return { owned: deduped };
   } catch {
-    return { owned: [], shared: [] };
+    return { owned: [] };
   }
 }
 
@@ -581,93 +522,3 @@ export async function probeDeviceReachability(
   }
   return { reachable: false };
 }
-
-export async function mintGuestSdkToken(
-  token: string,
-  hostUserId: string,
-  targetDeviceId: string,
-): Promise<{ token: string; expiresAt: number; allowedProjects?: string[] }> {
-  const res = await fetch(`${convexSiteUrl}/guests/sdk-token`, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${token}`,
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({ hostUserId, targetDeviceId }),
-  });
-  if (!res.ok) {
-    const data = await res.json().catch(() => ({}));
-    throw new Error(data.error || 'Failed to mint delegated SDK token');
-  }
-  return res.json();
-}
-
-export async function fetchGuestHosts(token: string): Promise<GuestHostsResponse> {
-  const res = await fetch(`${convexSiteUrl}/guests/hosts`, {
-    headers: { Authorization: `Bearer ${token}` },
-  });
-  if (!res.ok) {
-    const data = await res.json().catch(() => ({}));
-    throw new Error(data.error || 'Failed to fetch guest hosts');
-  }
-  return res.json();
-}
-
-export async function findInviteByCode(
-  token: string,
-  code: string,
-): Promise<InvitationPreview | null> {
-  const cleaned = code.toUpperCase().trim();
-  const res = await fetch(
-    `${convexSiteUrl}/guests/find-by-code?code=${encodeURIComponent(cleaned)}`,
-    { headers: { Authorization: `Bearer ${token}` } },
-  );
-  if (res.status === 404) return null;
-  if (!res.ok) {
-    const data = await res.json().catch(() => ({}));
-    throw new Error(data.error || 'Failed to load invite');
-  }
-  return res.json();
-}
-
-export async function acceptGuestByCode(
-  token: string,
-  code: string,
-  approvedDeviceIds?: string[],
-): Promise<{ hostName: string; hostEmail: string }> {
-  const res = await fetch(`${convexSiteUrl}/guests/accept-code`, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${token}`,
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({
-      code: code.toUpperCase().trim(),
-      approvedDeviceIds,
-    }),
-  });
-  if (!res.ok) {
-    const data = await res.json().catch(() => ({}));
-    throw new Error(data.error || 'Invalid invite code');
-  }
-  return res.json();
-}
-
-export async function acceptGuestInvitation(
-  token: string,
-  hostUserId: string,
-  approvedDeviceIds?: string[],
-): Promise<void> {
-  const res = await fetch(`${convexSiteUrl}/guests/accept`, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${token}`,
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({ hostUserId, approvedDeviceIds }),
-  });
-  if (!res.ok) {
-    const data = await res.json().catch(() => ({}));
-    throw new Error(data.error || 'Failed to accept invitation');
-  }
-}