@agentshouse/kit 0.1.0-alpha.4 → 0.1.0-alpha.40

package/src/workspace.js

@@ -1,22 +1,29 @@
 import { access, mkdir, readFile, rm } from "node:fs/promises";
+import { createServer } from "node:net";
 import { join } from "node:path";
 import { readConfiguration } from "./configuration.js";
 import {
   CGROUP_CONTROLLERS,
   HOST_MOUNT_INFO,
+  LAUNCH_DIRECTORY_BASE,
   LOOP_CONTROL,
   WORKSPACE_ACQUIRE_MAX,
   WORKSPACE_COMMAND_TIMEOUT_MS,
+  WORKSPACE_DISK_HOUSE,
   WORKSPACE_DISK_IMAGE,
+  WORKSPACE_DISK_KIT_HOME,
   WORKSPACE_DISK_MOUNT,
   WORKSPACE_KIT_HOME,
   WORKSPACE_MOUNT_OPTIONS,
   WORKSPACE_LABEL,
-  WORKSPACE_MOUNT,
+  WORKSPACE_LOCK_POLL_MS,
   WORKSPACE_OPERATION_WITHDRAWN,
   WORKSPACE_POLL_MS,
+  WORKSPACE_PREVIOUS_SUFFIX,
   WORKSPACE_READY_ATTEMPTS,
   WORKSPACE_READY_POLL_MS,
+  WORKSPACE_RELEASE_IMAGE,
+  WORKSPACE_SELECTED_IMAGE,
   WORKSPACE_STOP_TIMEOUT_SECONDS,
   WORKSPACE_SYSTEM_RESERVE_BYTES,
 } from "./contract.js";
@@ -27,10 +34,13 @@ import {
   openSession,
   releaseControl,
   reportWorkspaceOutcome,
+  updateDrain,
 } from "./house.js";
-import { KitRefusal } from "./refusal.js";
+import { houseFailed, KitRefusal } from "./refusal.js";
 
 const REQUIRED_CONTROLLERS = ["cpu", "memory"];
+const PROVISIONED_DISK = "/disk";
+const STOPPED_STATES = ["created", "exited"];
 const MEMINFO = "/proc/meminfo";
 const MEM_AVAILABLE = /^MemAvailable:\s+(\d+)\s+kB$/m;
 
@@ -106,30 +116,35 @@ export function mountedPaths(document) {
   );
 }
 
-export function workspaceCreateArguments(identity, operation, image, house, root) {
+export function workspaceCreateArguments(identity, workspace, image, house, root) {
+  const disk = workspaceMountPath(root, identity);
   return [
     "create",
     "--name",
     identity,
     "--label",
-    `${WORKSPACE_LABEL}=${operation.environment}`,
+    `${WORKSPACE_LABEL}=${workspace.environment}`,
     "--cpus",
-    (operation.maxima.cpu_millicores / 1000).toFixed(3),
+    (workspace.maxima.cpu_millicores / 1000).toFixed(3),
     "--memory",
-    `${operation.maxima.memory_bytes}b`,
+    `${workspace.maxima.memory_bytes}b`,
     "--memory-swap",
-    `${operation.maxima.memory_bytes}b`,
+    `${workspace.maxima.memory_bytes}b`,
     "--restart",
     "no",
+    ...(new URL(house).protocol === "https:" ? [] : ["--network", "host"]),
     "--mount",
-    `type=bind,source=${workspaceMountPath(root, identity)},target=${WORKSPACE_MOUNT}`,
+    `type=bind,source=${disk}/${WORKSPACE_DISK_KIT_HOME},target=${WORKSPACE_KIT_HOME}`,
+    "--mount",
+    `type=bind,source=${disk}/${WORKSPACE_DISK_HOUSE},target=${LAUNCH_DIRECTORY_BASE}`,
+    "--env",
+    `HOME=${WORKSPACE_KIT_HOME}`,
     "--env",
     `HOUSE_KIT_HOME=${WORKSPACE_KIT_HOME}`,
     "--env",
-    `HOUSE_KIT_HOUSE=${house}`,
-    "--workdir",
-    WORKSPACE_MOUNT,
+    "HOUSE_KIT_CONTAINER=1",
     image,
+    "resident",
   ];
 }
 
@@ -198,7 +213,7 @@ export async function workspacePrerequisites(host, image) {
   if (formatter.status !== 0) {
     return {
       supported: false,
-      refusal: `the declared workspace image ${image} carries no mkfs.ext4, so no volume ceiling can be created`,
+      refusal: `the selected Kit image ${image} carries no mkfs.ext4, so no volume ceiling can be created`,
     };
   }
   return { supported: true, runtime: `docker ${version.stdout.trim()}` };
@@ -215,34 +230,45 @@ function bootstrapConfiguration() {
   });
 }
 
-function provisionArguments(root, identity, image, target, mode) {
+function diskArguments(root, identity, image, script) {
   return [
     "run",
     "--rm",
     "--interactive",
     "--mount",
-    `type=bind,source=${workspaceMountPath(root, identity)},target=${WORKSPACE_MOUNT}`,
+    `type=bind,source=${workspaceMountPath(root, identity)},target=${PROVISIONED_DISK}`,
     "--entrypoint",
     "sh",
     image,
     "-c",
-    `set -e; mkdir -p ${WORKSPACE_KIT_HOME}; chmod 700 ${WORKSPACE_KIT_HOME}; cat > ${target}; chmod ${mode} ${target}`,
+    script,
   ];
 }
 
-async function provisionWorkspaceState(host, root, identity, image, authority) {
-  for (const [target, mode, content] of [
-    [`${WORKSPACE_KIT_HOME}/credential`, "600", `${authority.credential}\n`],
-    [`${WORKSPACE_KIT_HOME}/kit.json`, "600", `${bootstrapConfiguration()}\n`],
-  ]) {
-    const written = await docker(
+async function onDisk(host, settings, identity, script, stdin = "") {
+  const written = await docker(host, diskArguments(settings.root, identity, settings.image, script), stdin);
+  if (written.status !== 0) {
+    throw new KitRefusal("kit_workspace_unprovisioned", written.stderr.trim() || identity);
+  }
+}
+
+async function provisionWorkspaceState(host, settings, identity, operation) {
+  const home = `${PROVISIONED_DISK}/${WORKSPACE_DISK_KIT_HOME}`;
+  const house = `${PROVISIONED_DISK}/${WORKSPACE_DISK_HOUSE}`;
+  const files = [
+    ...(operation.authority === undefined ? [] : [["credential", operation.authority.credential]]),
+    ["kit.json", bootstrapConfiguration()],
+    ["house", settings.house],
+    ["environment", operation.environment],
+  ];
+  for (const [name, content] of files) {
+    await onDisk(
       host,
-      provisionArguments(root, identity, image, target, mode),
-      content,
+      settings,
+      identity,
+      `set -e; mkdir -p ${home} ${house}; chmod 700 ${home} ${house}; cat > ${home}/${name}; chmod 600 ${home}/${name}`,
+      `${content}\n`,
     );
-    if (written.status !== 0) {
-      throw new KitRefusal("kit_workspace_unprovisioned", written.stderr.trim() || identity);
-    }
   }
 }
 
@@ -289,9 +315,7 @@ export async function createWorkspace(host, settings, operation) {
   }
   const mountRefusal = await mountWorkspace(host, settings, identity);
   if (mountRefusal !== null) return { outcome: "unsupported", refusal: mountRefusal };
-  if (operation.authority !== undefined) {
-    await provisionWorkspaceState(host, settings.root, identity, settings.image, operation.authority);
-  }
+  await provisionWorkspaceState(host, settings, identity, operation);
   const created = await docker(
     host,
     workspaceCreateArguments(identity, operation, settings.image, settings.house, settings.root),
@@ -312,9 +336,97 @@ async function workspacePresent(host, identity) {
   return inspected.status === 0 ? inspected.stdout.trim() : null;
 }
 
+async function heldWorkspace(host, identity) {
+  const inspected = await docker(host, [
+    "container",
+    "inspect",
+    "--format",
+    `{{.State.Status}} {{.Config.Image}} {{index .Config.Labels "${WORKSPACE_LABEL}"}} {{.HostConfig.NanoCpus}} {{.HostConfig.Memory}}`,
+    identity,
+  ]);
+  if (inspected.status !== 0) return null;
+  const [state, image, environment, nanoCpus, memory] = inspected.stdout.trim().split(/\s+/);
+  return {
+    state,
+    image,
+    environment,
+    maxima: { cpu_millicores: Number(nanoCpus) / 1_000_000, memory_bytes: Number(memory) },
+  };
+}
+
+function previousName(identity) {
+  return `${identity}${WORKSPACE_PREVIOUS_SUFFIX}`;
+}
+
+async function replaceWorkspace(host, settings, identity, held, running) {
+  const mountRefusal = await mountWorkspace(host, settings, identity);
+  if (mountRefusal !== null) return mountRefusal;
+  if (running) {
+    const stopped = await docker(host, [
+      "stop",
+      "--timeout",
+      String(WORKSPACE_STOP_TIMEOUT_SECONDS),
+      identity,
+    ]);
+    if (stopped.status !== 0) return `the workspace did not stop: ${stopped.stderr.trim()}`;
+  }
+  let cause;
+  try {
+    cause = await placeReplacement(host, settings, identity, held, running);
+  } catch (error) {
+    if (!(error instanceof KitRefusal)) throw error;
+    cause = error.message;
+  }
+  if (cause === null) {
+    const removed = await docker(host, ["rm", "--force", previousName(identity)]);
+    if (removed.status === 0) return null;
+    cause = `the previous workspace was not removed: ${removed.stderr.trim()}`;
+  }
+  return rollBack(host, identity, running, cause);
+}
+
+async function placeReplacement(host, settings, identity, held, running) {
+  await onDisk(host, settings, identity, `rm -f ${updateDrain(`${PROVISIONED_DISK}/${WORKSPACE_DISK_KIT_HOME}`)}`);
+  const setAside = await docker(host, ["rename", identity, previousName(identity)]);
+  if (setAside.status !== 0) return `the workspace was not set aside: ${setAside.stderr.trim()}`;
+  const created = await docker(
+    host,
+    workspaceCreateArguments(identity, held, settings.image, settings.house, settings.root),
+  );
+  if (created.status !== 0) return `the workspace was not recreated: ${created.stderr.trim()}`;
+  if (!running) return null;
+  const started = await docker(host, ["start", identity]);
+  if (started.status !== 0) return `the workspace did not start: ${started.stderr.trim()}`;
+  return null;
+}
+
+async function rollBack(host, identity, running, cause) {
+  const unrestored = await restorePrevious(host, identity);
+  if (unrestored !== null) return `${cause}, and ${unrestored}`;
+  if (!running) return cause;
+  const restarted = await docker(host, ["start", identity]);
+  if (restarted.status === 0) return cause;
+  return `${cause}, and the workspace did not start again: ${restarted.stderr.trim()}`;
+}
+
+async function restorePrevious(host, identity) {
+  const previous = previousName(identity);
+  if ((await workspacePresent(host, previous)) === null) return null;
+  if ((await workspacePresent(host, identity)) !== null) {
+    const discarded = await docker(host, ["rm", "--force", identity]);
+    if (discarded.status !== 0) {
+      return `the replacement was not removed: ${discarded.stderr.trim()}`;
+    }
+  }
+  const restored = await docker(host, ["rename", previous, identity]);
+  if (restored.status !== 0) return `the workspace was not restored: ${restored.stderr.trim()}`;
+  return null;
+}
+
 export async function startWorkspace(host, settings, operation) {
   const identity = operation.workspace ?? workspaceIdentity(operation);
-  if ((await workspacePresent(host, identity)) === null) return { outcome: "absent" };
+  const held = await heldWorkspace(host, identity);
+  if (held === null) return { outcome: "absent" };
   const available = memoryAvailable(await host.read(MEMINFO));
   if (available - operation.maxima.memory_bytes < WORKSPACE_SYSTEM_RESERVE_BYTES) {
     return {
@@ -324,6 +436,10 @@ export async function startWorkspace(host, settings, operation) {
   }
   const mountRefusal = await mountWorkspace(host, settings, identity);
   if (mountRefusal !== null) return { outcome: "unsupported", refusal: mountRefusal };
+  if (STOPPED_STATES.includes(held.state) && held.image !== settings.image) {
+    const refusal = await replaceWorkspace(host, settings, identity, held, false);
+    if (refusal !== null) return { outcome: "failed", refusal };
+  }
   const started = await docker(host, ["start", identity]);
   if (started.status !== 0) {
     return { outcome: "failed", refusal: `the workspace did not start: ${started.stderr.trim()}` };
@@ -409,14 +525,15 @@ export async function managedWorkspaces(host) {
   if (listed.status !== 0) {
     throw new KitRefusal("kit_workspace_inventory_unavailable", listed.stderr.trim() || null);
   }
-  return listed.stdout
-    .split("\n")
-    .map((line) => line.trim())
-    .filter((line) => line !== "")
-    .map((line) => {
-      const [name, environment, state] = line.split(/\s+/);
-      return { name, environment, state };
-    });
+  const managed = new Map();
+  for (const line of listed.stdout.split("\n").map((entry) => entry.trim()).filter((entry) => entry !== "")) {
+    const [container, environment, state] = line.split(/\s+/);
+    const name = container.endsWith(WORKSPACE_PREVIOUS_SUFFIX)
+      ? container.slice(0, -WORKSPACE_PREVIOUS_SUFFIX.length)
+      : container;
+    if (!managed.has(name)) managed.set(name, { name, environment, state });
+  }
+  return [...managed.values()];
 }
 
 export async function reconcileWorkspaces(host, authorized) {
@@ -425,76 +542,170 @@ export async function reconcileWorkspaces(host, authorized) {
   );
   const stopped = [];
   for (const managed of await managedWorkspaces(host)) {
-    if (managed.state !== "running") continue;
     if (expected.get(managed.environment) === "running") continue;
-    const settled = await docker(host, [
-      "stop",
-      "--timeout",
-      String(WORKSPACE_STOP_TIMEOUT_SECONDS),
-      managed.name,
-    ]);
-    if (settled.status === 0) stopped.push(managed.name);
+    const settled = await exclusively(host, managed.name, async () => {
+      if ((await restorePrevious(host, managed.name)) !== null) return false;
+      if ((await workspacePresent(host, managed.name)) !== "running") return false;
+      const stopping = await docker(host, [
+        "stop",
+        "--timeout",
+        String(WORKSPACE_STOP_TIMEOUT_SECONDS),
+        managed.name,
+      ]);
+      return stopping.status === 0;
+    });
+    if (settled) stopped.push(managed.name);
   }
   return stopped;
 }
 
+function workspaceLock(identity) {
+  return new Promise((resolve, reject) => {
+    const lock = createServer();
+    lock.once("error", reject);
+    lock.listen({ path: `\0${WORKSPACE_LABEL}/${identity}` }, () => resolve(lock));
+  });
+}
+
+async function exclusively(host, identity, act) {
+  let lock = null;
+  while (lock === null) {
+    try {
+      lock = await workspaceLock(identity);
+    } catch (error) {
+      if (error.code !== "EADDRINUSE") throw error;
+      await host.wait(WORKSPACE_LOCK_POLL_MS);
+    }
+  }
+  try {
+    return await act();
+  } finally {
+    await new Promise((resolve) => lock.close(resolve));
+  }
+}
+
 export async function performOperation(host, settings, operation) {
-  if (operation.kind === "create") return createWorkspace(host, settings, operation);
-  if (operation.kind === "start") return startWorkspace(host, settings, operation);
-  if (operation.kind === "stop") return stopWorkspace(host, operation);
-  return deleteWorkspace(host, settings, operation);
+  const selected = operation.kind === "stop" ? settings : { ...settings, image: await selectedImage(host) };
+  const identity = operation.workspace ?? workspaceIdentity(operation);
+  return exclusively(host, identity, async () => {
+    const unrestored = await restorePrevious(host, identity);
+    if (unrestored !== null) return { outcome: "failed", refusal: unrestored };
+    if (operation.kind === "stop") return stopWorkspace(host, operation);
+    if (operation.kind === "create") return createWorkspace(host, selected, operation);
+    if (operation.kind === "start") return startWorkspace(host, selected, operation);
+    return deleteWorkspace(host, selected, operation);
+  });
 }
 
-export async function serveWorkspaces(options, dependencies = {}) {
+async function selectedImage(host) {
+  let image;
+  try {
+    image = (await host.read(WORKSPACE_SELECTED_IMAGE)).trim();
+  } catch {
+    image = null;
+  }
+  if (image === null || !WORKSPACE_RELEASE_IMAGE.test(image)) {
+    throw new KitRefusal("kit_workspace_host_unconfigured", WORKSPACE_SELECTED_IMAGE);
+  }
+  return image;
+}
+
+async function hostSettings(options) {
   const configuration = await readConfiguration(options.configuration);
-  if (configuration.host === null || configuration.host.image === null) {
+  if (configuration.host === null) {
     throw new KitRefusal("kit_workspace_host_unconfigured", options.configuration);
   }
+  return { root: configuration.host.workspace, house: options.house };
+}
+
+async function updateWorkspace(host, settings, name) {
+  try {
+    const unrestored = await restorePrevious(host, name);
+    if (unrestored !== null) return { workspace: name, cause: unrestored };
+    const held = await heldWorkspace(host, name);
+    if (held === null || held.image === settings.image) return null;
+    const running = !STOPPED_STATES.includes(held.state);
+    if (running) {
+      const drained = await docker(host, ["exec", name, "kit", "resident", "drain"]);
+      if (drained.status !== 0) {
+        return { workspace: name, cause: drained.stdout.trim() || drained.stderr.trim() };
+      }
+    }
+    const refusal = await replaceWorkspace(host, settings, name, held, running);
+    if (refusal !== null) return { workspace: name, cause: refusal };
+    return { workspace: name, running };
+  } catch (error) {
+    if (!(error instanceof KitRefusal)) throw error;
+    return { workspace: name, cause: error.message };
+  }
+}
+
+export async function updateWorkspaces(options, dependencies = {}) {
+  const host = adapter(dependencies);
+  const updated = [];
+  const unchanged = [];
+  const managed = await managedWorkspaces(host);
+  if (managed.length === 0) return { updated, unchanged };
+  const settings = { ...(await hostSettings(options)), image: await selectedImage(host) };
+  for (const { name } of managed) {
+    const answer = await exclusively(host, name, () => updateWorkspace(host, settings, name));
+    if (answer === null) continue;
+    if (answer.cause === undefined) updated.push(answer);
+    else unchanged.push(answer);
+  }
+  return { updated, unchanged };
+}
+
+export async function serveWorkspaces(options, dependencies = {}) {
   const host = adapter(dependencies);
-  const settings = {
-    root: configuration.host.workspace,
-    image: configuration.host.image,
-    house: options.house,
-  };
+  const settings = await hostSettings(options);
   const session = await openSession(options, dependencies);
   const settled = [];
   const withdrawn = [];
   let reconciled = [];
   const passes = options.passes ?? Number.POSITIVE_INFINITY;
-  for (let pass = 0; pass < passes; pass += 1) {
-    const work = await maintainControl(
-      session,
-      async (signal) => {
-        const acquired = await acquireWorkspaces(session, WORKSPACE_ACQUIRE_MAX, signal);
-        reconciled = await reconcileWorkspaces(host, acquired.workspaces);
-        for (const operation of acquired.operations) {
-          let report;
-          try {
-            report = await performOperation(host, settings, operation);
-          } catch (error) {
-            if (!(error instanceof KitRefusal)) throw error;
-            report = { outcome: "failed", refusal: error.message };
-          }
-          try {
-            await reportWorkspaceOutcome(session, operation.operation, report, signal);
-          } catch (error) {
-            if (!(error instanceof KitRefusal) || error.code !== WORKSPACE_OPERATION_WITHDRAWN) {
-              throw error;
+  try {
+    for (let pass = 0; pass < passes; pass += 1) {
+      const work = await maintainControl(
+        session,
+        async (signal) => {
+          const acquired = await acquireWorkspaces(session, WORKSPACE_ACQUIRE_MAX, signal);
+          reconciled = await reconcileWorkspaces(host, acquired.workspaces);
+          for (const operation of acquired.operations) {
+            let report;
+            try {
+              report = await performOperation(host, settings, operation);
+            } catch (error) {
+              if (!(error instanceof KitRefusal)) throw error;
+              report = { outcome: "failed", refusal: error.message };
             }
-            withdrawn.push({ operation: operation.operation, kind: operation.kind });
-            continue;
+            try {
+              await reportWorkspaceOutcome(session, operation.operation, report, signal);
+            } catch (error) {
+              if (!(error instanceof KitRefusal) || error.code !== WORKSPACE_OPERATION_WITHDRAWN) {
+                throw error;
+              }
+              withdrawn.push({ operation: operation.operation, kind: operation.kind });
+              continue;
+            }
+            settled.push({ operation: operation.operation, kind: operation.kind, ...report });
           }
-          settled.push({ operation: operation.operation, kind: operation.kind, ...report });
-        }
-        return acquired;
-      },
-      options.signal,
-      { release: false },
-    );
-    if (pass + 1 < passes && work.operations.length === 0) {
-      await host.wait(WORKSPACE_POLL_MS);
+          return acquired;
+        },
+        options.signal,
+        { release: false },
+      ).catch((error) => {
+        if (!houseFailed(error)) throw error;
+        return null;
+      });
+      if (pass + 1 < passes && (work === null || work.operations.length === 0)) {
+        await host.wait(WORKSPACE_POLL_MS);
+      }
     }
+  } catch (error) {
+    if (!(error instanceof KitRefusal) || error.code !== "kit_command_cancelled") throw error;
+  } finally {
+    await releaseControl(session);
   }
-  await releaseControl(session);
   return { settled, reconciled, withdrawn };
 }

package/src/google/declared.js

@@ -1,146 +0,0 @@
-import { ITEM_BODY_MAX_BYTES } from "../contract.js";
-import { KitRefusal } from "../refusal.js";
-import { googleJson } from "./gateway.js";
-
-function valueAt(value, path) {
-  let current = value;
-  for (const segment of path.split(".")) {
-    if (current === null || current === undefined || typeof current !== "object") return undefined;
-    current = current[segment];
-  }
-  return current;
-}
-
-function requiredText(value, declaration) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new KitRefusal("google_provider_response_invalid", declaration);
-  }
-  return value;
-}
-
-function optionalText(value, declaration) {
-  if (value === undefined || value === null) return null;
-  return requiredText(value, declaration);
-}
-
-function cursorOf(value) {
-  if (value === null) return { pageToken: null, checkpoint: null };
-  let cursor;
-  try {
-    cursor = JSON.parse(value);
-  } catch {
-    throw new KitRefusal("google_checkpoint_invalid", "declared service");
-  }
-  if (
-    typeof cursor !== "object" ||
-    cursor === null ||
-    (cursor.pageToken !== null && typeof cursor.pageToken !== "string") ||
-    (cursor.checkpoint !== null && typeof cursor.checkpoint !== "string")
-  ) {
-    throw new KitRefusal("google_checkpoint_invalid", "declared service");
-  }
-  return cursor;
-}
-
-function composedBody(item, paths) {
-  const parts = paths.map((path) => valueAt(item, path));
-  if (parts.some((part) => !["string", "number", "boolean"].includes(typeof part))) {
-    throw new KitRefusal("google_provider_response_invalid", "declared body");
-  }
-  const body = parts.map((part) => `${part}`).join("\n\n");
-  if (Buffer.byteLength(body, "utf8") > ITEM_BODY_MAX_BYTES) {
-    throw new KitRefusal("google_provider_response_invalid", "declared body");
-  }
-  return body;
-}
-
-function normalizedItem(service, item) {
-  const fields = service.declaration.fields;
-  const observedAt = requiredText(valueAt(item, fields.observedAt), "declared observed time");
-  if (Number.isNaN(Date.parse(observedAt))) {
-    throw new KitRefusal("google_provider_response_invalid", "declared observed time");
-  }
-  const container = requiredText(valueAt(item, fields.container), "declared container");
-  const nativeVersion =
-    fields.nativeVersion === null
-      ? null
-      : optionalText(valueAt(item, fields.nativeVersion), "declared native version");
-  const providerModifiedAt =
-    fields.providerModifiedAt === null
-      ? null
-      : optionalText(
-          valueAt(item, fields.providerModifiedAt),
-          "declared provider modification time",
-        );
-  if (providerModifiedAt !== null && Number.isNaN(Date.parse(providerModifiedAt))) {
-    throw new KitRefusal("google_provider_response_invalid", "declared provider modification time");
-  }
-  return {
-    namespace: `google/${service.service}`,
-    nativeObjectId: requiredText(valueAt(item, fields.nativeId), "declared native id"),
-    nativeVersion,
-    providerModifiedAt:
-      providerModifiedAt === null ? null : new Date(providerModifiedAt).toISOString(),
-    observedAt: new Date(observedAt).toISOString(),
-    body: composedBody(item, fields.body),
-    author:
-      fields.author === null
-        ? null
-        : optionalText(valueAt(item, fields.author), "declared author"),
-    url:
-      fields.url === null ? null : optionalText(valueAt(item, fields.url), "declared url"),
-    attachments: [],
-    container: `google/${service.service}/${container}`,
-  };
-}
-
-export async function declaredPage(options, dependencies = {}) {
-  const declared = options.service.declaration;
-  const cursor = cursorOf(options.cursor);
-  const url = new URL(declared.path, `https://${declared.host}`);
-  for (const [name, value] of Object.entries(declared.query)) url.searchParams.set(name, value);
-  url.searchParams.set(declared.pageSize, `${options.limit}`);
-  if (cursor.pageToken !== null) {
-    url.searchParams.set(declared.pageToken.request, cursor.pageToken);
-  }
-  if (cursor.checkpoint !== null) {
-    url.searchParams.set(declared.pageToken.checkpointRequest, cursor.checkpoint);
-  }
-  const answer = await googleJson(
-    {
-      directory: options.directory,
-      instance: options.instance,
-      client: options.client,
-      requiredScopes: declared.scopes,
-      url: url.toString(),
-      signal: options.signal,
-    },
-    dependencies,
-  );
-  const entries = valueAt(answer, declared.items);
-  if (!Array.isArray(entries) || entries.length > options.limit) {
-    throw new KitRefusal("google_provider_response_invalid", "declared items");
-  }
-  const pageToken = valueAt(answer, declared.pageToken.response);
-  let next;
-  if (pageToken !== undefined && pageToken !== null) {
-    next = {
-      pageToken: requiredText(pageToken, "declared page token"),
-      checkpoint: cursor.checkpoint,
-    };
-  } else {
-    next = {
-      pageToken: null,
-      checkpoint: requiredText(
-        valueAt(answer, declared.pageToken.checkpointResponse),
-        "declared checkpoint",
-      ),
-    };
-  }
-  return {
-    items: entries.map((entry) => normalizedItem(options.service, entry)),
-    dropped: [],
-    cursor: JSON.stringify(next),
-    more: pageToken !== undefined && pageToken !== null,
-  };
-}

package/src/google/id.js

@@ -1 +0,0 @@
-export const GOOGLE_DRIVE_ID = /^[A-Za-z0-9_-]{1,512}$/;

package/src/instance/google.js

@@ -1 +0,0 @@
-export const GOOGLE_OAUTH_CLIENT = Object.freeze({"id":"911965338518-867gdvuddb7kdkjo3qvpv6gds369alb7.apps.googleusercontent.com","secret":"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"});