wtagent 0.3.0 → 1.0.0

package/src/image/providers/chatgpt-image-driver.js

@@ -0,0 +1,211 @@
+import fs from "node:fs/promises";
+import { BrowserImageDriver } from "../browser-image-driver.js";
+
+const DOWNLOAD_NAME_PATTERN = /download(?: image)?|下载(?:图片)?|下載(?:圖片)?/i;
+const MIN_IMAGE_EDGE = 256;
+
+export function preferredImageUrl(image) {
+  const candidates = [image?.source, image?.href]
+    .filter((value) => typeof value === "string" && value.length > 0);
+  if (candidates.length === 0) {
+    return null;
+  }
+  const durableHttps = candidates.find((value) => {
+    try {
+      const parsed = new URL(value);
+      return parsed.protocol === "https:"
+        && !parsed.hostname.endsWith("chatgpt.com");
+    } catch {
+      return false;
+    }
+  });
+  return durableHttps
+    ?? candidates.find((value) => value.startsWith("https://"))
+    ?? candidates[0];
+}
+
+export class ChatGPTImageDriver extends BrowserImageDriver {
+  capabilities() {
+    return Object.freeze({
+      generate: true,
+      referenceImages: true,
+      aspectRatios: ["auto", "1:1", "3:2", "2:3", "16:9", "9:16"],
+      imageCount: 1,
+    });
+  }
+
+  async generate(request, execution = {}) {
+    await this.ensureChatPage();
+    const baseline = new Set(
+      (await this.chatImages().catch(() => [])).map((image) => preferredImageUrl(image)),
+    );
+    return await this.performTurn(request, execution, async () => {
+      const image = await this.waitForChatImage(request.timeoutMs, baseline);
+      if (image.type === "text") return image;
+      const downloaded = await this.downloadChatImage(
+        image,
+        Math.min(request.timeoutMs, 60_000),
+      );
+      return {
+        sourcePath: downloaded.temporaryPath,
+        cleanup: async () => fs.rm(downloaded.temporaryDir, { recursive: true, force: true }),
+        provenance: {
+          provider: this.provider,
+          providerFileId: this.remoteFileId(image.source)
+            ?? this.remoteFileId(downloaded.downloadUrl),
+          suggestedFilename: downloaded.suggestedFilename,
+        },
+      };
+    });
+  }
+
+  async imagesFromLocator(locator) {
+    if (await locator.count().catch(() => 0) === 0) return [];
+    return await locator.evaluate((root, minEdge) => {
+      const toAbsolute = (value) => {
+        if (!value) return "";
+        try {
+          return new URL(value, location.href).href;
+        } catch {
+          return value;
+        }
+      };
+      const fromSrcset = (srcset) => {
+        let best = "";
+        let bestWidth = 0;
+        for (const part of String(srcset ?? "").split(",")) {
+          const [url, descriptor] = part.trim().split(/\s+/, 2);
+          const width = descriptor?.endsWith("w")
+            ? Number.parseInt(descriptor, 10)
+            : 0;
+          if (url && width >= bestWidth) {
+            best = url;
+            bestWidth = width;
+          }
+        }
+        return best;
+      };
+      const images = [...root.querySelectorAll("img")].map((image) => {
+        const source = toAbsolute(
+          image.currentSrc
+          || fromSrcset(image.srcset)
+          || image.src
+          || image.getAttribute("data-src")
+          || "",
+        );
+        const href = toAbsolute(image.closest("a")?.href || "");
+        return {
+          source,
+          href,
+          width: image.naturalWidth || 0,
+          height: image.naturalHeight || 0,
+        };
+      }).filter((image) => (
+        (image.source || image.href)
+        && image.width >= minEdge
+        && image.height >= minEdge
+      ));
+
+      for (const link of root.querySelectorAll("a[href]")) {
+        const href = toAbsolute(link.href);
+        if (
+          !href
+          || images.some((image) => image.href === href || image.source === href)
+        ) {
+          continue;
+        }
+        if (
+          /oaiusercontent/i.test(href)
+          || /\.(png|jpe?g|webp)(?:\?|$)/i.test(href)
+        ) {
+          images.push({
+            source: href,
+            href,
+            width: minEdge,
+            height: minEdge,
+          });
+        }
+      }
+      return images;
+    }, MIN_IMAGE_EDGE).catch(() => []);
+  }
+
+  async currentAssistantImages() {
+    return await this.imagesFromLocator(this.adapter.assistantMessages().last());
+  }
+
+  async chatImages() {
+    return await this.imagesFromLocator(
+      this.adapter.page.locator("main").first(),
+    );
+  }
+
+  async waitForChatImage(timeoutMs, baseline = new Set()) {
+    const deadline = Date.now() + timeoutMs;
+    let candidate = null;
+    let stableSince = 0;
+    const textState = {};
+    while (Date.now() < deadline) {
+      const images = (await this.currentAssistantImages().catch(() => []))
+        .filter((image) => !baseline.has(preferredImageUrl(image)));
+      if (images.length > 1) {
+        throw new Error(
+          "ChatGPT produced multiple uncorrelated chat images; refusing to guess which artifact belongs to this request.",
+        );
+      }
+      if (images.length === 1) {
+        const next = preferredImageUrl(images[0]);
+        if (candidate !== next) {
+          candidate = next;
+          stableSince = Date.now();
+        } else if (Date.now() - stableSince >= 1_500) {
+          return { ...images[0], source: next };
+        }
+      } else {
+        candidate = null;
+        stableSince = 0;
+      }
+      if (images.length === 0) {
+        const text = await this.completedTextResponse(textState);
+        if (text) return text;
+      } else {
+        textState.candidate = null;
+      }
+      await this.adapter.page.waitForTimeout(1_000);
+    }
+    throw new Error(`ChatGPT did not publish a new image within ${Math.round(timeoutMs / 1000)} seconds.`);
+  }
+
+  async downloadChatImage(image, timeoutMs) {
+    await this.adapter.page.bringToFront().catch(() => null);
+    const url = preferredImageUrl(image);
+    if (url) {
+      try {
+        return await this.saveFromUrl(this.adapter.page, url, timeoutMs);
+      } catch {
+        // The in-chat URL can be a preview or expire; try a download control next.
+      }
+    }
+
+    const response = this.adapter.assistantMessages().last();
+    const buttonCandidates = [
+      response.getByRole("button", { name: DOWNLOAD_NAME_PATTERN }),
+      response.locator('button[aria-label*="download" i]'),
+    ];
+    for (const locator of buttonCandidates) {
+      if (await locator.first().isVisible().catch(() => false)) {
+        try {
+          return await this.saveDownload(
+            this.adapter.page,
+            locator.first(),
+            Math.min(timeoutMs, 30_000),
+          );
+        } catch {
+          break;
+        }
+      }
+    }
+    throw new Error("ChatGPT generated an image but no download control or image URL was found.");
+  }
+
+}

package/src/image/providers/gemini-image-driver.js

@@ -0,0 +1,100 @@
+import fs from "node:fs/promises";
+import { BrowserImageDriver } from "../browser-image-driver.js";
+
+export class GeminiImageDriver extends BrowserImageDriver {
+  capabilities() {
+    return Object.freeze({
+      generate: true,
+      referenceImages: true,
+      aspectRatios: ["auto", "1:1", "3:2", "2:3", "4:3", "3:4", "16:9", "9:16"],
+      imageCount: 1,
+    });
+  }
+
+  async generatedImages() {
+    const response = this.adapter.assistantMessages().last();
+    if (await response.count().catch(() => 0) === 0) return [];
+    return await response.locator("img").evaluateAll((images) => images.map((image) => ({
+      source: image.currentSrc || image.src || "",
+      alt: image.alt || "",
+      width: image.naturalWidth || 0,
+      height: image.naturalHeight || 0,
+    })).filter((image) => image.source && image.width >= 256 && image.height >= 256));
+  }
+
+  async waitForGeneratedImage(timeoutMs, baseline = new Set()) {
+    const deadline = Date.now() + timeoutMs;
+    let stableSource = null;
+    let stableSince = 0;
+    const textState = {};
+    while (Date.now() < deadline) {
+      const images = (await this.generatedImages())
+        .filter((image) => !baseline.has(image.source));
+      if (images.length === 1) {
+        if (stableSource !== images[0].source) {
+          stableSource = images[0].source;
+          stableSince = Date.now();
+        } else if (Date.now() - stableSince >= 2_000) {
+          return images[0];
+        }
+      } else if (images.length > 1) {
+        throw new Error(
+          "Gemini returned multiple images for a single-output request; refusing to choose one implicitly.",
+        );
+      }
+      if (images.length === 0) {
+        const text = await this.completedTextResponse(textState);
+        if (text) return text;
+      } else {
+        textState.candidate = null;
+      }
+      await this.adapter.page.waitForTimeout(1_000);
+    }
+    throw new Error(`Gemini did not finish an image within ${Math.round(timeoutMs / 1000)} seconds.`);
+  }
+
+  async downloadGeneratedImage(timeoutMs, generatedImage = null) {
+    const response = this.adapter.assistantMessages().last();
+    const scope = response;
+    const buttonCandidates = [
+      scope.getByRole("button", { name: /download(?: image)?|下载(?:图片)?|下載(?:圖片)?/i }),
+      scope.locator('button[aria-label*="download" i]'),
+      scope.locator('button[data-test-id*="download" i]'),
+    ];
+    for (const locator of buttonCandidates) {
+      if (await locator.first().isVisible().catch(() => false)) {
+        try {
+          return await this.saveDownload(this.adapter.page, locator.first(), timeoutMs);
+        } catch {
+          break;
+        }
+      }
+    }
+    if (generatedImage?.source) {
+      return await this.saveFromUrl(this.adapter.page, generatedImage.source, timeoutMs);
+    }
+    throw new Error("Gemini generated an image but no image download control was found.");
+  }
+
+  async generate(request, execution = {}) {
+    await this.ensureChatPage();
+    const before = new Set((await this.generatedImages()).map((item) => item.source));
+    return await this.performTurn(request, execution, async () => {
+      const generatedImage = await this.waitForGeneratedImage(request.timeoutMs, before);
+      if (generatedImage.type === "text") return generatedImage;
+      const downloaded = await this.downloadGeneratedImage(
+        Math.min(request.timeoutMs, 60_000),
+        generatedImage,
+      );
+      return {
+        sourcePath: downloaded.temporaryPath,
+        cleanup: async () => fs.rm(downloaded.temporaryDir, { recursive: true, force: true }),
+        provenance: {
+          provider: this.provider,
+          providerFileId: this.remoteFileId(downloaded.downloadUrl),
+          suggestedFilename: downloaded.suggestedFilename,
+        },
+      };
+    });
+  }
+}

package/src/image/providers/grok-image-driver.js

@@ -0,0 +1,193 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { BrowserImageDriver } from "../browser-image-driver.js";
+
+const GROK_ASSET_HOST = "assets.grok.com";
+const GROK_GENERATED_IMAGE_PATH = /^\/users\/[^/]+\/generated\/([0-9a-f-]{16,})\/image\.(?:jpe?g|png|webp)$/i;
+const IMAGE_CONTENT_TYPE = /^image\/(?:jpeg|jpg|png|webp)(?:;|$)/i;
+
+export function parseGrokGeneratedImageUrl(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "https:" || url.hostname !== GROK_ASSET_HOST) return null;
+    const match = url.pathname.match(GROK_GENERATED_IMAGE_PATH);
+    if (!match) return null;
+    return {
+      id: match[1],
+      key: `${url.origin}${url.pathname}`,
+      url: url.href,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function responseUrl(response) {
+  return typeof response?.url === "function" ? response.url() : response?.url;
+}
+
+function responseHeaders(response) {
+  return typeof response?.headers === "function" ? response.headers() : response?.headers;
+}
+
+export class GrokImageDriver extends BrowserImageDriver {
+  constructor(options) {
+    super(options);
+    this.responseStabilityMs = options.responseStabilityMs ?? 2_000;
+  }
+
+  capabilities() {
+    return Object.freeze({
+      generate: true,
+      referenceImages: false,
+      aspectRatios: ["auto", "1:1", "3:2", "2:3", "16:9", "9:16"],
+      imageCount: 1,
+    });
+  }
+
+  trackGeneratedImageResponses() {
+    const page = this.adapter.page;
+    const images = [];
+    const keys = new Set();
+    let armed = false;
+    let lastAddedAt = 0;
+    const listener = (response) => {
+      if (!armed) return;
+      const parsed = parseGrokGeneratedImageUrl(responseUrl(response));
+      if (!parsed || keys.has(parsed.key)) return;
+      const ok = typeof response?.ok === "function" ? response.ok() : response?.ok;
+      const contentType = String(responseHeaders(response)?.["content-type"] ?? "");
+      if (!ok || !IMAGE_CONTENT_TYPE.test(contentType)) return;
+      keys.add(parsed.key);
+      images.push(parsed);
+      lastAddedAt = Date.now();
+    };
+    page.on("response", listener);
+    return {
+      arm: () => { armed = true; },
+      images: () => images.slice(),
+      lastAddedAt: () => lastAddedAt,
+      stop: () => page.off("response", listener),
+    };
+  }
+
+  async currentAssistantImages() {
+    const response = this.adapter.assistantMessages().last();
+    if (await response.count().catch(() => 0) === 0) return [];
+    return await response.locator("img").evaluateAll((images) => images.map((image) => ({
+      source: image.currentSrc || image.src || "",
+      alt: image.alt || "",
+      width: image.naturalWidth || 0,
+      height: image.naturalHeight || 0,
+    })).filter((image) => image.source && image.width >= 256 && image.height >= 256));
+  }
+
+  async waitForGeneratedImage(timeoutMs, tracker, baseline = new Set()) {
+    const deadline = Date.now() + timeoutMs;
+    let candidateKey = null;
+    let candidateSince = 0;
+    const textState = {};
+    while (Date.now() < deadline) {
+      const responses = tracker.images();
+      const responseByKey = new Map(responses.map((image) => [image.key, image]));
+      const rendered = (await this.currentAssistantImages().catch(() => []))
+        .map((image) => ({ ...image, parsed: parseGrokGeneratedImageUrl(image.source) }))
+        .filter((image) => (
+          image.parsed
+          && !baseline.has(image.parsed.key)
+          && responseByKey.has(image.parsed.key)
+        ));
+      const keys = [...new Set(rendered.map((image) => image.parsed.key))];
+      if (
+        keys.length > 0
+        && Date.now() - tracker.lastAddedAt() >= this.responseStabilityMs
+      ) {
+        const signature = keys.join("|");
+        if (candidateKey !== signature) {
+          candidateKey = signature;
+          candidateSince = Date.now();
+        } else if (Date.now() - candidateSince >= this.responseStabilityMs) {
+          const parsed = responseByKey.get(keys[0]);
+          return {
+            source: parsed.url,
+            providerFileId: parsed.id,
+            generatedImageCount: keys.length,
+            selectedImageIndex: 1,
+          };
+        }
+      }
+      if (keys.length === 0) {
+        const text = await this.completedTextResponse(textState);
+        if (text) return text;
+      } else {
+        textState.candidate = null;
+      }
+      await this.adapter.page.waitForTimeout(500);
+    }
+    throw new Error(`Grok did not finish an image within ${Math.round(timeoutMs / 1000)} seconds.`);
+  }
+
+  async downloadGeneratedImage(image) {
+    const temporaryDir = await fs.mkdtemp(path.join(os.tmpdir(), "wtagent-image-"));
+    const sourceUrl = new URL(image.source);
+    const extension = path.extname(sourceUrl.pathname).toLowerCase() || ".jpg";
+    const temporaryPath = path.join(temporaryDir, `generated-image${extension}`);
+    try {
+      const response = await this.adapter.page.request.get(image.source, {
+        timeout: 60_000,
+      });
+      if (!response.ok()) {
+        throw new Error(`Grok image download failed with HTTP ${response.status()}.`);
+      }
+      await fs.writeFile(temporaryPath, await response.body());
+      return {
+        temporaryDir,
+        temporaryPath,
+        suggestedFilename: path.basename(sourceUrl.pathname) || `generated-image${extension}`,
+        downloadUrl: image.source,
+      };
+    } catch (error) {
+      await fs.rm(temporaryDir, { recursive: true, force: true }).catch(() => null);
+      throw error;
+    }
+  }
+
+  async generate(request, execution = {}) {
+    if (request.referenceImages.length > 0) {
+      throw new Error("The current Grok image driver does not support reference images.");
+    }
+    await this.ensureChatPage();
+    const baseline = new Set(
+      (await this.currentAssistantImages().catch(() => []))
+        .map((image) => parseGrokGeneratedImageUrl(image.source)?.key)
+        .filter(Boolean),
+    );
+    const tracker = this.trackGeneratedImageResponses();
+    try {
+      tracker.arm();
+      return await this.performTurn(request, execution, async () => {
+        const image = await this.waitForGeneratedImage(
+          request.timeoutMs,
+          tracker,
+          baseline,
+        );
+        if (image.type === "text") return image;
+        const downloaded = await this.downloadGeneratedImage(image);
+        return {
+          sourcePath: downloaded.temporaryPath,
+          cleanup: async () => fs.rm(downloaded.temporaryDir, { recursive: true, force: true }),
+          provenance: {
+            provider: this.provider,
+            providerFileId: image.providerFileId,
+            suggestedFilename: downloaded.suggestedFilename,
+            generatedImageCount: image.generatedImageCount,
+            selectedImageIndex: image.selectedImageIndex,
+          },
+        };
+      });
+    } finally {
+      tracker.stop();
+    }
+  }
+}

package/src/platform/command-launcher.js

@@ -178,7 +178,7 @@ function buildBatchCommand(scriptPath, argv, {
 export function resolveLaunchPlan({
   program,
   argv = [],
-  cwd,
+  cwd = process.cwd(),
   env = process.env,
   platform = process.platform,
   existsSync = fs.existsSync,

package/src/platform/paths.js

@@ -7,6 +7,25 @@ import { getEnvCaseInsensitive } from "./command-launcher.js";
 const APP_NAME = "wtagent";
 const LEGACY_APP_NAME = "webagent";
 
+export function formatHomePath(filePath, {
+  platform = process.platform,
+  homeDir = os.homedir(),
+} = {}) {
+  const pathApi = platform === "win32" ? path.win32 : path.posix;
+  if (!pathApi.isAbsolute(filePath)) {
+    return filePath;
+  }
+  const relative = pathApi.relative(homeDir, filePath);
+  if (relative === "") {
+    return "~";
+  }
+  if (relative === ".." || relative.startsWith(`..${pathApi.sep}`)
+    || pathApi.isAbsolute(relative)) {
+    return filePath;
+  }
+  return `~${pathApi.sep}${relative}`;
+}
+
 function platformAppDataDir(appName, {
   env,
   platform,

package/src/platform/windows-diagnostics.js

@@ -8,11 +8,12 @@ import { promisify } from "node:util";
 import { discoverChromeExecutable } from "./chrome-discovery.js";
 import { resolveLaunchPlan } from "./command-launcher.js";
 import { inspectCdpProfileState } from "../browser/cdp-state.js";
+import { getPackageInfo } from "../shared/package-info.js";
 
 const execFileAsync = promisify(execFile);
 
 function parseMajorMinorPatch(version) {
-  const match = String(version ?? "").replace(/^v/, "").match(/^(\d+)\.(\d+)\.(\d+)/);
+  const match = String(version ?? "").replace(/^v/, "").match(/^(\d+)\.(\d+)\.(\d+)$/);
   if (!match) {
     return null;
   }
@@ -24,20 +25,12 @@ export function isSupportedNodeVersion(version = process.version) {
   if (!parsed) {
     return false;
   }
-  const [major, minor, patch] = parsed;
-  if (major > 20) {
-    return true;
-  }
-  if (major < 20) {
-    return false;
-  }
-  if (minor > 17) {
-    return true;
-  }
-  if (minor < 17) {
-    return false;
-  }
-  return patch >= 0;
+  const [major, minor] = parsed;
+  // Keep aligned with package.json and Inquirer's supported Node releases.
+  return (major === 20 && minor >= 17)
+    || (major === 22 && minor >= 13)
+    || (major === 23 && minor >= 5)
+    || major >= 24;
 }
 
 export function detectWsl({
@@ -126,7 +119,7 @@ export function assertNativeRuntimeSupported(context = {}) {
   const version = context.version ?? process.version;
   if (!isSupportedNodeVersion(version)) {
     throw new Error(
-      `WTAgent requires Node.js 20.17.0 or newer; current runtime is ${version}.`,
+      `WTAgent requires Node.js ${getPackageInfo().engines.node}; current runtime is ${version}.`,
     );
   }
 

package/src/policy/path-guard.js

@@ -73,7 +73,11 @@ export function isPathInside(rootPath, candidatePath, options = {}) {
     };
     const root = normalize(rootPath);
     const candidate = normalize(candidatePath);
-    return candidate === root || candidate.startsWith(`${root}\\`);
+    const relative = path.win32.relative(root, candidate);
+    return relative === ""
+      || (relative !== ".."
+        && !relative.startsWith("..\\")
+        && !path.win32.isAbsolute(relative));
   }
   const relative = path.relative(rootPath, candidatePath);
   return relative === ""

package/src/policy/policy-engine.js

@@ -9,6 +9,7 @@ const PATH_FIELDS = Object.freeze({
   "fs.search": ["path"],
   "terminal.exec": ["cwd"],
   "process.start": ["cwd"],
+  "image.generate": ["output_path", "reference_images"],
 });
 
 const PRIVILEGED_PROGRAMS = new Set(["sudo", "su", "doas", "runas"]);
@@ -268,11 +269,15 @@ export class PolicyEngine {
     let allowOutside = false;
 
     for (const field of PATH_FIELDS[toolCall.name] ?? []) {
-      const rawPath = toolCall.args[field] || ".";
-      const resolved = await resolveToolPath(context.projectRoot, rawPath);
-      if (!resolved.inside) {
-        reasons.push(`${field} is outside the selected project: ${resolved.path}`);
-        allowOutside = true;
+      const values = Array.isArray(toolCall.args[field])
+        ? toolCall.args[field]
+        : [toolCall.args[field] || "."];
+      for (const rawPath of values) {
+        const resolved = await resolveToolPath(context.projectRoot, rawPath);
+        if (!resolved.inside) {
+          reasons.push(`${field} is outside the selected project: ${resolved.path}`);
+          allowOutside = true;
+        }
       }
     }