@kamilio/wire 0.1.3 → 0.1.5

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

@@ -28,6 +28,8 @@ export async function chromeLaunchArguments(environment: NodeEnvironment, startU
   ]);
 }
 
+const chromeExecutable = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
+
 interface ChromeCookie {
   readonly domain: string;
   readonly expires: number;
@@ -36,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 {
@@ -133,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)));
   });
 }
 
@@ -155,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,
@@ -222,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>;
 }
 
@@ -242,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;
@@ -268,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> => {
@@ -291,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();
@@ -325,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kamilio/wire",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Attach Notion, Google Docs, Slack, Gmail, Asana, ChatGPT, and Zoom resources as local Markdown you can sync.",
   "keywords": [
     "markdown",
@@ -87,8 +87,8 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev-link": "npm link",
-    "prepack": "rm -rf node_modules && mkdir -p node_modules && for package in provider-asana provider-chatgpt provider-gmail provider-google-docs provider-notion provider-slack provider-zoom wire-core; do cp -R ../$package node_modules/$package; done && for package in ajv commander fast-deep-equal fast-string-truncated-width fast-string-width fast-wrap-ansi fast-uri ignore jose jsonc-parser json-schema-traverse pct-encode require-from-string sisteransi smol-toml tiny-stdio-mcp-server toolcraft toolcraft-schema uri-template uri-template-lite yaml; do cp -R ../../node_modules/$package node_modules/$package; done",
-    "postpack": "rm -rf node_modules",
+    "prepack": "cp ../../README.md README.md && rm -rf node_modules && mkdir -p node_modules && for package in provider-asana provider-chatgpt provider-gmail provider-google-docs provider-notion provider-slack provider-zoom wire-core; do cp -R ../$package node_modules/$package; done && for package in ajv commander fast-deep-equal fast-string-truncated-width fast-string-width fast-wrap-ansi fast-uri ignore jose jsonc-parser json-schema-traverse pct-encode require-from-string sisteransi smol-toml tiny-stdio-mcp-server toolcraft toolcraft-schema uri-template uri-template-lite yaml; do cp -R ../../node_modules/$package node_modules/$package; done",
+    "postpack": "rm -rf node_modules README.md",
     "test": "node --test --test-concurrency=1 test/**/*.test.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "check": "npm run typecheck && npm run build && npm test"

package/src/auth.ts

@@ -267,19 +267,13 @@ export function composeAuth(runtime: RuntimeCapabilities, environment: NodeEnvir
     await saveCookies(service, state.cookies, state.metadata);
     return state.result;
   };
-  const extract = async (service: AuthService, startUrl: string, domains: readonly string[], ready: (values: readonly Cookie[]) => boolean, metadataExpression?: string) => {
-    const extraction = { service, startUrl, domains, ready, verify: async (values: readonly Cookie[], metadata: Readonly<Record<string, string>>) => (await verifyCookieState(service, values, metadata)).result !== null, ...(metadataExpression === undefined ? {} : { metadataExpression }) };
+  const extract = async (service: AuthService, startUrl: string, domains: readonly string[], ready: (values: readonly Cookie[]) => boolean, metadataExpression?: string, freshSession?: true) => {
+    const extraction = { service, startUrl, domains, ready, verify: async (values: readonly Cookie[], metadata: Readonly<Record<string, string>>) => (await verifyCookieState(service, values, metadata)).result !== null, ...(metadataExpression === undefined ? {} : { metadataExpression }), ...(freshSession === undefined ? {} : { freshSession }) };
     const result = await extractCookies(environment, extraction);
     if (result.manual === true) {
       await saveCookies(service, result.cookies, result.metadata);
       return Object.freeze({ service, identity: Object.freeze({ saved: true }) });
     }
-    if (service === "chatgpt") {
-      await saveCookies(service, result.cookies, result.metadata);
-      const accountId = result.metadata["account_id"];
-      if (accountId === undefined) throw new Error("chatgpt cookie authentication failed. Run `wire chatgpt login` once; other commands reuse saved cookies.");
-      return Object.freeze({ service, identity: Object.freeze({ account_id: accountId }) });
-    }
     const verified = await verifyCookieState(service, result.cookies, result.metadata);
     if (verified.result === null) throw new Error(`${service} cookie authentication failed. Run \`wire ${service} login\` once; other commands reuse saved cookies.`);
     await saveCookies(service, verified.cookies, verified.metadata);
@@ -293,7 +287,7 @@ export function composeAuth(runtime: RuntimeCapabilities, environment: NodeEnvir
       return Object.freeze({ service, deleted: true });
     },
     extractAsana: () => extract("asana", "https://app.asana.com/", ["asana.com"], (values) => values.some((cookie) => cookie.domain === ".asana.com" || cookie.domain.endsWith(".asana.com"))),
-    extractChatgpt: () => extract("chatgpt", "https://chatgpt.com/", ["chatgpt.com", "openai.com"], requiredReady(["oai-did", "__Secure-next-auth.session-token"])),
+    extractChatgpt: () => extract("chatgpt", "https://chatgpt.com/", ["chatgpt.com", "openai.com"], (values) => values.some((cookie) => cookie.name === "oai-did") && values.some((cookie) => cookie.name === "__Secure-next-auth.session-token" || cookie.name === "__Secure-next-auth.session-token.0"), undefined, true),
     extractGmail: () => extract("gmail", "https://mail.google.com/mail/u/0/", ["google.com"], googleReady),
     extractGoogleDocs: () => extract("google-docs", "https://docs.google.com/", ["google.com"], googleReady),
     extractNotion: () => extract("notion", "https://www.notion.so/login", ["notion.so", "notion.com"], requiredReady(["token_v2", "notion_user_id", "notion_users"])),

package/src/executable.ts

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 
 import { createRoot } from "./adapters/root.js";
 import { composeAuth } from "./auth.js";
@@ -52,15 +52,21 @@ function loadConfiguredEnvironment(environment: NodeEnvironment, currentDirector
   return config.env === undefined ? environment : Object.freeze({ ...environment, ...config.env });
 }
 
+function operationPath(value: string, path: string): string {
+  if (value.startsWith("http://") || value.startsWith("https://")) return path;
+  return isAbsolute(value) ? value : resolve(path, value);
+}
+
 export function createExecutableRoot(environment: NodeEnvironment, currentDirectory: string, options = { allowPaste: true }) {
   const repositoryRoot = environment["WIRE_REPOSITORY_ROOT"] ?? discoverRepositoryRoot(currentDirectory);
   const baseEnvironment = repositoryRoot === undefined ? environment : Object.freeze({ ...environment, WIRE_REPOSITORY_ROOT: repositoryRoot });
-  const resolvedEnvironment = loadConfiguredEnvironment(baseEnvironment, currentDirectory);
+  let activeConfigurationPath = currentDirectory;
+  const configuredEnvironment = () => loadConfiguredEnvironment(baseEnvironment, activeConfigurationPath);
   const http = createNodeHttp();
   const filesystem = createNodeFilesystem();
   const processCapability = createNodeProcess();
   const clock = createNodeClock();
-  const configuration = createNodeConfiguration(resolvedEnvironment);
+  const configuration = Object.freeze({ get: (name: string) => createNodeConfiguration(configuredEnvironment()).get(name) });
   const home = configuration.get("HOME");
   const runtimeBase = {
     http,
@@ -69,14 +75,14 @@ export function createExecutableRoot(environment: NodeEnvironment, currentDirect
     clock,
     openFiles: createNodeOpenFiles(processCapability),
     configuration,
-    secrets: createNodeSecrets(filesystem, resolvedEnvironment),
+    secrets: createNodeSecrets(filesystem, configuredEnvironment()),
     gmailTokens: Object.freeze({ load: () => createGoogleTokensCapability(filesystem, http, clock, configuration.get("GOOGLE_CREDENTIALS_FILE"), configuration.get("GOOGLE_TOKEN_FILE")).load(), refresh: () => createGoogleTokensCapability(filesystem, http, clock, configuration.get("GOOGLE_CREDENTIALS_FILE"), configuration.get("GOOGLE_TOKEN_FILE")).refresh() }),
     googleFormsTokens: Object.freeze({ load: () => createGoogleTokensCapability(filesystem, http, clock, configuration.get("GOOGLE_CREDENTIALS_FILE"), configuration.get("GOOGLE_FORMS_TOKEN_FILE")).load(), refresh: () => createGoogleTokensCapability(filesystem, http, clock, configuration.get("GOOGLE_CREDENTIALS_FILE"), configuration.get("GOOGLE_FORMS_TOKEN_FILE")).refresh() }),
   };
   let auth: ReturnType<typeof composeAuth>;
-  const runtime = Object.freeze({ ...runtimeBase, cookies: createCookiesCapability(filesystem, () => home, () => resolvedEnvironment["WIRE_REPOSITORY_ROOT"]) });
-  auth = composeAuth(runtime, resolvedEnvironment, extractChromeCookies);
-  const wire = withWireHooks(composeWire({
+  const runtime = Object.freeze({ ...runtimeBase, cookies: createCookiesCapability(filesystem, () => home, () => configuredEnvironment()["WIRE_REPOSITORY_ROOT"]) });
+  auth = composeAuth(runtime, configuredEnvironment(), extractChromeCookies);
+  const baseWire = composeWire({
     home,
     fetchInput: runtime,
     catalog: serviceCatalog,
@@ -98,6 +104,25 @@ export function createExecutableRoot(environment: NodeEnvironment, currentDirect
     watch: createNodeWatch(),
     now: runtime.clock.now,
     open: runtime.openFiles.open,
-  }), { currentDirectory, home, environment: resolvedEnvironment });
+  });
+  const configuredWire = Object.freeze({
+    ...baseWire,
+    attach: async (url: string, path: string) => { activeConfigurationPath = path; return baseWire.attach(url, path); },
+    create: async (url: string, path: string) => { activeConfigurationPath = path; return baseWire.create(url, path); },
+    view: async (url: string) => { activeConfigurationPath = currentDirectory; return baseWire.view(url); },
+    downloadSource: async (url: string, path: string) => { activeConfigurationPath = path; return baseWire.downloadSource(url, path); },
+    sync: async (value: string, path: string) => { activeConfigurationPath = operationPath(value, path); return baseWire.sync(value, path); },
+    download: async (value: string, path: string) => { activeConfigurationPath = operationPath(value, path); return baseWire.download(value, path); },
+    detach: async (value: string, path: string) => { activeConfigurationPath = operationPath(value, path); return baseWire.detach(value, path); },
+    unlink: async (value: string, path: string) => { activeConfigurationPath = operationPath(value, path); return baseWire.unlink(value, path); },
+    watch: async (value: string, path: string) => { activeConfigurationPath = operationPath(value, path); return baseWire.watch(value, path); },
+    openResource: async (value: string, path: string) => { activeConfigurationPath = operationPath(value, path); return baseWire.openResource(value, path); },
+    syncAll: async (path: string) => { activeConfigurationPath = path; return baseWire.syncAll(path); },
+    listResources: async (path: string) => { activeConfigurationPath = path; return baseWire.listResources(path); },
+    showResource: async (value: string, path: string) => { activeConfigurationPath = operationPath(value, path); return baseWire.showResource(value, path); },
+    init: baseWire.init,
+    switchBackend: baseWire.switchBackend,
+  });
+  const wire = withWireHooks(configuredWire, { currentDirectory, home, environment: configuredEnvironment() });
   return createRoot(wire, currentDirectory, auth, readStandardInput, options);
 }

package/src/hooks.ts

@@ -5,7 +5,7 @@ import { dirname, isAbsolute, join, resolve } from "node:path";
 import { promisify } from "node:util";
 
 import type { Resource, Wire, WireResult } from "wire-core";
-import { configuredWireRoot, openWireRegistry, wireRelativePath } from "wire-core";
+import { configuredWireRoot, loadWireConfig, openWireRegistry, wireRelativePath } from "wire-core";
 import type { WireWatchSyncHook } from "wire-core/internal/operations";
 import { wireWatchHooks } from "wire-core/internal/operations";
 
@@ -118,10 +118,18 @@ async function updateMovedResult(options: WireHookOptions, wireRoot: string, res
       { ...primary, path: relativePath },
     ],
   };
-  if (result.summary.action !== "detached") await (await openWireRegistry(wireRoot, options.home)).put(resource);
+  if (result.summary.action !== "detached") {
+    const registry = await openWireRegistry(wireRoot, options.home);
+    if ((await registry.listResources()).some((item) => item.id === result.resource.id)) await registry.put(resource);
+  }
   return { ...result, resource, path: outputPath, summary: { ...result.summary, local: outputPath } };
 }
 
+async function hookEnvironment(options: WireHookOptions, wireRoot: string): Promise<Record<string, string>> {
+  const config = await loadWireConfig(wireRoot);
+  return stringEnvironment({ ...options.environment, ...config.env });
+}
+
 async function runHookCommands(wireRoot: string, event: WireHookEvent, environment: Readonly<Record<string, string>>): Promise<Record<string, string>> {
   let current = { ...environment };
   for (const path of await hookCommandPaths(wireRoot, event)) {
@@ -132,10 +140,11 @@ async function runHookCommands(wireRoot: string, event: WireHookEvent, environme
 }
 
 async function runResourceHooks(options: WireHookOptions, command: string, result: WireResult): Promise<HookState> {
-  const wireRoot = (await configuredWireRoot(result.path, options.home))!;
+  const wireRoot = await configuredWireRoot(result.path, options.home);
+  if (wireRoot === null) return { result, environment: {} };
   let currentResult = result;
   let environment = {
-    ...stringEnvironment(options.environment),
+    ...await hookEnvironment(options, wireRoot),
     ...resourceEnvironment(command, options.currentDirectory, wireRoot, currentResult),
   };
   for (const path of await hookCommandPaths(wireRoot, "post-resource")) {
@@ -152,9 +161,10 @@ async function runResourceHooks(options: WireHookOptions, command: string, resul
 }
 
 async function runSummaryHooks(options: WireHookOptions, event: WireHookEvent, command: string, rootPath: string, results: readonly WireResult[], environment: Readonly<Record<string, string>>): Promise<Record<string, string>> {
-  const wireRoot = (await configuredWireRoot(rootPath, options.home))!;
+  const wireRoot = await configuredWireRoot(rootPath, options.home);
+  if (wireRoot === null) return {};
   return runHookCommands(wireRoot, event, {
-    ...stringEnvironment(options.environment),
+    ...await hookEnvironment(options, wireRoot),
     ...environment,
     ...summaryEnvironment(event, command, options.currentDirectory, wireRoot, results),
   });