@agentshouse/kit 0.1.0-alpha.25 → 0.1.0-alpha.27

package/src/directory.js

@@ -1,10 +1,8 @@
 import { constants } from "node:fs";
-import { access, mkdir, realpath, rename, rm, stat } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { access, mkdir, realpath, stat } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { LAUNCH_DIRECTORY_BASE } from "./contract.js";
 import { KitRefusal } from "./refusal.js";
-import { seedStarterSet } from "./starter-set.js";
 
 export function launchBase(dependencies = {}) {
   return dependencies.launchBase ?? LAUNCH_DIRECTORY_BASE;
@@ -39,25 +37,9 @@ function unavailable(path, cause) {
   return new KitRefusal("kit_launch_directory_unavailable", `${path} ${cause}`);
 }
 
-async function isDirectory(path) {
-  try {
-    return (await stat(path)).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-async function seedDefaultDirectory(selected, base, path) {
-  const staging = join(base, `.${randomUUID()}.staging`);
-  try {
-    await seedStarterSet(staging);
-    await rename(staging, path);
-  } catch (error) {
-    await rm(staging, { recursive: true, force: true }).catch(() => undefined);
-    if (!(await isDirectory(path))) {
-      throw unavailable(selected, `could not be prepared (${error.code ?? "unknown"})`);
-    }
-  }
+async function createDefaultDirectory(selected, path) {
+  const refused = await made(path);
+  if (refused !== null) throw unavailable(selected, `could not be created (${refused})`);
 }
 
 function within(base, selected) {
@@ -73,9 +55,7 @@ export async function readyLaunchDirectory(selected, base, agentId = null, optio
   if (options.container && !within(resolve(base), path)) {
     throw unavailable(selected, `resolves outside ${base}`);
   }
-  if (path === defaultDirectory(base, agentId) && !(await isDirectory(path))) {
-    await seedDefaultDirectory(selected, base, path);
-  }
+  if (path === defaultDirectory(base, agentId)) await createDefaultDirectory(selected, path);
   let described;
   try {
     described = await stat(path);

package/src/google/calendar.js

@@ -4,9 +4,10 @@ import { googleJson } from "./gateway.js";
 import { GOOGLE_SCOPES } from "./oauth.js";
 
 const CALENDAR_ORIGIN = "https://www.googleapis.com";
+const CALENDAR = "primary";
 
-function cursorOf(value, calendars) {
-  if (value === null) return { calendar: 0, pageToken: null, syncTokens: {} };
+function cursorOf(value) {
+  if (value === null) return { pageToken: null, syncToken: null };
   let cursor;
   try {
     cursor = JSON.parse(value);
@@ -16,16 +17,8 @@ function cursorOf(value, calendars) {
   if (
     typeof cursor !== "object" ||
     cursor === null ||
-    !Number.isInteger(cursor.calendar) ||
-    cursor.calendar < 0 ||
-    cursor.calendar >= calendars.length ||
     (cursor.pageToken !== null && typeof cursor.pageToken !== "string") ||
-    typeof cursor.syncTokens !== "object" ||
-    cursor.syncTokens === null ||
-    Array.isArray(cursor.syncTokens) ||
-    Object.entries(cursor.syncTokens).some(
-      ([calendar, token]) => !calendars.includes(calendar) || typeof token !== "string",
-    )
+    (cursor.syncToken !== null && typeof cursor.syncToken !== "string")
   ) {
     throw new KitRefusal("google_checkpoint_invalid", "calendar");
   }
@@ -45,7 +38,7 @@ function authorOf(event) {
     : event.organizer.email;
 }
 
-function normalizedEvent(event, calendar) {
+function normalizedEvent(event) {
   if (
     typeof event?.id !== "string" ||
     typeof event.etag !== "string" ||
@@ -71,45 +64,53 @@ function normalizedEvent(event, calendar) {
     author: authorOf(event),
     url: event.htmlLink ?? null,
     attachments: [],
-    container: `google/calendar/${calendar}`,
+    container: `google/calendar/${CALENDAR}`,
   };
 }
 
-function pageUrl(calendar, cursor, limit, backfillFloor) {
-  const url = new URL(
-    `/calendar/v3/calendars/${encodeURIComponent(calendar)}/events`,
-    CALENDAR_ORIGIN,
-  );
+function common(options) {
+  return {
+    directory: options.directory,
+    account: options.account,
+    requiredScopes: [GOOGLE_SCOPES.calendar],
+    signal: options.signal,
+  };
+}
+
+function pageUrl(cursor, limit, backfillFloor) {
+  const url = new URL(`/calendar/v3/calendars/${CALENDAR}/events`, CALENDAR_ORIGIN);
   url.searchParams.set("maxResults", `${limit}`);
   url.searchParams.set("singleEvents", "true");
   url.searchParams.set("showDeleted", "true");
   if (cursor.pageToken !== null) url.searchParams.set("pageToken", cursor.pageToken);
-  const syncToken = cursor.syncTokens[calendar];
-  if (syncToken !== undefined) url.searchParams.set("syncToken", syncToken);
+  if (cursor.syncToken !== null) url.searchParams.set("syncToken", cursor.syncToken);
   else if (backfillFloor !== null && backfillFloor !== undefined) {
     url.searchParams.set("timeMin", backfillFloor);
   }
   return url.toString();
 }
 
+export async function calendarEmail(options, dependencies = {}) {
+  const calendar = await googleJson(
+    { ...common(options), url: `${CALENDAR_ORIGIN}/calendar/v3/calendars/${CALENDAR}` },
+    dependencies,
+  );
+  if (typeof calendar.id !== "string") {
+    throw new KitRefusal("google_provider_response_invalid", "calendar");
+  }
+  return calendar.id;
+}
+
 export async function calendarPage(options, dependencies = {}) {
-  const calendars = options.selection.calendars;
-  let cursor = cursorOf(options.cursor, calendars);
-  const calendar = calendars[cursor.calendar];
-  const common = {
-    directory: options.directory,
-    instance: options.instance,
-    client: options.client,
-    requiredScopes: [GOOGLE_SCOPES.calendar],
-    signal: options.signal,
-  };
+  let cursor = cursorOf(options.cursor);
+  const shared = common(options);
   let answer;
   try {
     answer = await googleJson(
       {
-        ...common,
+        ...shared,
         goneCode: "google_calendar_cursor_expired",
-        url: pageUrl(calendar, cursor, options.limit, options.backfillFloor),
+        url: pageUrl(cursor, options.limit, options.backfillFloor),
       },
       dependencies,
     );
@@ -117,11 +118,9 @@ export async function calendarPage(options, dependencies = {}) {
     if (!(error instanceof KitRefusal) || error.code !== "google_calendar_cursor_expired") {
       throw error;
     }
-    const syncTokens = { ...cursor.syncTokens };
-    delete syncTokens[calendar];
-    cursor = { calendar: cursor.calendar, pageToken: null, syncTokens };
+    cursor = { pageToken: null, syncToken: null };
     answer = await googleJson(
-      { ...common, url: pageUrl(calendar, cursor, options.limit, options.backfillFloor) },
+      { ...shared, url: pageUrl(cursor, options.limit, options.backfillFloor) },
       dependencies,
     );
   }
@@ -135,23 +134,18 @@ export async function calendarPage(options, dependencies = {}) {
   }
   let next;
   if (answer.nextPageToken !== undefined) {
-    next = { calendar: cursor.calendar, pageToken: answer.nextPageToken, syncTokens: cursor.syncTokens };
+    next = { pageToken: answer.nextPageToken, syncToken: cursor.syncToken };
   } else {
     if (typeof answer.nextSyncToken !== "string") {
       throw new KitRefusal("google_provider_response_invalid", "calendar sync token");
     }
-    const syncTokens = { ...cursor.syncTokens, [calendar]: answer.nextSyncToken };
-    next = {
-      calendar: cursor.calendar + 1 === calendars.length ? 0 : cursor.calendar + 1,
-      pageToken: null,
-      syncTokens,
-    };
+    next = { pageToken: null, syncToken: answer.nextSyncToken };
   }
   const normalized = [];
   const dropped = [];
   for (const event of items) {
     try {
-      normalized.push(normalizedEvent(event, calendar));
+      normalized.push(normalizedEvent(event));
     } catch (error) {
       if (
         error instanceof KitRefusal &&
@@ -172,6 +166,6 @@ export async function calendarPage(options, dependencies = {}) {
     items: normalized,
     dropped,
     cursor: JSON.stringify(next),
-    more: answer.nextPageToken !== undefined || cursor.calendar + 1 < calendars.length,
+    more: answer.nextPageToken !== undefined,
   };
 }

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);
   }
 }