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

package/src/configuration.js

@@ -7,18 +7,10 @@ import {
   MIGRATOR_TIMEOUT_MS,
 } from "./contract.js";
 import { declarationReader } from "./declaration.js";
-import { GOOGLE_DRIVE_ID } from "./google/id.js";
 import { KitRefusal } from "./refusal.js";
 
-const PRESETS = new Set(["custom", "google"]);
 const AGENT_CLIENTS = new Set(["claude-code"]);
-const GOOGLE_CURATED_SERVICES = new Set(["gmail", "calendar", "drive"]);
 const ENVIRONMENT_VALUE_MAX = 4096;
-const GOOGLE_API_HOST = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*\.googleapis\.com$/;
-const GOOGLE_API_PATH = /^\/[A-Za-z0-9._~!$&'()*+,;=:@%/-]+$/;
-const GOOGLE_API_SCOPE = /^https:\/\/www\.googleapis\.com\/auth\/[A-Za-z0-9._-]+$/;
-const EXTRACTION_PATH = /^(?:[A-Za-z_][A-Za-z0-9_-]*|\d+)(?:\.(?:[A-Za-z_][A-Za-z0-9_-]*|\d+))*$/;
-const QUERY_NAME = /^[A-Za-z][A-Za-z0-9_.-]{0,127}$/;
 
 const { refuse, plain, closed, text, positiveCount, filled } = declarationReader(
   "kit_configuration_invalid",
@@ -116,225 +108,33 @@ function backfillOf(value, declaration) {
   return { kind: named[0], bound: positiveCount(backfill[named[0]], declaration) };
 }
 
-function textList(value, declaration) {
-  return filled(value, declaration).map((entry, position) =>
-    text(entry, `${declaration}[${position}]`, 512),
-  );
-}
-
-function textArray(value, declaration) {
-  if (!Array.isArray(value)) refuse(declaration);
-  return value.map((entry, position) => text(entry, `${declaration}[${position}]`, 512));
-}
-
-function googleSelectionOf(value, declaration, service) {
-  if (service === "gmail") {
-    const selection = closed(value, ["labels"], declaration);
-    return { labels: textList(selection.labels, `${declaration}.labels`) };
-  }
-  if (service === "calendar") {
-    const selection = closed(value, ["calendars"], declaration);
-    return { calendars: textList(selection.calendars, `${declaration}.calendars`) };
-  }
-  if (service === "drive") {
-    const selection = closed(value, ["files", "folders"], declaration);
-    const files =
-      selection.files === undefined ? [] : textArray(selection.files, `${declaration}.files`);
-    const folders =
-      selection.folders === undefined ? [] : textArray(selection.folders, `${declaration}.folders`);
-    if (files.length + folders.length === 0) refuse(declaration);
-    files.forEach((id, position) => {
-      if (!GOOGLE_DRIVE_ID.test(id)) refuse(`${declaration}.files[${position}]`);
-    });
-    folders.forEach((id, position) => {
-      if (!GOOGLE_DRIVE_ID.test(id)) refuse(`${declaration}.folders[${position}]`);
-    });
-    return { files, folders };
-  }
-  refuse(declaration);
-}
-
-function extractionPath(value, declaration) {
-  const path = text(value, declaration, 512);
-  if (!EXTRACTION_PATH.test(path)) refuse(declaration);
-  return path;
-}
-
-function queryOf(value, declaration) {
-  const query = plain(value, declaration);
-  const parsed = {};
-  for (const [name, entry] of Object.entries(query)) {
-    if (!QUERY_NAME.test(name) || typeof entry !== "string" || entry.length > 2048) {
-      refuse(`${declaration}.${name}`);
-    }
-    parsed[name] = entry;
-  }
-  return parsed;
-}
-
-function declaredServiceOf(value, declaration) {
-  const declared = closed(
-    value,
-    ["host", "path", "query", "page_size", "page_token", "items", "fields", "scopes"],
-    declaration,
-  );
-  const host = text(declared.host, `${declaration}.host`, 253);
-  if (!GOOGLE_API_HOST.test(host)) refuse(`${declaration}.host`);
-  const path = text(declared.path, `${declaration}.path`, 2048);
-  if (!GOOGLE_API_PATH.test(path) || path.includes("..") || path.includes("//")) {
-    refuse(`${declaration}.path`);
-  }
-  const tokens = closed(
-    declared.page_token,
-    ["request", "response", "checkpoint_request", "checkpoint_response"],
-    `${declaration}.page_token`,
-  );
-  const pageToken = {
-    request: text(tokens.request, `${declaration}.page_token.request`, 128),
-    response: extractionPath(tokens.response, `${declaration}.page_token.response`),
-    checkpointRequest: text(
-      tokens.checkpoint_request,
-      `${declaration}.page_token.checkpoint_request`,
-      128,
-    ),
-    checkpointResponse: extractionPath(
-      tokens.checkpoint_response,
-      `${declaration}.page_token.checkpoint_response`,
-    ),
-  };
-  if (
-    !QUERY_NAME.test(pageToken.request) ||
-    !QUERY_NAME.test(pageToken.checkpointRequest) ||
-    pageToken.request === pageToken.checkpointRequest
-  ) {
-    refuse(`${declaration}.page_token`);
-  }
-  const fields = closed(
-    declared.fields,
-    [
-      "native_id",
-      "native_version",
-      "provider_modified_at",
-      "observed_at",
-      "body",
-      "container",
-      "author",
-      "url",
-    ],
-    `${declaration}.fields`,
-  );
-  const pageSize = text(declared.page_size, `${declaration}.page_size`, 128);
-  if (!QUERY_NAME.test(pageSize)) refuse(`${declaration}.page_size`);
-  const scopes = textList(declared.scopes, `${declaration}.scopes`).map((scope, position) => {
-    if (!GOOGLE_API_SCOPE.test(scope)) refuse(`${declaration}.scopes[${position}]`);
-    return scope;
-  });
-  return {
-    host,
-    path,
-    query: queryOf(declared.query, `${declaration}.query`),
-    pageSize,
-    scopes: [...new Set(scopes)],
-    pageToken,
-    items: extractionPath(declared.items, `${declaration}.items`),
-    fields: {
-      nativeId: extractionPath(fields.native_id, `${declaration}.fields.native_id`),
-      nativeVersion:
-        fields.native_version === undefined
-          ? null
-          : extractionPath(fields.native_version, `${declaration}.fields.native_version`),
-      providerModifiedAt:
-        fields.provider_modified_at === undefined
-          ? null
-          : extractionPath(
-              fields.provider_modified_at,
-              `${declaration}.fields.provider_modified_at`,
-            ),
-      observedAt: extractionPath(fields.observed_at, `${declaration}.fields.observed_at`),
-      body: textList(fields.body, `${declaration}.fields.body`).map((path, position) =>
-        extractionPath(path, `${declaration}.fields.body[${position}]`),
-      ),
-      container: extractionPath(fields.container, `${declaration}.fields.container`),
-      author:
-        fields.author === undefined
-          ? null
-          : extractionPath(fields.author, `${declaration}.fields.author`),
-      url:
-        fields.url === undefined ? null : extractionPath(fields.url, `${declaration}.fields.url`),
-    },
-  };
-}
-
-function serviceOf(value, declaration, preset) {
+function serviceOf(value, declaration) {
   const service = closed(
     value,
-    ["service", "source_ref", "rooms", "backfill", "connector", "selection", "declaration"],
+    ["service", "source_ref", "rooms", "backfill", "connector"],
     declaration,
   );
-  const name = declaredId(service.service, `${declaration}.service`);
-  if (preset === "custom" && service.connector === undefined) refuse(`${declaration}.connector`);
-  if (preset === "custom" && service.selection !== undefined) refuse(`${declaration}.selection`);
-  if (preset === "custom" && service.declaration !== undefined) refuse(`${declaration}.declaration`);
-  if (preset === "google" && service.connector !== undefined) refuse(`${declaration}.connector`);
-  if (preset === "google" && GOOGLE_CURATED_SERVICES.has(name) && service.declaration !== undefined) {
-    refuse(`${declaration}.declaration`);
-  }
-  if (preset === "google" && !GOOGLE_CURATED_SERVICES.has(name)) {
-    if (service.selection !== undefined) refuse(`${declaration}.selection`);
-    if (service.declaration === undefined) refuse(`${declaration}.declaration`);
-  }
   return {
-    service: name,
+    service: declaredId(service.service, `${declaration}.service`),
     sourceRef: text(service.source_ref, `${declaration}.source_ref`, 512),
     rooms: filled(service.rooms, `${declaration}.rooms`).map((room, position) =>
       text(room, `${declaration}.rooms[${position}]`, 512),
     ),
     backfill: backfillOf(service.backfill, `${declaration}.backfill`),
-    selection:
-      preset === "google" && GOOGLE_CURATED_SERVICES.has(name)
-        ? googleSelectionOf(service.selection, `${declaration}.selection`, name)
-        : null,
-    connector: preset === "custom" ? connectorOf(service.connector, `${declaration}.connector`) : null,
-    declaration:
-      preset === "google" && !GOOGLE_CURATED_SERVICES.has(name)
-        ? declaredServiceOf(service.declaration, `${declaration}.declaration`)
-        : null,
+    connector: connectorOf(service.connector, `${declaration}.connector`),
   };
 }
 
 function instanceOf(value, declaration) {
-  const instance = closed(value, ["id", "preset", "services", "scopes"], declaration);
-  const preset = declaredId(instance.preset, `${declaration}.preset`);
-  if (!PRESETS.has(preset)) refuse(`${declaration}.preset`);
-  if (preset !== "google" && instance.scopes !== undefined) refuse(`${declaration}.scopes`);
-  const scopes =
-    instance.scopes === undefined
-      ? []
-      : textList(instance.scopes, `${declaration}.scopes`).map((scope, position) => {
-          if (!GOOGLE_API_SCOPE.test(scope)) refuse(`${declaration}.scopes[${position}]`);
-          return scope;
-        });
+  const instance = closed(value, ["id", "preset", "services"], declaration);
   const services = filled(instance.services, `${declaration}.services`).map((service, position) =>
-    serviceOf(service, `${declaration}.services[${position}]`, preset),
+    serviceOf(service, `${declaration}.services[${position}]`),
   );
   services.forEach((service, position) => {
     const first = services.findIndex((candidate) => candidate.service === service.service);
     if (first !== position) refuse(`${declaration}.services[${position}].service`);
   });
-  services.forEach((service, position) => {
-    if (
-      service.declaration !== null &&
-      service.declaration.scopes.some((scope) => !scopes.includes(scope))
-    ) {
-      refuse(`${declaration}.services[${position}].declaration.scopes`);
-    }
-  });
-  return {
-    id: declaredId(instance.id, `${declaration}.id`),
-    preset,
-    services,
-    ...(preset === "google" ? { scopes: [...new Set(scopes)] } : {}),
-  };
+  return { id: declaredId(instance.id, `${declaration}.id`), preset: instance.preset, services };
 }
 
 function absolutePath(value, declaration) {
@@ -402,8 +202,8 @@ export function parseConfiguration(document) {
   if (typeof skills !== "boolean") refuse("skills");
   if (!Array.isArray(declared.instances)) refuse("instances");
   if (!Array.isArray(declared.migrators)) refuse("migrators");
-  const instances = declared.instances.map((instance, position) =>
-    instanceOf(instance, `instances[${position}]`),
+  const instances = declared.instances.flatMap((instance, position) =>
+    instance?.preset === "custom" ? [instanceOf(instance, `instances[${position}]`)] : [],
   );
   instances.forEach((instance, position) => {
     const first = instances.findIndex((candidate) => candidate.id === instance.id);

package/src/connector-login.js

@@ -1,91 +1,10 @@
 import { readConfiguration, sourceInstance } from "./configuration.js";
 import { authorizeCustom, customAuthorizationStatus } from "./custom/authorization.js";
-import { googleAuthorization, authorizeGoogle, GOOGLE_SCOPES } from "./google/oauth.js";
-import { KitRefusal } from "./refusal.js";
 
-function googleServiceScopes(service) {
-  const curated = GOOGLE_SCOPES[service.service];
-  return curated === undefined ? service.declaration.scopes : [curated];
-}
-
-function googleServiceAuthorized(authorization, scopes) {
-  return authorization.grants.some((grant) =>
-    scopes.every((scope) => grant.scopes.includes(scope)),
-  );
-}
-
-function googleConsent(service, context) {
-  return async ({ url }) => {
-    const collected = await context.present(
-      {
-        steps: [
-          { kind: "visit", label: `Sign in to Google and allow access for ${service.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.",
-          },
-        ],
-      },
-      context.signal,
-    );
-    return collected.address;
-  };
-}
-
-const CONNECTOR_LOGINS = {
-  custom: {
-    status: customAuthorizationStatus,
-    login: authorizeCustom,
-  },
-  google: {
-    status: async (instance, context) => {
-      const authorization = await googleAuthorization(context.directory, instance.id);
-      if (authorization === null) return false;
-      return instance.services.every((service) =>
-        googleServiceAuthorized(authorization, googleServiceScopes(service)),
-      );
-    },
-    guided: async (instance, context) => {
-      for (const service of instance.services) {
-        try {
-          await authorizeGoogle(
-            {
-              directory: context.directory,
-              instance: instance.id,
-              client: context.dependencies.googleOAuthClient(),
-              scopes: googleServiceScopes(service),
-              approve: googleConsent(service, context),
-            },
-            context.dependencies.googleDependencies ?? {},
-          );
-        } catch (error) {
-          if (context.signal.aborted) return "cancelled";
-          if (error instanceof KitRefusal && error.code === "google_authorization_declined") {
-            return "cancelled";
-          }
-          return "failed";
-        }
-      }
-      return "ready";
-    },
-  },
-};
-
-export function connectorLogin(instance, dependencies = {}) {
-  return { ...CONNECTOR_LOGINS, ...(dependencies.connectorLogins ?? {}) }[instance.preset];
-}
-
-export async function signInConnector(options, dependencies = {}) {
+export async function signInConnector(options) {
   const configuration = await readConfiguration(options.configuration);
   const instance = sourceInstance(configuration, options.instance);
-  const gateway = connectorLogin(instance, dependencies);
-  if (gateway.login === undefined) {
-    throw new KitRefusal("kit_connector_login_guided", `${instance.id} signs in through House setup`);
-  }
   const context = { directory: options.directory, signal: options.signal };
-  if (await gateway.status(instance, context)) return "skipped";
-  return (await gateway.login(instance, context)) ? "ready" : "needs_attention";
+  if (await customAuthorizationStatus(instance, context)) return "skipped";
+  return (await authorizeCustom(instance, context)) ? "ready" : "needs_attention";
 }

package/src/contract.js

@@ -259,6 +259,10 @@ export const KIT_LOGIN_REPORT_PATH = "/kit/logins/report";
 export const GUIDED_LOGIN_TIMEOUT_MS = 10 * 60 * 1000;
 export const GUIDED_LOGIN_OUTPUT_MAX_BYTES = 64 * 1024;
 
+export const KIT_SOURCES_DESIRED_PATH = "/kit/sources/desired";
+export const KIT_SOURCES_REPORT_PATH = "/kit/sources/report";
+export const SOURCE_CAPTURE_INTERVAL_MS = 15 * 60 * 1000;
+
 export const EXECUTION_AUTHORITIES = ["allow", "refuse"];
 
 export const PERMISSION_OPTION_KINDS = Object.freeze({

package/src/delivery.js

@@ -54,10 +54,8 @@ const FAILURE_CATEGORIES = {
   google_provider_unavailable: "provider",
   google_provider_response_invalid: "provider",
   google_checkpoint_invalid: "provider",
-  google_service_unsupported: "config",
-  google_oauth_client_unconfigured: "config",
-  google_drive_selection_exceeded: "config",
   google_drive_item_missing: "provider",
+  api_disabled: "config",
 };
 
 export function fileDescriptor(file) {
@@ -184,8 +182,7 @@ export function stallOf(code, houseRetry = null) {
 
 export function healthOfRun(stall) {
   if (stall === null) return { state: "ok", category: null };
-  return {
-    state: stall.disposition === "retry" ? "retrying" : "failed",
-    category: stall.category ?? FAILURE_CATEGORIES[stall.code] ?? "internal",
-  };
+  const category = stall.category ?? FAILURE_CATEGORIES[stall.code] ?? "internal";
+  if (stall.disposition === "retry") return { state: "retrying", category };
+  return { state: "failed", category, cause: stall.code };
 }

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