wtagent 0.1.0-alpha.0

package/src/browser/fake-web-model-adapter.js

@@ -0,0 +1,86 @@
+export class FakeWebModelAdapter {
+  constructor(responses = []) {
+    this.responses = [...responses];
+    this.sentMessages = [];
+    this.profileDir = "fake-profile";
+    this.launched = false;
+    this.mode = null;
+    this.conversationUrl = "https://chatgpt.com/";
+    this.lastAssistantMessageId = null;
+    this.responseNumber = 0;
+    this.startConversationCalls = [];
+    this.sentAttachments = [];
+    // Records window-state calls so tests can assert restore/minimize ordering.
+    this.windowStateCalls = [];
+  }
+
+  async launch() {
+    this.launched = true;
+  }
+
+  async close() {
+    this.launched = false;
+  }
+
+  async restoreWindow() {
+    this.windowStateCalls.push("restore");
+  }
+
+  async minimizeWindow() {
+    this.windowStateCalls.push("minimize");
+  }
+
+  async getAuthState() {
+    return "authenticated";
+  }
+
+  async waitForManualLogin() {}
+
+  async startConversation(conversationUrl = null) {
+    this.startConversationCalls.push(conversationUrl);
+    if (conversationUrl) {
+      this.conversationUrl = conversationUrl;
+    } else {
+      this.conversationUrl = "https://chatgpt.com/";
+    }
+  }
+
+  async selectMode(mode) {
+    this.mode = mode;
+    return {
+      status: "select",
+      requested: mode,
+      selectedLabel: mode,
+      attempts: 1,
+      reason: `Selecting ${mode}.`,
+    };
+  }
+
+  async getConversationUrl() {
+    return this.conversationUrl;
+  }
+
+  async sendMessage(text, { files = [] } = {}) {
+    this.sentMessages.push(text);
+    this.sentAttachments.push(files);
+    if (this.conversationUrl === "https://chatgpt.com/") {
+      this.conversationUrl = "https://chatgpt.com/c/fake";
+    }
+    return { attachment: files.length ? { attached: files, failed: [] } : null };
+  }
+
+  async waitForTurnComplete({ onDelta } = {}) {
+    if (this.responses.length === 0) {
+      throw new Error("Fake adapter has no more responses.");
+    }
+    const response = this.responses.shift();
+    this.responseNumber += 1;
+    this.lastAssistantMessageId = `assistant-${this.responseNumber}`;
+    await onDelta?.(response);
+    return response;
+  }
+
+  async getLastAssistantMessageId() {
+    return this.lastAssistantMessageId;
+  }
+}

package/src/browser/mode-selection.js

@@ -0,0 +1,179 @@
+// Language-independent model/mode selection logic for the ChatGPT web picker.
+//
+// The picker's visible labels are localized (e.g. "Pro", and reasoning tiers
+// like "Extra high"), so we must NOT match options by their display text.
+// Instead every option is identified by a stable attribute "slug" derived from
+// data-testid / data-* / id, which does not change with the UI language.
+//
+// This module is pure and DOM-free so it can be unit-tested without a browser.
+// The adapter supplies a small "port" of async DOM operations to
+// `runModeSelection`; all the retry / fallback policy lives here.
+
+export function slugTokens(slug) {
+  return String(slug ?? "").toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+}
+
+export function normalizeToken(value) {
+  return String(value ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+
+// Does the option's stable slug encode the requested mode token?
+// `token` is a normalized (separator-free) string, e.g. "pro" or "extrahigh".
+// Short tokens (< 4 chars, e.g. "pro") require an exact whole-segment match so
+// "pro" does not match "provider". Longer tokens also allow a substring match
+// against the separator-free slug, so a multi-word mode like "Extra high"
+// (-> "extrahigh") matches a hyphenated slug like "o3-extra-high".
+export function slugMatchesToken(slug, token) {
+  if (!token) {
+    return false;
+  }
+  const tokens = slugTokens(slug);
+  if (tokens.includes(token)) {
+    return true;
+  }
+  if (token.length >= 4) {
+    const joined = tokens.join("");
+    return joined.includes(token) || tokens.some((candidate) => candidate.includes(token));
+  }
+  return false;
+}
+
+// Given the enumerated menu options and the requested mode, decide what to do.
+// options: [{ index, slug, label, disabled }] in DOM order.
+// Returns { status, targetIndex, selectedLabel, reason }.
+//   status "select"              -> requested mode is available; click it.
+//   status "fallback"            -> requested mode is limited/disabled; click
+//                                   the option immediately before it.
+//   status "unavailable"         -> requested mode is not present in the menu.
+//   status "unavailable_disabled"-> requested mode is disabled and the previous
+//                                   option is not selectable either.
+export function chooseModeOption(options, requested) {
+  const token = normalizeToken(requested);
+  const proIndex = options.findIndex((option) => slugMatchesToken(option.slug, token));
+
+  if (proIndex === -1) {
+    return {
+      status: "unavailable",
+      targetIndex: null,
+      selectedLabel: null,
+      reason: `"${requested}" is not in the model menu.`,
+    };
+  }
+
+  const pro = options[proIndex];
+  if (!pro.disabled) {
+    return {
+      status: "select",
+      targetIndex: proIndex,
+      selectedLabel: pro.label || requested,
+      reason: `Selecting ${requested}.`,
+    };
+  }
+
+  // Pro is present but limited. Fall back to the option immediately before it.
+  const previous = options[proIndex - 1];
+  if (previous && !previous.disabled) {
+    return {
+      status: "fallback",
+      targetIndex: proIndex - 1,
+      selectedLabel: previous.label || `option ${proIndex}`,
+      reason: `${requested} is limited; selecting the previous option `
+        + `"${previous.label || proIndex - 1}" instead.`,
+    };
+  }
+
+  return {
+    status: "unavailable_disabled",
+    targetIndex: null,
+    selectedLabel: null,
+    reason: previous
+      ? `${requested} is limited and the previous option is also unavailable.`
+      : `${requested} is limited and has no previous option to fall back to.`,
+  };
+}
+
+// Orchestrates selection against a DOM "port". Never throws for mode issues:
+// it always resolves to a structured result the runtime can surface to the CLI,
+// so a limited/absent Pro degrades gracefully instead of aborting the run.
+//
+// port: {
+//   alreadyOnMode(requested) -> bool,
+//   hasSwitcher()            -> bool,
+//   openMenu()               -> void,
+//   readOptions()            -> [{index, slug, label, disabled}],
+//   clickOption(index)       -> bool (click landed),
+//   waitClosed()             -> bool (menu closed after click),
+//   closeMenu()              -> void,
+//   writeDiagnostics(label)  -> void,
+// }
+export async function runModeSelection(port, requested, { maxAttempts = 2 } = {}) {
+  if (!requested) {
+    return { status: "skipped", requested, attempts: 0, reason: "No mode requested." };
+  }
+
+  if (await port.alreadyOnMode(requested)) {
+    return {
+      status: "already",
+      requested,
+      selectedLabel: requested,
+      attempts: 0,
+      reason: `Already using ${requested}.`,
+    };
+  }
+
+  if (!await port.hasSwitcher()) {
+    await port.writeDiagnostics("mode-switcher-not-found");
+    return {
+      status: "switcher_not_found",
+      requested,
+      attempts: 0,
+      reason: "Model switcher was not found.",
+    };
+  }
+
+  let lastReason = "";
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    await port.openMenu();
+    const options = await port.readOptions();
+
+    // The Radix menu populates asynchronously; an empty read is a race, retry.
+    if (!options || options.length === 0) {
+      lastReason = "Model menu did not populate in time.";
+      await port.closeMenu();
+      continue;
+    }
+
+    const choice = chooseModeOption(options, requested);
+
+    if (choice.status === "select" || choice.status === "fallback") {
+      const clicked = await port.clickOption(choice.targetIndex);
+      const closed = clicked && await port.waitClosed();
+      if (closed) {
+        return { ...choice, requested, attempts: attempt };
+      }
+      lastReason = "The option click did not register.";
+      await port.closeMenu();
+      continue;
+    }
+
+    await port.closeMenu();
+
+    // A genuinely absent Pro might still be populating on the first pass, so
+    // retry once; a disabled Pro will not change, so report immediately.
+    if (choice.status === "unavailable" && attempt < maxAttempts) {
+      lastReason = choice.reason;
+      continue;
+    }
+
+    await port.writeDiagnostics(`mode-${requested}-${choice.status}`);
+    return { ...choice, requested, attempts: attempt };
+  }
+
+  await port.writeDiagnostics(`mode-${requested}-unresolved`);
+  return {
+    status: "unresolved",
+    requested,
+    attempts: maxAttempts,
+    reason: lastReason || `Could not select ${requested}.`,
+  };
+}

package/src/browser/native-login.js

@@ -0,0 +1,49 @@
+import { spawn } from "node:child_process";
+import { discoverChromeExecutable } from "../platform/chrome-discovery.js";
+import { ensureDirectory } from "../platform/paths.js";
+import { killProcessTree } from "../tools/process-utils.js";
+
+export async function launchNativeLoginBrowser({
+  profileDir,
+  chromePath,
+  url = "https://chatgpt.com/",
+}) {
+  await ensureDirectory(profileDir);
+  const executablePath = discoverChromeExecutable(chromePath);
+  const child = spawn(
+    executablePath,
+    [
+      `--user-data-dir=${profileDir}`,
+      "--profile-directory=Default",
+      "--no-first-run",
+      "--no-default-browser-check",
+      url,
+    ],
+    {
+      detached: process.platform !== "win32",
+      stdio: "ignore",
+      windowsHide: false,
+    },
+  );
+
+  await new Promise((resolve, reject) => {
+    child.once("spawn", resolve);
+    child.once("error", reject);
+  });
+
+  return {
+    pid: child.pid,
+    async close() {
+      await killProcessTree(child.pid);
+      await new Promise((resolve) => {
+        if (child.exitCode != null || child.signalCode != null) {
+          resolve();
+          return;
+        }
+        child.once("close", resolve);
+        setTimeout(resolve, 3_000).unref?.();
+      });
+    },
+  };
+}
+

package/src/cli/at-files.js

@@ -0,0 +1,93 @@
+// Parses `@file` mentions from an interactive message so the CLI can attach the
+// referenced files to the ChatGPT web composer.
+//
+// Supported forms:
+//   @path/to/file.txt          bare path (stops at whitespace)
+//   @/abs/path/to/file.jpeg    absolute path
+//   @"my file.pdf"             double-quoted path (may contain spaces)
+//   @'my file.pdf'             single-quoted path
+//
+// A bare `@` not followed by a path-like character (e.g. an email local part
+// like "foo@bar.com", or "@" alone) is left untouched.
+//
+// Attachments are NOT bounded to the project root: this is a web upload to the
+// user's own ChatGPT session (not a local tool read), so the user may attach
+// any file they can point at — an absolute path outside the project is valid.
+// A relative path is resolved against the project root for convenience.
+
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+// A mention is `@` that is at the start of the string or preceded by
+// whitespace, followed by either a quoted path or a bare path token.
+const MENTION = /(^|\s)@(?:"([^"]+)"|'([^']+)'|([^\s"']+))/g;
+
+// Extracts @mentions and resolves them to existing files.
+// Returns:
+//   mentions: [{ raw, requested }]           every syntactic @token found
+//   files:    [{ name, path, requested }]    resolved, existing files (any location)
+//   missing:  [{ requested, reason }]        tokens that did not resolve to a file
+export async function extractAtMentions(text, projectRoot) {
+  const source = String(text ?? "");
+  const mentions = [];
+  for (const match of source.matchAll(MENTION)) {
+    const requested = match[2] ?? match[3] ?? match[4] ?? "";
+    if (requested) {
+      mentions.push({ raw: `@${match[2] != null || match[3] != null ? `"${requested}"` : requested}`, requested });
+    }
+  }
+
+  const files = [];
+  const missing = [];
+  const seen = new Set();
+  for (const mention of mentions) {
+    if (seen.has(mention.requested)) {
+      continue;
+    }
+    seen.add(mention.requested);
+
+    // Absolute paths are used as-is; relative paths resolve against the project
+    // root. `~` is expanded to the user's home directory for convenience.
+    const expanded = expandHome(mention.requested);
+    const absPath = path.isAbsolute(expanded)
+      ? path.resolve(expanded)
+      : path.resolve(projectRoot, expanded);
+
+    let stat;
+    try {
+      stat = await fs.stat(absPath);
+    } catch {
+      missing.push({ requested: mention.requested, reason: "not-found" });
+      continue;
+    }
+    if (!stat.isFile()) {
+      missing.push({ requested: mention.requested, reason: "not-a-file" });
+      continue;
+    }
+
+    files.push({
+      name: basename(absPath),
+      path: absPath,
+      requested: mention.requested,
+    });
+  }
+
+  return { mentions, files, missing };
+}
+
+function expandHome(rawPath) {
+  const value = String(rawPath ?? "");
+  if (value === "~") {
+    return os.homedir();
+  }
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return path.join(os.homedir(), value.slice(2));
+  }
+  return value;
+}
+
+function basename(filePath) {
+  const parts = String(filePath).split(/[/\\]/);
+  return parts[parts.length - 1] || filePath;
+}