@kamilio/wire 0.1.2 → 0.1.4

package/node_modules/wire-core/src/operations.ts

@@ -55,6 +55,10 @@ export type WireWatchSession = Readonly<{
   close(): void;
 }>;
 
+export type WireWatchSyncCommand = "sync" | "download";
+export type WireWatchSyncHook = (command: WireWatchSyncCommand, result: WireResult) => Promise<WireResult>;
+export const wireWatchHooks = Symbol("wireWatchHooks");
+
 export type Wire = Readonly<{
   attach(url: string, path: string): Promise<WireResult>;
   create(url: string, path: string): Promise<WireResult>;
@@ -73,6 +77,10 @@ export type Wire = Readonly<{
   switchBackend(path: string): Promise<SwitchedWireBackend>;
 }>;
 
+type WireInternal = Wire & Readonly<{
+  [wireWatchHooks](value: string, path: string, hooks: readonly WireWatchSyncHook[]): Promise<WireWatchSession>;
+}>;
+
 async function wireRoot<FetchInput>(dependencies: WireDependencies<FetchInput>, path: string): Promise<string> {
   const configured = await dependencies.workspace.configuredRoot(path, dependencies.home);
   if (configured !== null) return configured;
@@ -147,6 +155,11 @@ function markdownSnapshot(snapshot: JsonValue): string | null {
   return typeof markdown === "string" ? markdown : null;
 }
 
+function storedSnapshot(fetched: FetchedDocument): JsonValue {
+  if (!jsonObject(fetched.data)) return fetched.data;
+  return { ...fetched.data, markdown: fetched.markdown };
+}
+
 function pathLikeResourceValue(value: string): boolean {
   return value === "." || value === ".." || value.startsWith("./") || value.startsWith("../") || value.startsWith("/") || value.includes("/") || value.includes("\\") || value.endsWith(".md");
 }
@@ -155,6 +168,15 @@ function relativePathContains(parent: string, child: string): boolean {
   return parent === "" || child === parent || child.startsWith(`${parent}/`);
 }
 
+function relativePathEscapes(path: string): boolean {
+  return path === ".." || path.startsWith("../");
+}
+
+function serviceCanSynchronize<FetchInput>(url: string, catalog: ServiceCatalog<FetchInput>): boolean {
+  const parsed = new URL(url);
+  return catalog.find((service) => service.matches(parsed))!.synchronize !== undefined;
+}
+
 function errorMessage(error: unknown): string {
   if (error instanceof Error) return error.message;
   if (typeof error === "object" && error !== null && "message" in error && typeof error["message"] === "string") return error["message"];
@@ -177,6 +199,11 @@ export function composeWire<FetchInput>(dependencies: WireDependencies<FetchInpu
     }
     const relativePath = dependencies.workspace.relativePath(outputPath, root);
     const previous = previousMarkdown === null ? await dependencies.filesystem.exists(outputPath) ? await dependencies.filesystem.readText(outputPath) : "" : previousMarkdown;
+    if (action === "attached" && current !== null) {
+      const snapshot = current.data.find((item) => item.namespace === source.service && item.key === "snapshot")!.value;
+      const baseMarkdown = markdownSnapshot(syncBase(source.service, snapshot, current.data));
+      if (baseMarkdown !== null && previous !== baseMarkdown) throw new Error(`Local edits exist for ${primaryLink(current).path}. Run \`wire sync ${primaryLink(current).path}\` before attaching this URL again.`);
+    }
     await dependencies.filesystem.writeText(outputPath, fetched.markdown);
     const id = resourceId(source);
     const primary = current?.filesystem_links.find((link) => link.path === relativePath && link.role === "primary");
@@ -195,7 +222,7 @@ export function composeWire<FetchInput>(dependencies: WireDependencies<FetchInpu
         ...(current?.data.filter((item) => item.namespace !== "wire" && !(item.namespace === source.service && item.key === "snapshot")) ?? []),
         { namespace: "wire", key: "title", value: fetched.title },
         { namespace: "wire", key: "synced_at", value: dependencies.now().toISOString() },
-        { namespace: source.service, key: "snapshot", value: fetched.data },
+        { namespace: source.service, key: "snapshot", value: storedSnapshot(fetched) },
       ],
       relationships: extractRelationships(fetched.markdown, id, dependencies.catalog),
     };
@@ -217,7 +244,11 @@ export function composeWire<FetchInput>(dependencies: WireDependencies<FetchInpu
     const fetched = await fetchSource(dependencies.fetchInput, url, dependencies.catalog);
     const source = parseSourceUrl(url, dependencies.catalog);
     const cleanPath = join(resolve(path), markdownFilename(fetched.title));
-    const outputPath = await dependencies.filesystem.exists(cleanPath) ? join(resolve(path), collisionFilename(fetched.title, source.service, source.identifier)) : cleanPath;
+    let outputPath = cleanPath;
+    if (await dependencies.filesystem.exists(cleanPath)) {
+      const existingMarkdown = await dependencies.filesystem.readText(cleanPath);
+      if (existingMarkdown !== fetched.markdown) outputPath = join(resolve(path), collisionFilename(fetched.title, source.service, source.identifier));
+    }
     const previous = await dependencies.filesystem.exists(outputPath) ? await dependencies.filesystem.readText(outputPath) : "";
     await dependencies.filesystem.writeText(outputPath, fetched.markdown);
     const id = resourceId(source);
@@ -230,7 +261,7 @@ export function composeWire<FetchInput>(dependencies: WireDependencies<FetchInpu
       data: [
         { namespace: "wire", key: "title", value: fetched.title },
         { namespace: "wire", key: "synced_at", value: dependencies.now().toISOString() },
-        { namespace: source.service, key: "snapshot", value: fetched.data },
+        { namespace: source.service, key: "snapshot", value: storedSnapshot(fetched) },
       ],
       relationships: extractRelationships(fetched.markdown, id, dependencies.catalog),
     };
@@ -273,10 +304,12 @@ export function composeWire<FetchInput>(dependencies: WireDependencies<FetchInpu
     const outputDirectory = dirname(outputPath);
     const source = parseSourceUrl(resource.urls[0]!, dependencies.catalog);
     const snapshot = resource.data.find((item) => item.namespace === source.service && item.key === "snapshot")!.value;
-    const markdown = await dependencies.filesystem.exists(outputPath) ? await dependencies.filesystem.readText(outputPath) : "";
+    if (!(await dependencies.filesystem.exists(outputPath))) throw new Error(`Linked file missing: ${primaryLink(resource).path} - restore it or run wire detach`);
+    const markdown = await dependencies.filesystem.readText(outputPath);
     const base = syncBase(source.service, snapshot, resource.data);
     const baseMarkdown = markdownSnapshot(base);
     const localChanged = baseMarkdown !== null && markdown !== baseMarkdown;
+    if (localChanged && !serviceCanSynchronize(resource.urls[0]!, dependencies.catalog)) throw new Error(`${source.service} is download-only and the local file has edits. Run \`wire download ${primaryLink(resource).path}\` to discard them.`);
     const fetched = await synchronizeSource(dependencies.fetchInput, resource.urls[0]!, dependencies.catalog, base, markdown, outputPath);
     const action = localChanged ? fetched.markdown === baseMarkdown ? "synced" : "uploaded" : fetched.markdown === markdown ? "synced" : "downloaded";
     return store(resource.urls[0]!, outputDirectory, fetched, markdown, action, undefined, action === "uploaded" && baseMarkdown !== null ? baseMarkdown : undefined, action === "uploaded" ? markdown : fetched.markdown);
@@ -298,27 +331,36 @@ export function composeWire<FetchInput>(dependencies: WireDependencies<FetchInpu
     const root = await existingWireRoot(dependencies, await dependencies.filesystem.exists(candidatePath) ? candidatePath : path);
     const registry = await dependencies.workspace.openRegistry(root, dependencies.home);
     const resource = await resolveResource(registry, value, root, path);
-    const result = await download(value, path);
+    const outputPath = join(dirname(root), primaryLink(resource).path);
+    const previous = await dependencies.filesystem.exists(outputPath) ? await dependencies.filesystem.readText(outputPath) : "";
+    const fetched = await fetchSource(dependencies.fetchInput, resource.urls[0]!, dependencies.catalog);
+    await dependencies.filesystem.writeText(outputPath, fetched.markdown);
     await registry.delete(resource.id);
-    return { ...result, summary: { ...result.summary, action: "detached" } };
+    return { resource, path: outputPath, markdown: fetched.markdown, summary: { action: "detached", ...changeSummary(previous, fetched.markdown), remote: resource.urls[0]!, local: outputPath } };
   };
   const unlink = detach;
 
-  const watch = async (value: string, path: string): Promise<WireWatchSession> => {
+  const runWatchHooks = async (hooks: readonly WireWatchSyncHook[], command: WireWatchSyncCommand, result: WireResult): Promise<WireResult> => {
+    let current = result;
+    for (const hook of hooks) current = await hook(command, current);
+    return current;
+  };
+
+  const watchWithHooks = async (value: string, path: string, hooks: readonly WireWatchSyncHook[]): Promise<WireWatchSession> => {
     const candidatePath = resolve(path, value);
     const root = await existingWireRoot(dependencies, await dependencies.filesystem.exists(candidatePath) ? candidatePath : path);
     const config = watchConfig(await dependencies.workspace.loadConfig!(root));
     const registry = await dependencies.workspace.openRegistry(root, dependencies.home);
     const resource = await resolveResource(registry, value, root, path);
     const outputPath = join(dirname(root), primaryLink(resource).path);
-    const initial = await dependencies.filesystem.exists(outputPath) ? null : await download(value, path);
+    const initial = await dependencies.filesystem.exists(outputPath) ? null : await runWatchHooks(hooks, "download", await download(value, path));
     let lastSyncedMarkdown = initial === null ? await dependencies.filesystem.readText(outputPath) : initial.markdown;
     let debounce: ReturnType<typeof setTimeout> | undefined;
     let resolveClosed!: () => void;
     const closed = new Promise<void>((resolveClosedPromise) => { resolveClosed = resolveClosedPromise; });
     const handles: WatchHandle[] = [];
     const synchronize = async () => {
-      const result = config.mode === "download" ? await download(value, path) : await sync(value, path);
+      const result = config.mode === "download" ? await runWatchHooks(hooks, "download", await download(value, path)) : await runWatchHooks(hooks, "sync", await sync(value, path));
       lastSyncedMarkdown = result.markdown;
     };
     const schedule = () => {
@@ -349,6 +391,8 @@ export function composeWire<FetchInput>(dependencies: WireDependencies<FetchInpu
     });
   };
 
+  const watch = (value: string, path: string): Promise<WireWatchSession> => watchWithHooks(value, path, []);
+
   const openResource = async (value: string, path: string): Promise<Resource> => {
     const candidatePath = resolve(path, value);
     const root = await existingWireRoot(dependencies, await dependencies.filesystem.exists(candidatePath) ? candidatePath : path);
@@ -362,6 +406,7 @@ export function composeWire<FetchInput>(dependencies: WireDependencies<FetchInpu
     const root = await existingWireRoot(dependencies, path);
     const registry = await dependencies.workspace.openRegistry(root, dependencies.home);
     const scope = dependencies.workspace.relativePath(path, root);
+    if (relativePathEscapes(scope)) throw new Error(`Sync scope is outside the Wire workspace: root ${dirname(root)}, path ${path}`);
     const results: WireResult[] = [];
     for (const resource of await registry.listResources()) {
       const outputPath = join(dirname(root), primaryLink(resource).path);
@@ -404,5 +449,6 @@ export function composeWire<FetchInput>(dependencies: WireDependencies<FetchInpu
     showResource,
     init: dependencies.workspace.initialize,
     switchBackend: (path: string) => dependencies.workspace.switchBackend!(path, dependencies.home),
-  });
+    [wireWatchHooks]: watchWithHooks,
+  }) as WireInternal;
 }

package/node_modules/wire-core/src/ports.ts

@@ -134,4 +134,5 @@ export interface RuntimeCapabilities {
   readonly secrets: SecretsCapability;
   readonly cookies: CookiesCapability;
   readonly gmailTokens: GoogleTokensCapability;
+  readonly googleFormsTokens: GoogleTokensCapability;
 }

package/node_modules/wire-core/src/runtime/chrome.ts

@@ -23,10 +23,13 @@ export async function chromeLaunchArguments(environment: NodeEnvironment, startU
     "--remote-debugging-port=0",
     "--no-first-run",
     "--no-default-browser-check",
+    "--restore-last-session",
     startUrl,
   ]);
 }
 
+const chromeExecutable = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
+
 interface ChromeCookie {
   readonly domain: string;
   readonly expires: number;
@@ -35,6 +38,10 @@ interface ChromeCookie {
   readonly path: string;
   readonly secure: boolean;
   readonly value: string;
+  readonly sameSite?: string;
+  readonly sourceScheme?: string;
+  readonly sourcePort?: number;
+  readonly partitionKey?: Readonly<Record<string, unknown>>;
 }
 
 interface PendingRequest {
@@ -42,23 +49,39 @@ interface PendingRequest {
   readonly reject: (reason: unknown) => void;
 }
 
+interface PendingEvent {
+  readonly resolve: (value: Record<string, unknown>) => void;
+  readonly reject: (reason: unknown) => void;
+}
+
 class ChromeConnection {
   readonly socket: WebSocket;
   readonly pending = new Map<number, PendingRequest>();
-  readonly events = new Map<string, Array<(value: Record<string, unknown>) => void>>();
+  readonly events = new Map<string, PendingEvent[]>();
   nextId = 1;
+  closed = false;
 
   constructor(url: string) {
     this.socket = new WebSocket(url);
+    const rejectPending = () => {
+      this.closed = true;
+      const error = new Error("Chrome window closed before login completed");
+      for (const request of this.pending.values()) request.reject(error);
+      this.pending.clear();
+      for (const events of this.events.values()) for (const event of events) event.reject(error);
+      this.events.clear();
+    };
+    this.socket.addEventListener("close", rejectPending, { once: true });
+    this.socket.addEventListener("error", rejectPending, { once: true });
     this.socket.addEventListener("message", (event) => {
       const message = JSON.parse(event.data.toString()) as { id?: number; method?: string; params?: Record<string, unknown>; result?: unknown; error?: unknown };
       if (message.id === undefined) {
         if (message.method !== undefined) {
           const events = this.events.get(message.method);
           if (events !== undefined) {
-            const resolve = events.shift()!;
+            const pending = events.shift()!;
             if (events.length === 0) this.events.delete(message.method);
-            resolve(message.params!);
+            pending.resolve(message.params!);
           }
         }
         return;
@@ -81,15 +104,23 @@ class ChromeConnection {
     const id = this.nextId;
     this.nextId += 1;
     return new Promise((resolve, reject) => {
+      if (this.closed) {
+        reject(new Error("Chrome window closed before login completed"));
+        return;
+      }
       this.pending.set(id, { resolve, reject });
       this.socket.send(JSON.stringify({ id, method, params }));
     });
   }
 
   event(method: string): Promise<Record<string, unknown>> {
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
+      if (this.closed) {
+        reject(new Error("Chrome window closed before login completed"));
+        return;
+      }
       const events = this.events.get(method) ?? [];
-      events.push(resolve);
+      events.push({ resolve, reject });
       this.events.set(method, events);
     });
   }
@@ -108,7 +139,7 @@ function devtoolsUrl(stderr: NodeJS.ReadableStream): Promise<string> {
       const match = /DevTools listening on (ws:\/\/[^\s]+)/.exec(contents);
       if (match !== null) resolve(match[1]!);
     });
-    stderr.on("end", () => reject(new Error(contents)));
+    stderr.on("end", () => reject(new Error(contents === "" ? "Chrome exited before DevTools started. A Wire Chrome window is already open from a previous login; close it and retry." : contents)));
   });
 }
 
@@ -130,54 +161,6 @@ async function pageDevtoolsUrl(browserUrl: string, domains: readonly string[]):
   return targets.find((target) => target.type === "page" && domains.some((domain) => new URL(target.url).hostname === domain || new URL(target.url).hostname.endsWith(`.${domain}`)))!.webSocketDebuggerUrl;
 }
 
-async function chatgptBrowserMetadata(pageConnection: ChromeConnection): Promise<Readonly<Record<string, string>> | null> {
-  const evaluation = await pageConnection.request("Runtime.evaluate", {
-    expression: `new Promise((resolve) => {
-      (async () => {
-        if (location.hostname !== "chatgpt.com") {
-          resolve({ ok: false });
-          return;
-        }
-        const response = await fetch("/api/auth/session", { cache: "no-store" });
-        const text = await response.text();
-        if (!text.startsWith("{")) {
-          resolve({ ok: false });
-          return;
-        }
-        const session = JSON.parse(text);
-        if (!("account" in session) || !("id" in session.account) || !("accessToken" in session) || "error" in session) {
-          resolve({ ok: false });
-          return;
-        }
-        const backend = await fetch("/backend-api/conversations?offset=0&limit=1&order=updated&is_archived=false&is_starred=false", {
-          cache: "no-store",
-          headers: {
-            authorization: \`Bearer \${session.accessToken}\`,
-            "chatgpt-account-id": session.account.id
-          }
-        });
-        resolve({ ok: backend.ok, account_id: session.account.id });
-      })().catch(() => resolve({ ok: false }));
-    })`,
-    awaitPromise: true,
-    returnByValue: true,
-  }) as { result: { value?: { ok?: boolean; account_id?: string } } };
-  const value = evaluation.result.value!;
-  if (value.ok !== true) return null;
-  return Object.freeze({ account_id: value.account_id! });
-}
-
-async function chatgptChallengeUrl(pageConnection: ChromeConnection): Promise<string | null> {
-  const evaluation = await pageConnection.request("Runtime.evaluate", {
-    expression: `(() => ({ href: location.href, title: document.title, text: document.body.innerText }))()`,
-    returnByValue: true,
-  }) as { result: { value?: { href: string; title: string; text: string } } };
-  const value = evaluation.result.value!;
-  const pageText = `${value.href}\n${value.title}\n${value.text}`;
-  if (/cdn-cgi\/challenge-platform|cf_chl|Just a moment|Verify you are human|Cloudflare/i.test(pageText)) return value.href;
-  return null;
-}
-
 function chromeCookies(values: readonly ChromeCookie[], domains: readonly string[]): readonly Cookie[] {
   return Object.freeze(values.filter((cookie) => domains.some((domain) => cookie.domain === domain || cookie.domain.endsWith(`.${domain}`))).map((cookie) => Object.freeze({
     domain: cookie.domain,
@@ -197,6 +180,7 @@ export interface ChromeCookieExtraction {
   readonly domains: readonly string[];
   readonly ready: (cookies: readonly Cookie[]) => boolean;
   readonly metadataExpression?: string;
+  readonly freshSession?: true;
   readonly verify: (cookies: readonly Cookie[], metadata: Readonly<Record<string, string>>) => Promise<boolean>;
 }
 
@@ -217,10 +201,66 @@ function sleep(milliseconds: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 
+async function headlessChromeConnection(environment: NodeEnvironment): Promise<Readonly<{ chrome: ReturnType<typeof spawn>; connection: ChromeConnection }>> {
+  const chrome = spawn(chromeExecutable, [`--user-data-dir=${chromeUserDataDir(environment)}`, "--remote-debugging-port=0", "--headless=new", "--no-first-run", "--no-default-browser-check", "about:blank"], { detached: true, stdio: ["ignore", "ignore", "pipe"] });
+  const connection = new ChromeConnection(await devtoolsUrl(chrome.stderr!));
+  await connection.opened();
+  return Object.freeze({ chrome, connection });
+}
+
+async function expireServiceCookies(connection: ChromeConnection, domains: readonly string[]): Promise<void> {
+  const serviceDomain = (domain: string) => { const bare = domain.startsWith(".") ? domain.slice(1) : domain; return domains.some((value) => bare === value || bare.endsWith(`.${value}`)); };
+  const stored = await connection.request("Storage.getCookies") as { cookies: readonly ChromeCookie[] };
+  const expiredCopies = stored.cookies.filter((cookie) => serviceDomain(cookie.domain)).map((cookie) => ({
+    name: cookie.name,
+    value: "",
+    domain: cookie.domain,
+    path: cookie.path,
+    secure: cookie.secure,
+    httpOnly: cookie.httpOnly,
+    expires: 1,
+    ...(cookie.sameSite === undefined ? {} : { sameSite: cookie.sameSite }),
+    ...(cookie.sourceScheme === undefined ? {} : { sourceScheme: cookie.sourceScheme }),
+    ...(cookie.sourcePort === undefined ? {} : { sourcePort: cookie.sourcePort }),
+    ...(cookie.partitionKey === undefined ? {} : { partitionKey: cookie.partitionKey }),
+  }));
+  if (expiredCopies.length > 0) await connection.request("Storage.setCookies", { cookies: expiredCopies });
+}
+
+async function extractDetachedChromeCookies(environment: NodeEnvironment, extraction: ChromeCookieExtraction): Promise<ChromeCookieResult> {
+  await mkdir(chromeUserDataDir(environment), { recursive: true });
+  const prep = await headlessChromeConnection(environment);
+  await expireServiceCookies(prep.connection, extraction.domains);
+  await closeChrome(prep.chrome, prep.connection);
+  const chrome = spawn(chromeExecutable, [`--user-data-dir=${chromeUserDataDir(environment)}`, "--no-first-run", "--no-default-browser-check", extraction.startUrl], { detached: true, stdio: ["ignore", "ignore", "ignore"] });
+  stderr.write(`\nLog in to ${extraction.service} in the opened Chrome window, then quit Chrome (Cmd+Q). Wire picks up the session after Chrome exits.\n`);
+  let interrupted = false;
+  const interrupt = () => {
+    interrupted = true;
+    process.kill(-chrome.pid!, "SIGTERM");
+  };
+  process.on("SIGINT", interrupt);
+  await new Promise((resolve) => chrome.once("exit", resolve));
+  process.off("SIGINT", interrupt);
+  await sleep(500);
+  const harvest = await headlessChromeConnection(environment);
+  const stored = await harvest.connection.request("Storage.getCookies") as { cookies: readonly ChromeCookie[] };
+  await closeChrome(harvest.chrome, harvest.connection);
+  const cookies = chromeCookies(stored.cookies, extraction.domains);
+  if (interrupted) {
+    const save = await confirmSaveLogin();
+    if (!save) throw new Error("Login not saved");
+    return Object.freeze({ cookies, metadata: Object.freeze({}), manual: true });
+  }
+  if (!extraction.ready(cookies)) throw new Error(`${extraction.service} login did not complete: the Chrome window was quit before login finished.`);
+  return Object.freeze({ cookies, metadata: Object.freeze({}) });
+}
+
 export async function extractChromeCookies(environment: NodeEnvironment, extraction: ChromeCookieExtraction): Promise<ChromeCookieResult> {
+  if (extraction.freshSession === true) return extractDetachedChromeCookies(environment, extraction);
   const profile = chromeUserDataDir(environment);
   await mkdir(profile, { recursive: true });
-  const chrome = spawn("/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", [...await chromeLaunchArguments(environment, extraction.startUrl)], { detached: true, stdio: ["ignore", "ignore", "pipe"] });
+  const chrome = spawn(chromeExecutable, [...await chromeLaunchArguments(environment, extraction.startUrl)], { detached: true, stdio: ["ignore", "ignore", "pipe"] });
   let interrupted = false;
   let interrupting = false;
   let interruptResult: ChromeCookieResult | null | undefined;
@@ -243,7 +283,7 @@ export async function extractChromeCookies(environment: NodeEnvironment, extract
   const browserUrl = await devtoolsUrl(chrome.stderr!);
   const connection = new ChromeConnection(browserUrl);
   await connection.opened();
-  const pageConnection = extraction.metadataExpression === undefined && extraction.service !== "chatgpt" ? undefined : new ChromeConnection(await pageDevtoolsUrl(browserUrl, extraction.domains));
+  const pageConnection = extraction.metadataExpression === undefined ? undefined : new ChromeConnection(await pageDevtoolsUrl(browserUrl, extraction.domains));
   if (pageConnection !== undefined) await pageConnection.opened();
   if (pageConnection !== undefined) await Promise.race([sleep(2000), interruptPromise]);
   const currentResult = async (): Promise<ChromeCookieResult> => {
@@ -266,33 +306,12 @@ export async function extractChromeCookies(environment: NodeEnvironment, extract
     return interruptResult;
   };
   for (;;) {
-    if (extraction.service === "chatgpt") {
-      const challengeUrl = await chatgptChallengeUrl(pageConnection!);
-      const manualResult = await interruptedResult();
-      if (manualResult !== undefined) return manualResult;
-      if (challengeUrl !== null) {
-        await closeChrome(chrome, connection, pageConnection);
-        process.off("SIGINT", interrupt);
-        throw new Error(`ChatGPT login is stuck on an HTML challenge: ${challengeUrl}`);
-      }
-    }
     const result = await currentResult();
     const manualResult = await interruptedResult();
     if (manualResult !== undefined) return manualResult;
     if (extraction.ready(result.cookies)) {
-      let metadata: Readonly<Record<string, string>> = result.metadata;
-      if (extraction.service === "chatgpt") {
-        const chatgptMetadata = await Promise.race([chatgptBrowserMetadata(pageConnection!), interruptPromise.then(() => undefined)]);
-        const interruptedChatgptResult = await interruptedResult();
-        if (interruptedChatgptResult !== undefined) return interruptedChatgptResult;
-        if (chatgptMetadata === undefined) continue;
-        if (chatgptMetadata === null) {
-          await closeChrome(chrome, connection, pageConnection);
-          process.off("SIGINT", interrupt);
-          throw new Error("ChatGPT login is blocked by an HTML challenge. Complete `wire chatgpt login` in the opened Chrome window, then retry.");
-        }
-        metadata = chatgptMetadata;
-      } else if (extraction.metadataExpression !== undefined) {
+      const metadata: Readonly<Record<string, string>> = result.metadata;
+      if (extraction.metadataExpression !== undefined) {
         if (Object.keys(metadata).length === 0) {
           await Promise.race([sleep(1000), interruptPromise]);
           const interruptedMetadataResult = await interruptedResult();
@@ -300,7 +319,7 @@ export async function extractChromeCookies(environment: NodeEnvironment, extract
           continue;
         }
       }
-      if (extraction.service !== "chatgpt" && !(await Promise.race([extraction.verify(result.cookies, metadata), interruptPromise.then(() => false)]))) {
+      if (!(await Promise.race([extraction.verify(result.cookies, metadata), interruptPromise.then(() => false)]))) {
         const interruptedVerifyResult = await interruptedResult();
         if (interruptedVerifyResult !== undefined) return interruptedVerifyResult;
         await Promise.race([sleep(1000), interruptPromise]);

package/node_modules/wire-core/src/runtime/cookies.ts

@@ -191,8 +191,10 @@ export function createCookiesCapability(filesystem: FilesystemCapability, home:
     },
     save: async (service: string, cookies: readonly Cookie[], metadata: Readonly<Record<string, string>>) => {
       const candidatePaths = paths(service);
-      const path = await existingCookiesFile(filesystem, candidatePaths) ?? candidatePaths[0]!;
-      await filesystem.writeText(path, serializeNetscapeCookies(cookies, metadata));
+      const contents = serializeNetscapeCookies(cookies, metadata);
+      const existingPaths = [];
+      for (const path of candidatePaths) if (await filesystem.exists(path)) existingPaths.push(path);
+      for (const path of existingPaths.length === 0 ? [candidatePaths[0]!] : existingPaths) await filesystem.writeText(path, contents);
     },
     delete: async (service: string) => {
       for (const path of paths(service)) if (await filesystem.exists(path)) await filesystem.delete(path);

package/node_modules/wire-core/src/runtime/node.ts

@@ -100,6 +100,10 @@ export function composeNodeRuntime(dependencies: NodeRuntimeDependencies): Runti
       load: () => createGoogleTokensCapability(dependencies.filesystem, dependencies.http, dependencies.clock, configuration.get("GOOGLE_CREDENTIALS_FILE"), configuration.get("GOOGLE_TOKEN_FILE")).load(),
       refresh: () => createGoogleTokensCapability(dependencies.filesystem, dependencies.http, dependencies.clock, configuration.get("GOOGLE_CREDENTIALS_FILE"), configuration.get("GOOGLE_TOKEN_FILE")).refresh(),
     }),
+    googleFormsTokens: Object.freeze({
+      load: () => createGoogleTokensCapability(dependencies.filesystem, dependencies.http, dependencies.clock, configuration.get("GOOGLE_CREDENTIALS_FILE"), configuration.get("GOOGLE_FORMS_TOKEN_FILE")).load(),
+      refresh: () => createGoogleTokensCapability(dependencies.filesystem, dependencies.http, dependencies.clock, configuration.get("GOOGLE_CREDENTIALS_FILE"), configuration.get("GOOGLE_FORMS_TOKEN_FILE")).refresh(),
+    }),
   });
 }
 

package/node_modules/wire-core/src/storage/registry.ts

@@ -19,7 +19,7 @@ type ResourceIdRow = Readonly<{ resource_id: string }>;
 type IdRow = Readonly<{ id: string }>;
 type SqliteModule = Readonly<{ DatabaseSync: new (path: string) => DatabaseSync }>;
 
-const require = createRequire(import.meta.url);
+const require = createRequire("/wire-core/storage/registry.js");
 
 function compareStrings(left: string, right: string): number {
   const leftCodePoints = Array.from(left, (character) => character.codePointAt(0)!);
@@ -77,7 +77,7 @@ export class SqliteRegistry implements Registry {
 
   constructor(path: string) {
     this.path = realpathSyncParent(path);
-    using database = this.connect();
+    const database = this.connect();
     database.exec(`
       PRAGMA journal_mode=DELETE;
       PRAGMA foreign_keys=ON;
@@ -121,11 +121,27 @@ export class SqliteRegistry implements Registry {
       );
       CREATE INDEX IF NOT EXISTS resource_relationships_target ON resource_relationships(target_id);
     `);
+    database.close();
   }
 
   async put(resource: Resource): Promise<Resource> {
     const normalized = storageResource(resource);
-    using database = this.connect();
+    assertUniqueFileResource(normalized);
+    const database = this.connect();
+    for (const identifier of normalized.identifiers) {
+      const row = database.prepare("SELECT resource_id FROM resource_identifiers WHERE service = ? AND identifier = ? AND resource_id != ?").get(identifier.service, identifier.identifier, normalized.id) as ResourceIdRow | undefined;
+      if (row !== undefined) {
+        database.close();
+        throw new Error(`${identifier.service}/${identifier.identifier}`);
+      }
+    }
+    for (const url of normalized.urls) {
+      const row = database.prepare("SELECT resource_id FROM resource_urls WHERE url = ? AND resource_id != ?").get(url, normalized.id) as ResourceIdRow | undefined;
+      if (row !== undefined) {
+        database.close();
+        throw new Error(url);
+      }
+    }
     database.exec("BEGIN");
     database.prepare("INSERT INTO resources (id, type) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET type=excluded.type").run(normalized.id, normalized.type);
     database.prepare("DELETE FROM resource_identifiers WHERE resource_id = ?").run(normalized.id);
@@ -144,58 +160,76 @@ export class SqliteRegistry implements Registry {
     const insertRelationship = database.prepare("INSERT INTO resource_relationships (source_id, target_id, type, data_json) VALUES (?, ?, ?, ?)");
     for (const relationship of normalized.relationships) insertRelationship.run(normalized.id, relationship.target_id, relationship.type, stableJsonCompact(relationship.data));
     database.exec("COMMIT");
+    database.close();
     return normalized;
   }
 
   async get(resourceId: string): Promise<Resource> {
-    using database = this.connect();
+    const database = this.connect();
+    const row = database.prepare("SELECT id FROM resources WHERE id = ?").get(resourceId) as IdRow | undefined;
+    if (row === undefined) {
+      database.close();
+      throw missingResource(resourceId);
+    }
     database.exec("BEGIN");
     const resource = this.getResource(database, resourceId);
     database.exec("COMMIT");
+    database.close();
     return resource;
   }
 
   async findByIdentifier(service: string, identifier: string): Promise<Resource> {
-    using database = this.connect();
+    const database = this.connect();
     database.exec("BEGIN");
     const row = database.prepare("SELECT resource_id FROM resource_identifiers WHERE service = ? AND identifier = ?").get(service, identifier) as ResourceIdRow | undefined;
-    if (row === undefined) throw missingIdentifier(service, identifier);
+    if (row === undefined) {
+      database.close();
+      throw missingIdentifier(service, identifier);
+    }
     const resource = this.getResource(database, row.resource_id);
     database.exec("COMMIT");
+    database.close();
     return resource;
   }
 
   async findByUrl(url: string): Promise<Resource> {
-    using database = this.connect();
+    const database = this.connect();
     database.exec("BEGIN");
     const row = database.prepare("SELECT resource_id FROM resource_urls WHERE url = ?").get(url) as ResourceIdRow | undefined;
-    if (row === undefined) throw missingUrl(url);
+    if (row === undefined) {
+      database.close();
+      throw missingUrl(url);
+    }
     const resource = this.getResource(database, row.resource_id);
     database.exec("COMMIT");
+    database.close();
     return resource;
   }
 
   async findByPath(path: string): Promise<readonly Resource[]> {
-    using database = this.connect();
+    const database = this.connect();
     database.exec("BEGIN");
     const rows = database.prepare("SELECT DISTINCT resource_id FROM filesystem_links WHERE path = ? ORDER BY resource_id").all(path.replaceAll(sep, "/")) as ResourceIdRow[];
     const resources = rows.map((row) => this.getResource(database, row.resource_id));
     database.exec("COMMIT");
+    database.close();
     return resources;
   }
 
   async listResources(): Promise<readonly Resource[]> {
-    using database = this.connect();
+    const database = this.connect();
     database.exec("BEGIN");
     const rows = database.prepare("SELECT id FROM resources ORDER BY id").all() as IdRow[];
     const resources = rows.map((row) => this.getResource(database, row.id));
     database.exec("COMMIT");
+    database.close();
     return resources;
   }
 
   async delete(resourceId: string): Promise<void> {
-    using database = this.connect();
+    const database = this.connect();
     database.prepare("DELETE FROM resources WHERE id = ?").run(resourceId);
+    database.close();
   }
 
   private getResource(database: DatabaseSync, resourceId: string): Resource {
@@ -245,10 +279,9 @@ export class FileRegistry implements Registry {
       if (existingUrls.has(url)) throw new Error(url);
     }
     const tempPath = join(this.path, randomUUID());
-    {
-      await using handle = await open(tempPath, "wx", 0o600);
-      await handle.writeFile(`${stableJsonPretty(normalized)}\n`, "utf8");
-    }
+    const handle = await open(tempPath, "wx", 0o600);
+    await handle.writeFile(`${stableJsonPretty(normalized)}\n`, "utf8");
+    await handle.close();
     await rename(tempPath, this.resourcePath(normalized.id));
     return normalized;
   }