@agentshouse/kit 0.1.0-alpha.3 → 0.1.0-alpha.31

package/src/google/drive.js

@@ -1,7 +1,6 @@
 import { ITEM_BODY_MAX_BYTES } from "../contract.js";
 import { KitRefusal } from "../refusal.js";
 import { googleBoundedText, googleJson } from "./gateway.js";
-import { GOOGLE_DRIVE_ID } from "./id.js";
 import { GOOGLE_SCOPES } from "./oauth.js";
 
 const DRIVE_ORIGIN = "https://www.googleapis.com";
@@ -20,17 +19,10 @@ const TEXT_MIMES = new Set([
   "application/xhtml+xml",
   "image/svg+xml",
 ]);
-const FILE_FIELDS = "id,name,mimeType,modifiedTime,version,parents,webViewLink,owners,trashed";
-const FOLDER_FRONTIER_MAX = 4096;
+const FILE_FIELDS =
+  "id,name,mimeType,modifiedTime,version,parents,webViewLink,owners,ownedByMe,trashed";
 
-function selectionsOf(selection) {
-  return [
-    ...selection.files.map((id) => ({ kind: "file", id })),
-    ...selection.folders.map((id) => ({ kind: "folder", id })),
-  ];
-}
-
-function cursorOf(value, selections) {
+function cursorOf(value) {
   if (value === null) return null;
   let cursor;
   try {
@@ -40,29 +32,9 @@ function cursorOf(value, selections) {
   }
   const validSnapshot =
     cursor?.phase === "snapshot" &&
-    Number.isInteger(cursor.selection) &&
-    cursor.selection >= 0 &&
-    cursor.selection < selections.length &&
     (cursor.pageToken === null || typeof cursor.pageToken === "string") &&
-    typeof cursor.changeToken === "string" &&
-    Array.isArray(cursor.folders) &&
-    cursor.folders.every(
-      (folder) => typeof folder === "string" && GOOGLE_DRIVE_ID.test(folder),
-    ) &&
-    Array.isArray(cursor.visited) &&
-    cursor.visited.every(
-      (folder) => typeof folder === "string" && GOOGLE_DRIVE_ID.test(folder),
-    ) &&
-    new Set([...cursor.folders, ...cursor.visited]).size ===
-      cursor.folders.length + cursor.visited.length &&
-    cursor.folders.length + cursor.visited.length <= FOLDER_FRONTIER_MAX &&
-    (selections[cursor.selection].kind === "folder"
-      ? cursor.folders.length > 0
-      : cursor.folders.length === 0 && cursor.visited.length === 0);
-  const validChanges =
-    cursor?.phase === "changes" &&
-    cursor.selection === 0 &&
-    typeof cursor.pageToken === "string";
+    typeof cursor.changeToken === "string";
+  const validChanges = cursor?.phase === "changes" && typeof cursor.pageToken === "string";
   if (!validSnapshot && !validChanges) throw new KitRefusal("google_checkpoint_invalid", "drive");
   return cursor;
 }
@@ -70,8 +42,7 @@ function cursorOf(value, selections) {
 function common(options) {
   return {
     directory: options.directory,
-    instance: options.instance,
-    client: options.client,
+    account: options.account,
     requiredScopes: [GOOGLE_SCOPES.drive],
     signal: options.signal,
   };
@@ -86,14 +57,10 @@ function fileUrl(id, query = {}) {
 function fileMetadata(value) {
   if (
     typeof value?.id !== "string" ||
-    !GOOGLE_DRIVE_ID.test(value.id) ||
     typeof value.name !== "string" ||
     typeof value.mimeType !== "string" ||
     (value.parents !== undefined &&
-      (!Array.isArray(value.parents) ||
-        value.parents.some(
-          (parent) => typeof parent !== "string" || !GOOGLE_DRIVE_ID.test(parent),
-        )))
+      (!Array.isArray(value.parents) || value.parents.some((parent) => typeof parent !== "string")))
   ) {
     throw new KitRefusal("google_provider_response_invalid", "drive file");
   }
@@ -102,7 +69,6 @@ function fileMetadata(value) {
 
 async function parentPath(options, file, dependencies, cache) {
   const names = [];
-  const identifiers = [];
   const seen = new Set();
   let parent = file.parents?.[0] ?? null;
   while (parent !== null && parent !== "root") {
@@ -126,10 +92,9 @@ async function parentPath(options, file, dependencies, cache) {
       throw new KitRefusal("google_provider_response_invalid", "drive parent");
     }
     names.unshift(metadata.name);
-    identifiers.unshift(metadata.id);
     parent = metadata.parents?.[0] ?? null;
   }
-  return { names, identifiers };
+  return names;
 }
 
 async function contentOf(options, file, dependencies) {
@@ -190,7 +155,7 @@ async function normalizedFile(options, file, dependencies, cache) {
     author: authorOf(metadata),
     url: metadata.webViewLink ?? null,
     attachments: [],
-    container: `google/drive${folders.names.length === 0 ? "" : `/${folders.names.join("/")}`}`,
+    container: `google/drive${folders.length === 0 ? "" : `/${folders.join("/")}`}`,
   };
 }
 
@@ -239,114 +204,45 @@ async function startPageToken(options, dependencies) {
   return answer.startPageToken;
 }
 
-async function snapshotPage(options, cursor, selections, dependencies) {
-  const selected = selections[cursor.selection];
-  let files;
-  const dropped = [];
-  let nextPageToken = null;
-  if (selected.kind === "file") {
-    try {
-      files = [
-        fileMetadata(
-          await googleJson(
-            {
-              ...common(options),
-              url: fileUrl(selected.id, { fields: FILE_FIELDS }),
-              notFoundCode: "google_drive_item_missing",
-            },
-            dependencies,
-          ),
-        ),
-      ];
-    } catch (error) {
-      if (!(error instanceof KitRefusal) || error.code !== "google_drive_item_missing") throw error;
-      files = [];
-      dropped.push({
-        namespace: "google/drive",
-        nativeObjectId: selected.id,
-        nativeVersion: null,
-        code: error.code,
-      });
-    }
-  } else {
-    const folder = cursor.folders[0];
-    const url = new URL("/drive/v3/files", DRIVE_ORIGIN);
-    url.searchParams.set("q", `'${folder}' in parents and trashed = false`);
-    url.searchParams.set("pageSize", `${options.limit}`);
-    url.searchParams.set("fields", `nextPageToken,files(${FILE_FIELDS})`);
-    if (cursor.pageToken !== null) url.searchParams.set("pageToken", cursor.pageToken);
-    const answer = await googleJson({ ...common(options), url: url.toString() }, dependencies);
-    if (
-      !Array.isArray(answer.files) ||
-      (answer.nextPageToken !== undefined && typeof answer.nextPageToken !== "string")
-    ) {
-      throw new KitRefusal("google_provider_response_invalid", "drive files");
-    }
-    files = answer.files.map(fileMetadata);
-    nextPageToken = answer.nextPageToken ?? null;
-  }
-  const cache = new Map();
-  const normalized = await normalizeFiles(options, files, dependencies, cache);
-  const knownFolders = new Set([...cursor.folders, ...cursor.visited]);
-  const discoveredFolders = [
-    ...new Set(
-      files
-        .filter((file) => file.mimeType === FOLDER_MIME && !knownFolders.has(file.id))
-        .map((file) => file.id),
-    ),
-  ];
-  if (knownFolders.size + discoveredFolders.length > FOLDER_FRONTIER_MAX) {
-    throw new KitRefusal("google_drive_selection_exceeded");
+function snapshotQuery(backfillFloor) {
+  const clauses = ["'me' in owners", "trashed = false", `mimeType != '${FOLDER_MIME}'`];
+  if (backfillFloor !== null && backfillFloor !== undefined) {
+    clauses.push(`modifiedTime >= '${backfillFloor}'`);
   }
-  let next;
-  if (nextPageToken !== null) {
-    next = {
-      phase: "snapshot",
-      selection: cursor.selection,
-      pageToken: nextPageToken,
-      changeToken: cursor.changeToken,
-      folders: [...cursor.folders, ...discoveredFolders],
-      visited: cursor.visited,
-    };
-  } else if (
-    selected.kind === "folder" &&
-    cursor.folders.length - 1 + discoveredFolders.length > 0
+  return clauses.join(" and ");
+}
+
+async function snapshotPage(options, cursor, dependencies) {
+  const url = new URL("/drive/v3/files", DRIVE_ORIGIN);
+  url.searchParams.set("q", snapshotQuery(options.backfillFloor));
+  url.searchParams.set("pageSize", `${options.limit}`);
+  url.searchParams.set("fields", `nextPageToken,files(${FILE_FIELDS})`);
+  if (cursor.pageToken !== null) url.searchParams.set("pageToken", cursor.pageToken);
+  const answer = await googleJson({ ...common(options), url: url.toString() }, dependencies);
+  if (
+    !Array.isArray(answer.files) ||
+    (answer.nextPageToken !== undefined && typeof answer.nextPageToken !== "string")
   ) {
-    next = {
-      phase: "snapshot",
-      selection: cursor.selection,
-      pageToken: null,
-      changeToken: cursor.changeToken,
-      folders: [...cursor.folders.slice(1), ...discoveredFolders],
-      visited: [...cursor.visited, cursor.folders[0]],
-    };
-  } else if (cursor.selection + 1 < selections.length) {
-    const following = selections[cursor.selection + 1];
-    next = {
-      phase: "snapshot",
-      selection: cursor.selection + 1,
-      pageToken: null,
-      changeToken: cursor.changeToken,
-      folders: following.kind === "folder" ? [following.id] : [],
-      visited: [],
-    };
-  } else {
-    next = { phase: "changes", selection: 0, pageToken: cursor.changeToken };
+    throw new KitRefusal("google_provider_response_invalid", "drive files");
   }
+  const normalized = await normalizeFiles(
+    options,
+    answer.files.map(fileMetadata),
+    dependencies,
+    new Map(),
+  );
+  const next =
+    answer.nextPageToken === undefined
+      ? { phase: "changes", pageToken: cursor.changeToken }
+      : { phase: "snapshot", pageToken: answer.nextPageToken, changeToken: cursor.changeToken };
   return {
     items: normalized.items,
-    dropped: [...dropped, ...normalized.dropped],
+    dropped: normalized.dropped,
     cursor: JSON.stringify(next),
     more: true,
   };
 }
 
-async function selectedChange(options, file, dependencies, cache) {
-  if (options.selection.files.includes(file.id)) return true;
-  const folders = await parentPath(options, file, dependencies, cache);
-  return folders.identifiers.some((folder) => options.selection.folders.includes(folder));
-}
-
 async function changesPage(options, cursor, dependencies) {
   const url = new URL("/drive/v3/changes", DRIVE_ORIGIN);
   url.searchParams.set("pageToken", cursor.pageToken);
@@ -370,66 +266,45 @@ async function changesPage(options, cursor, dependencies) {
   }
   const files = answer.changes
     .filter((change) => change?.removed !== true && change?.file !== undefined)
-    .map((change) => fileMetadata(change.file));
-  const cache = new Map();
-  const selected = [];
-  const dropped = [];
-  for (const file of files) {
-    if (file.mimeType === FOLDER_MIME) continue;
-    try {
-      if (await selectedChange(options, file, dependencies, cache)) selected.push(file);
-    } catch (error) {
-      if (!(error instanceof KitRefusal) || error.code !== "google_drive_item_missing") throw error;
-      dropped.push(droppedFile(file, error.code));
-    }
-  }
-  const normalized = await normalizeFiles(options, selected, dependencies, cache);
+    .map((change) => fileMetadata(change.file))
+    .filter((file) => file.ownedByMe === true && file.trashed !== true);
+  const normalized = await normalizeFiles(options, files, dependencies, new Map());
   const pageToken = answer.nextPageToken ?? answer.newStartPageToken;
   if (typeof pageToken !== "string") {
     throw new KitRefusal("google_provider_response_invalid", "drive change token");
   }
   return {
     items: normalized.items,
-    dropped: [...dropped, ...normalized.dropped],
-    cursor: JSON.stringify({ phase: "changes", selection: 0, pageToken }),
+    dropped: normalized.dropped,
+    cursor: JSON.stringify({ phase: "changes", pageToken }),
     more: answer.nextPageToken !== undefined,
   };
 }
 
-export async function drivePage(options, dependencies = {}) {
-  const selections = selectionsOf(options.selection);
-  const stored = cursorOf(options.cursor, selections);
-  const cursor =
-    stored ?? {
-      phase: "snapshot",
-      selection: 0,
-      pageToken: null,
-      changeToken: await startPageToken(options, dependencies),
-      folders: selections[0].kind === "folder" ? [selections[0].id] : [],
-      visited: [],
-    };
-  if (cursor.phase === "snapshot") {
-    return snapshotPage(options, cursor, selections, dependencies);
+async function openedSnapshot(options, dependencies) {
+  return { phase: "snapshot", pageToken: null, changeToken: await startPageToken(options, dependencies) };
+}
+
+export async function driveEmail(options, dependencies = {}) {
+  const about = await googleJson(
+    { ...common(options), url: `${DRIVE_ORIGIN}/drive/v3/about?fields=user(emailAddress)` },
+    dependencies,
+  );
+  if (typeof about.user?.emailAddress !== "string") {
+    throw new KitRefusal("google_provider_response_invalid", "drive about");
   }
+  return about.user.emailAddress;
+}
+
+export async function drivePage(options, dependencies = {}) {
+  const cursor = cursorOf(options.cursor) ?? (await openedSnapshot(options, dependencies));
+  if (cursor.phase === "snapshot") return snapshotPage(options, cursor, dependencies);
   try {
     return await changesPage(options, cursor, dependencies);
   } catch (error) {
     if (!(error instanceof KitRefusal) || error.code !== "google_drive_cursor_expired") {
       throw error;
     }
-    const first = selections[0];
-    return snapshotPage(
-      options,
-      {
-        phase: "snapshot",
-        selection: 0,
-        pageToken: null,
-        changeToken: await startPageToken(options, dependencies),
-        folders: first.kind === "folder" ? [first.id] : [],
-        visited: [],
-      },
-      selections,
-      dependencies,
-    );
+    return snapshotPage(options, await openedSnapshot(options, dependencies), dependencies);
   }
 }

package/src/google/entries.js

@@ -0,0 +1,346 @@
+import { SOURCE_CAPTURE_INTERVAL_MS } from "../contract.js";
+import { desiredSources, maintainControl, openSession, reportSources } from "../house.js";
+import { KitRefusal } from "../refusal.js";
+import { signInModule } from "../setup.js";
+import { captureEntry, localServiceState } from "../source.js";
+import { noteNames, notePath, readHealth, readNote, removeNotes, writeNote } from "../state.js";
+import { coalescedTask, residentWake } from "../tasks.js";
+import {
+  authorizeGoogle,
+  forgetGoogleAccount,
+  googleAccount,
+  googleSignedIn,
+  GOOGLE_SCOPES,
+  GOOGLE_SOURCES,
+} from "./oauth.js";
+import { recordAccountEmail } from "./source.js";
+
+const ENTRY_NOTES = ["checkpoints", "health", "gaps", "dropped", "originals", "entries"];
+
+export const GOOGLE_APIS = Object.freeze({
+  gmail: "Gmail API",
+  calendar: "Google Calendar API",
+  drive: "Google Drive API",
+});
+
+async function heldEntries(directory) {
+  const entries = [];
+  for (const source of await noteNames(directory, GOOGLE_SOURCES, "entries")) {
+    entries.push(await readNote(notePath(directory, GOOGLE_SOURCES, source, "entries"), null));
+  }
+  return entries;
+}
+
+export async function accountEntries(directory, account) {
+  return (await heldEntries(directory)).filter((entry) => entry.account === account);
+}
+
+async function entryReport(directory, entry) {
+  const account = await googleAccount(directory, entry.account);
+  const email = account?.email ?? null;
+  if (account?.scopes.includes(GOOGLE_SCOPES[entry.service]) !== true) {
+    return { source: entry.source, state: "signed_out", email };
+  }
+  const health = await readHealth(directory, GOOGLE_SOURCES, entry.source);
+  if (health?.state === "failed") {
+    return { source: entry.source, state: "failed", email, cause: health.cause ?? null };
+  }
+  return { source: entry.source, state: "ready", email };
+}
+
+async function reportEntries(context, entries) {
+  if (entries.length === 0) return;
+  const sources = [];
+  for (const entry of entries) sources.push(await entryReport(context.directory, entry));
+  await reportSources(context.session, sources, context.signal);
+}
+
+async function captureOccurrence(context, entry) {
+  const delivered = await captureEntry(context, entry);
+  await reportEntries(context, [entry]);
+  return delivered;
+}
+
+async function collectedClient(entry, present, signal) {
+  const collected = await present(
+    {
+      steps: [
+        {
+          kind: "collect",
+          label: "Client ID of your Google OAuth client",
+          name: "client_id",
+          description: `In your own Google Cloud project, enable the ${GOOGLE_APIS[entry.service]} and create an OAuth client of type Desktop app. Paste its client ID here.`,
+        },
+        {
+          kind: "collect",
+          label: "Client secret of that OAuth client",
+          name: "client_secret",
+          description: `Paste the same client's secret. It stays on this Environment beside the ${entry.account} account's sign-in.`,
+        },
+      ],
+    },
+    signal,
+  );
+  return { id: collected.client_id.trim(), secret: collected.client_secret.trim() };
+}
+
+function consent(entry, present, signal) {
+  return async ({ url }) => {
+    const collected = await present(
+      {
+        steps: [
+          {
+            kind: "visit",
+            label: `Sign in to Google for ${entry.account} and allow access for ${entry.service}`,
+            url,
+          },
+          {
+            kind: "collect",
+            label: "The address your browser ended on",
+            name: "address",
+            description:
+              "After you allow access, Google sends your browser to a 127.0.0.1 address that does not open. Copy that whole address from the address bar and paste it here.",
+          },
+        ],
+      },
+      signal,
+    );
+    return collected.address;
+  };
+}
+
+async function guidedSignIn(context, entry, present, signal) {
+  try {
+    const account = await googleAccount(context.directory, entry.account);
+    await authorizeGoogle(
+      {
+        directory: context.directory,
+        account: entry.account,
+        client: account?.client ?? (await collectedClient(entry, present, signal)),
+        scopes: [GOOGLE_SCOPES[entry.service]],
+        approve: consent(entry, present, signal),
+      },
+      context.dependencies,
+    );
+    return "ready";
+  } catch (error) {
+    if (signal.aborted) return "cancelled";
+    if (error instanceof KitRefusal && error.code === "google_authorization_declined") {
+      return "cancelled";
+    }
+    return "failed";
+  }
+}
+
+async function signIn(context, entry) {
+  const outcome = await signInModule(context, {
+    category: "connector",
+    name: entry.source,
+    login: { integration: "google", instance: entry.account, service: entry.service },
+    install: null,
+    signedIn: () => googleSignedIn(context.directory, entry.account, entry.service),
+    guided: ({ present, signal }) => guidedSignIn(context, entry, present, signal),
+  });
+  if (outcome.status !== "ready") return false;
+  await removeNotes(context.directory, GOOGLE_SOURCES, entry.source, ["health"]);
+  try {
+    await recordAccountEmail(context, { account: entry.account, service: entry.service });
+  } catch (error) {
+    if (!(error instanceof KitRefusal) || error.code === "kit_command_cancelled") throw error;
+  }
+  await reportEntries(context, [entry]);
+  return true;
+}
+
+export function sourceEntries(context) {
+  const { directory, session, dependencies } = context;
+  const interval = dependencies.sourceCaptureIntervalMs ?? SOURCE_CAPTURE_INTERVAL_MS;
+  const held = new Map();
+  const wake = residentWake();
+  let attempted = new Set();
+  let signingIn = null;
+  let cadence = Promise.resolve();
+
+  function occasion(record) {
+    return {
+      session,
+      directory,
+      dependencies,
+      now: context.now,
+      signal: AbortSignal.any([context.signal, record.stop.signal]),
+    };
+  }
+
+  function occur(record) {
+    const current = (record.running ?? Promise.resolve())
+      .catch(() => {})
+      .then(() => {
+        record.last = context.now().getTime();
+        return captureOccurrence(occasion(record), record.entry);
+      });
+    record.running = current;
+    current
+      .finally(() => {
+        if (record.running === current) record.running = null;
+        signIns.trigger();
+        wake.notify();
+      })
+      .catch(() => {});
+    return current;
+  }
+
+  function track(entry) {
+    const record = held.get(entry.source);
+    if (record !== undefined) record.entry = entry;
+    else held.set(entry.source, { entry, last: null, running: null, stop: new AbortController() });
+  }
+
+  async function drop(source, record) {
+    record.stop.abort();
+    held.delete(source);
+    if (signingIn?.source === source) await signingIn.task.catch(() => {});
+    await record.running?.catch(() => {});
+    await removeNotes(directory, GOOGLE_SOURCES, source, ENTRY_NOTES);
+  }
+
+  const signIns = coalescedTask(context.signal, context.unavailable, async () => {
+    for (const record of [...held.values()]) {
+      if (context.draining()) return;
+      const { entry } = record;
+      if (record.stop.signal.aborted || attempted.has(entry.source)) continue;
+      if (await googleSignedIn(directory, entry.account, entry.service)) continue;
+      attempted.add(entry.source);
+      const task = signIn(occasion(record), entry);
+      signingIn = { source: entry.source, task };
+      try {
+        if (await task) record.last = null;
+      } catch (error) {
+        if (!record.stop.signal.aborted) throw error;
+      } finally {
+        signingIn = null;
+      }
+      wake.notify();
+    }
+  });
+
+  const reconciling = coalescedTask(context.signal, context.unavailable, async () => {
+    const desired = await desiredSources(session, context.signal);
+    const named = new Set(desired.map((entry) => entry.source));
+    for (const [source, record] of [...held]) {
+      if (!named.has(source)) await drop(source, record);
+    }
+    for (const entry of desired) {
+      await writeNote(notePath(directory, GOOGLE_SOURCES, entry.source, "entries"), entry);
+      track(entry);
+    }
+    await reportEntries({ session, directory, signal: context.signal }, desired);
+    attempted = new Set();
+    signIns.trigger();
+    wake.notify();
+    const kept = [...new Set(desired.map((entry) => entry.account))];
+    for (const account of await noteNames(directory, GOOGLE_SOURCES, "credentials")) {
+      if (!kept.includes(account)) await forgetGoogleAccount(directory, account, kept, dependencies);
+    }
+  });
+
+  async function startDue() {
+    let next = interval;
+    const now = context.now().getTime();
+    for (const record of [...held.values()]) {
+      if (record.running !== null) continue;
+      const due = record.last === null ? 0 : record.last + interval - now;
+      if (due > 0) {
+        next = Math.min(next, due);
+        continue;
+      }
+      try {
+        if (!(await googleSignedIn(directory, record.entry.account, record.entry.service))) continue;
+      } catch (error) {
+        context.unavailable(error);
+        continue;
+      }
+      if (record.stop.signal.aborted || record.running !== null) continue;
+      occur(record).catch((error) => {
+        if (!record.stop.signal.aborted && !context.signal.aborted) context.unavailable(error);
+      });
+    }
+    return next;
+  }
+
+  return {
+    async start() {
+      try {
+        for (const entry of await heldEntries(directory)) track(entry);
+      } catch (error) {
+        context.unavailable(error);
+      }
+      cadence = (async () => {
+        while (!context.signal.aborted) {
+          await wake.wait(context.draining() ? interval : await startDue(), context.signal);
+        }
+      })();
+    },
+    reconcile: () => reconciling.trigger(),
+    capture(source) {
+      const record = held.get(source);
+      if (record === undefined) return Promise.reject(new KitRefusal("kit_instance_unknown", source));
+      return occur(record);
+    },
+    idle: () =>
+      reconciling.idle() &&
+      signIns.idle() &&
+      [...held.values()].every((record) => record.running === null),
+    async settled() {
+      await reconciling.settled();
+      await signIns.settled();
+      await cadence;
+      await Promise.all([...held.values()].map((record) => record.running?.catch(() => {})));
+    },
+  };
+}
+
+function namedEntries(entries, service) {
+  if (service === null) return entries;
+  const named = entries.filter((entry) => entry.service === service);
+  if (named.length === 0) throw new KitRefusal("kit_service_unknown", service);
+  return named;
+}
+
+export async function captureAccount(options, dependencies = {}) {
+  const entries = namedEntries(options.entries, options.service);
+  const session = await openSession(options, dependencies);
+  return maintainControl(
+    session,
+    async (signal) => {
+      const services = [];
+      for (const entry of entries) {
+        services.push(
+          session.resident === undefined
+            ? await captureOccurrence(
+                { session, directory: options.directory, dependencies, signal, now: session.now },
+                entry,
+              )
+            : await session.capture(entry.source, signal),
+        );
+      }
+      return { instance: options.account, services };
+    },
+    options.signal,
+  );
+}
+
+export async function accountStatus(options) {
+  const services = [];
+  for (const entry of namedEntries(options.entries, options.service)) {
+    const local = await localServiceState(options.directory, GOOGLE_SOURCES, entry.source);
+    services.push({
+      service: entry.service,
+      source_ref: entry.source,
+      rooms: entry.rooms,
+      signed_in: await googleSignedIn(options.directory, entry.account, entry.service),
+      ...local,
+      enable: local.health.cause === "api_disabled" ? GOOGLE_APIS[entry.service] : null,
+    });
+  }
+  return { instance: options.account, preset: "google", services };
+}