wtagent 0.1.0 → 0.2.1

package/src/cli/render-events.js

@@ -54,8 +54,9 @@ function summarizeArgs(name, args = {}) {
 }
 
 export class Renderer {
-  constructor({ stream = process.stdout } = {}) {
+  constructor({ stream = process.stdout, providerLabel = "model" } = {}) {
     this.stream = stream;
+    this.providerLabel = providerLabel;
     this.isTTY = Boolean(stream.isTTY);
     this.spinner = null;
     this.timer = null;
@@ -263,10 +264,10 @@ export class Renderer {
         break;
       case "browser.auth_required":
         this.stopSpinner();
-        this.println(`${YELLOW}Log in to ChatGPT in the opened Chrome window…${RESET}`);
+        this.println(`${YELLOW}Log in to ${this.providerLabel} in the opened Chrome window…${RESET}`);
         break;
       case "browser.authenticated":
-        this.println(`${GREEN}ChatGPT login detected.${RESET}`);
+        this.println(`${GREEN}${this.providerLabel} login detected.${RESET}`);
         break;
       case "conversation.mode_selected": {
         const { requested, status, selectedLabel } = payload;
@@ -304,16 +305,17 @@ export class Renderer {
         this.stopSpinner();
         this.note(
           payload.deadRequest
-            ? `no reply from ChatGPT; asking it to continue (${payload.retry}/${payload.maxRetries})`
-            : `empty ChatGPT response; asking it to continue (${payload.retry}/${payload.maxRetries})`,
+            ? `no reply from ${this.providerLabel}; asking it to continue (${payload.retry}/${payload.maxRetries})`
+            : payload.generationFailed
+              ? `${this.providerLabel} generation failed (server error); asking it to retry (${payload.retry}/${payload.maxRetries})`
+              : `empty ${this.providerLabel} response; asking it to continue (${payload.retry}/${payload.maxRetries})`,
         );
         break;
       case "model.limit_reached":
         this.stopSpinner();
         this.note(
-          "ChatGPT usage limit reached. Try a different thinking level on resume "
-            + "(wtagent resume <session-id> --mode Pro or --mode Current), wait "
-            + "for the limit to reset, or change plans.",
+          `${this.providerLabel} usage limit reached. Wait for the limit to reset, `
+            + "try a different mode on resume, or change plans.",
         );
         break;
       case "model.progress":
@@ -325,6 +327,10 @@ export class Renderer {
       case "protocol.invalid":
         this.note(`format retry${payload.count ? ` (${payload.count})` : ""}: ${truncate(payload.message, 100)}`);
         break;
+      case "protocol.plain_answer":
+        this.stopSpinner();
+        this.note("The model answered without the XML protocol; showing the reply as the final answer.");
+        break;
       case "tool.proposed":
         this.stopSpinner();
         this.#toolCall(payload.name, payload.args);

package/src/cli/self-update.js

@@ -0,0 +1,145 @@
+import { spawn } from "node:child_process";
+import { resolveLaunchPlan } from "../platform/command-launcher.js";
+import { fetchJson, NETWORK_TIMEOUT_MS } from "../shared/fetch-json.js";
+import { getPackageName, getPackageVersion } from "../shared/package-info.js";
+
+export const UPDATE_CHECK_TIMEOUT_MS = NETWORK_TIMEOUT_MS;
+export const UPDATE_COMMAND_TIMEOUT_MS = 10_000;
+export const INSTALL_TIMEOUT_MS = 120_000;
+export const MANUAL_INSTALL_COMMAND = "npm install -g wtagent@latest";
+
+const VERSION_RE = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+
+export function npmRegistryLatestUrl(name = getPackageName()) {
+  return `https://registry.npmjs.org/${encodeURIComponent(name)}/latest`;
+}
+
+export function parseVersion(value) {
+  const match = String(value ?? "").trim().match(VERSION_RE);
+  if (!match) {
+    return null;
+  }
+  return {
+    core: [Number(match[1]), Number(match[2]), Number(match[3])],
+    pre: match[4] ?? null,
+  };
+}
+
+export function compareVersions(left, right) {
+  const parsedLeft = parseVersion(left);
+  const parsedRight = parseVersion(right);
+  if (!parsedLeft || !parsedRight) {
+    return null;
+  }
+  for (let index = 0; index < 3; index += 1) {
+    if (parsedLeft.core[index] !== parsedRight.core[index]) {
+      return parsedLeft.core[index] < parsedRight.core[index] ? -1 : 1;
+    }
+  }
+  if (!parsedLeft.pre && !parsedRight.pre) {
+    return 0;
+  }
+  if (!parsedLeft.pre) {
+    return 1;
+  }
+  if (!parsedRight.pre) {
+    return -1;
+  }
+  if (parsedLeft.pre === parsedRight.pre) {
+    return 0;
+  }
+  return parsedLeft.pre < parsedRight.pre ? -1 : 1;
+}
+
+export function isRemoteNewer(remote, local = getPackageVersion()) {
+  const comparison = compareVersions(local, remote);
+  return comparison != null && comparison < 0;
+}
+
+export async function fetchLatestVersion({
+  fetchImpl,
+  timeoutMs = UPDATE_CHECK_TIMEOUT_MS,
+  packageName = getPackageName(),
+} = {}) {
+  const document = await fetchJson(npmRegistryLatestUrl(packageName), {
+    fetchImpl,
+    timeoutMs,
+  });
+  return typeof document?.version === "string" && document.version.trim()
+    ? document.version.trim()
+    : null;
+}
+
+export async function installLatest({
+  spawnImpl = spawn,
+  planCommandImpl = (program, argv) => resolveLaunchPlan({ program, argv }),
+  timeoutMs = INSTALL_TIMEOUT_MS,
+  stdio = "inherit",
+} = {}) {
+  const plan = planCommandImpl("npm", ["install", "-g", "wtagent@latest"]);
+  return await new Promise((resolve) => {
+    let settled = false;
+    let timer;
+    const finish = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+
+    let child;
+    try {
+      child = spawnImpl(plan.command, plan.args, {
+        stdio,
+        shell: plan.shell,
+        windowsVerbatimArguments: plan.windowsVerbatimArguments,
+      });
+    } catch (error) {
+      finish({ ok: false, error });
+      return;
+    }
+
+    timer = setTimeout(() => {
+      child.kill();
+      finish({ ok: false, error: new Error("npm install timed out.") });
+    }, timeoutMs);
+
+    child.once("error", (error) => {
+      finish({ ok: false, error });
+    });
+    child.once("exit", (code) => {
+      finish({ ok: code === 0, code });
+    });
+  });
+}
+
+export async function runSelfUpdate({
+  fetchLatest = fetchLatestVersion,
+  install = installLatest,
+  write = console.log,
+  writeError = console.error,
+  currentVersion = getPackageVersion(),
+} = {}) {
+  const latest = await fetchLatest({ timeoutMs: UPDATE_COMMAND_TIMEOUT_MS });
+  if (!latest) {
+    writeError("Could not check npm for the latest WTAgent version.");
+    writeError(`Install it manually: ${MANUAL_INSTALL_COMMAND}`);
+    return { status: "error" };
+  }
+  if (!isRemoteNewer(latest, currentVersion)) {
+    write(`Already up to date (${currentVersion}).`);
+    return { status: "current", currentVersion, latest };
+  }
+
+  write(`Updating WTAgent ${currentVersion} → ${latest} ...`);
+  const result = await install();
+  if (!result.ok) {
+    writeError("Update failed.");
+    writeError(`Install it manually: ${MANUAL_INSTALL_COMMAND}`);
+    return { status: "error", currentVersion, latest };
+  }
+  write(`Updated to ${latest}. Run wtagent again to use the new version.`);
+  return { status: "updated", currentVersion, latest };
+}

package/src/cli/startup-notices.js

@@ -0,0 +1,161 @@
+import { fetchJson, NETWORK_TIMEOUT_MS } from "../shared/fetch-json.js";
+import { getPackageVersion } from "../shared/package-info.js";
+import { NoticeStore, getNoticeStorePath } from "./notice-store.js";
+import {
+  MANUAL_INSTALL_COMMAND,
+  fetchLatestVersion,
+  installLatest,
+  isRemoteNewer,
+} from "./self-update.js";
+
+export const NOTICES_URL =
+  "https://raw.githubusercontent.com/XiXian42/wtagent/main/notices.json";
+export const NOTICE_TIMEOUT_MS = NETWORK_TIMEOUT_MS;
+const MAX_NOTICE_TEXT = 2_000;
+const MAX_NOTICE_ID = 128;
+
+const CYAN = "\x1b[36m";
+const RESET = "\x1b[0m";
+
+export function sanitizeNoticeText(value) {
+  return String(value ?? "")
+    .replace(/\r\n|\r/g, "\n")
+    .replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, "")
+    .replace(/\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)?/g, "")
+    .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, "")
+    .trim()
+    .slice(0, MAX_NOTICE_TEXT);
+}
+
+function normalizeTimes(value) {
+  if (value == null) {
+    return 1;
+  }
+  const times = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(times)) {
+    return 1;
+  }
+  return Math.max(0, Math.floor(times));
+}
+
+export function parseNoticeDocument(document) {
+  const raw = Array.isArray(document?.notices) ? document.notices : [];
+  const notices = [];
+  const seen = new Set();
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object") {
+      continue;
+    }
+    const id = typeof entry.id === "string" ? entry.id.trim() : "";
+    const text = sanitizeNoticeText(entry.text);
+    if (!id || id.length > MAX_NOTICE_ID || !text || seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    notices.push({
+      id,
+      text,
+      times: normalizeTimes(entry.times),
+    });
+  }
+  return notices;
+}
+
+export function selectNotice(notices, store) {
+  for (const notice of notices) {
+    if (notice.times <= 0) {
+      continue;
+    }
+    if (store.shownCount(notice.id) >= notice.times) {
+      continue;
+    }
+    return notice;
+  }
+  return null;
+}
+
+export function formatNotice(text) {
+  return `\n${CYAN}Notice${RESET}\n${text}\n`;
+}
+
+export async function fetchNoticeDocument({
+  fetchImpl,
+  timeoutMs = NOTICE_TIMEOUT_MS,
+  url = NOTICES_URL,
+} = {}) {
+  const document = await fetchJson(url, { fetchImpl, timeoutMs });
+  return document && typeof document === "object" ? document : null;
+}
+
+export async function runStartupChecks({
+  appDataDir,
+  interactive = true,
+  fetchLatest = fetchLatestVersion,
+  fetchNotices = fetchNoticeDocument,
+  install = installLatest,
+  promptUpdate,
+  write = (text) => {
+    console.log(text);
+  },
+  writeError = (text) => {
+    console.error(text);
+  },
+  now,
+} = {}) {
+  if (!interactive) {
+    return "continue";
+  }
+
+  const store = new NoticeStore({
+    filePath: getNoticeStorePath(appDataDir),
+    now,
+  });
+  await store.ensureLoaded();
+
+  const needUpdateCheck = !store.wasUpdatePromptedToday();
+  const needNotice = !store.wasNoticeShownToday();
+  const latestPromise = needUpdateCheck
+    ? fetchLatest({ timeoutMs: NOTICE_TIMEOUT_MS })
+    : Promise.resolve(null);
+  const noticesPromise = needNotice
+    ? fetchNotices({ timeoutMs: NOTICE_TIMEOUT_MS })
+    : Promise.resolve(null);
+
+  const currentVersion = getPackageVersion();
+  const latest = await latestPromise;
+  if (needUpdateCheck && latest) {
+    if (isRemoteNewer(latest, currentVersion)) {
+      write(`A newer WTAgent is available: ${currentVersion} → ${latest}`);
+      const choice = await promptUpdate({ currentVersion, latest });
+      if (choice == null) {
+        return "aborted";
+      }
+      await store.markUpdatePrompted();
+      if (choice) {
+        write(`Updating WTAgent ${currentVersion} → ${latest} ...`);
+        const result = await install();
+        if (result.ok) {
+          write(`Updated to ${latest}. Restart wtagent to use the new version.`);
+          return "updated";
+        }
+        writeError("Update failed.");
+        writeError(`Install it manually: ${MANUAL_INSTALL_COMMAND}`);
+      }
+    } else {
+      await store.markUpdatePrompted();
+    }
+  }
+
+  if (!needNotice) {
+    return "continue";
+  }
+
+  const notices = parseNoticeDocument(await noticesPromise);
+  const selected = selectNotice(notices, store);
+  if (!selected) {
+    return "continue";
+  }
+  write(formatNotice(selected.text).trimEnd());
+  await store.recordNoticeShown(selected.id);
+  return "continue";
+}

package/src/platform/paths.js

@@ -63,6 +63,13 @@ export function getChromeProfileDir(appDataDir = getAppDataDir()) {
   return path.join(appDataDir, "chrome-profile");
 }
 
+// Resolves a named Chrome profile directory under the app data dir. The
+// provider→basename mapping lives in the provider registry; this helper only
+// joins the path so paths.js stays free of provider dependencies.
+export function getProfileDir(appDataDir, basename) {
+  return path.join(appDataDir, basename);
+}
+
 export function getTasksDir(appDataDir = getAppDataDir()) {
   return path.join(appDataDir, "tasks");
 }

package/src/platform/windows-diagnostics.js

@@ -55,6 +55,35 @@ export function detectWsl({
   );
 }
 
+export function getWslSupport({
+  platform = process.platform,
+  env = process.env,
+  osRelease = os.release(),
+} = {}) {
+  if (!detectWsl({ platform, env, osRelease })) {
+    return { supported: true, preview: false, reason: null };
+  }
+
+  const display = env.WAYLAND_DISPLAY || env.DISPLAY;
+  if (!display) {
+    return {
+      supported: false,
+      preview: false,
+      reason:
+        "WSL is detected, but no Linux graphical display is configured. Enable WSLg (or an X server), install Chrome/Chromium inside the WSL distribution, and retry.",
+    };
+  }
+
+  return {
+    supported: true,
+    preview: true,
+    reason:
+      `WSL is detected with a ${env.WAYLAND_DISPLAY ? "Wayland" : "X11"} display environment configured. `
+      + "This preview check does not verify that the display is reachable; WTAgent confirms that only when Linux Chrome starts. "
+      + "Windows-host Chrome is not used.",
+  };
+}
+
 export function getNativeWindowsSupport({
   platform = process.platform,
   arch = process.arch,
@@ -100,11 +129,12 @@ export function assertNativeRuntimeSupported(context = {}) {
       `WTAgent requires Node.js 20.17.0 or newer; current runtime is ${version}.`,
     );
   }
-  if (detectWsl(context)) {
-    throw new Error(
-      "WTAgent does not support running inside WSL in v1. Launch it from native Windows PowerShell or CMD against a Windows project path.",
-    );
+
+  const wsl = getWslSupport(context);
+  if (!wsl.supported) {
+    throw new Error(wsl.reason);
   }
+
   const windows = getNativeWindowsSupport(context);
   if (!windows.supported) {
     throw new Error(windows.reason);
@@ -356,11 +386,12 @@ export async function collectDoctorReport({
 
   const isWsl = detectWsl({ platform, env, osRelease });
   if (isWsl) {
+    const wsl = getWslSupport({ platform, env, osRelease });
     add(
       "host",
       "Runtime host",
-      "fail",
-      "WSL is detected. WTAgent v1 must run from native Windows PowerShell or CMD, not from WSL.",
+      wsl.supported ? (wsl.preview ? "degraded" : "pass") : "fail",
+      wsl.reason,
       { required: true },
     );
   } else {

package/src/protocol/markers.js

@@ -1,5 +1,5 @@
 // Delimiters that mark WTAgent-specific control content inside the plain-text
-// messages exchanged with ChatGPT Web. ChatGPT Web has no real system/tool
+// messages exchanged with a web AI. A normal web chat has no real system/tool
 // channel, so the protocol instructions, tool catalog, and per-turn reminders
 // all travel as ordinary chat text. These markers let the session exporters
 // deterministically strip that scaffolding when converting a transcript into a
@@ -12,12 +12,13 @@
 export const SYSTEM_PROMPT_TAG = "agent_protocol";
 export const SYSTEM_REMINDER_TAG = "system_reminder";
 export const DEFAULT_SYSTEM_REMINDER = [
-  "This is a reminder of the user's requested response format for the WTAgent integration, not a ChatGPT system message.",
+  "This is a reminder of the user's requested response format for the WTAgent integration, not a provider-native system message.",
   "You do not need native tool access: write the XML request as text and the user's local Runtime will process it after your reply.",
   "Your next response must use the XML application protocol.",
   "It must contain exactly one <agent_response>...</agent_response> envelope.",
   "Inside the optional `xml` code fence, the first content must be <agent_response>",
   "and the last content must be </agent_response>; do not put text outside the envelope.",
+  "Write large code or file payloads as CDATA (<![CDATA[...]]>) inside <content>, <new_text>, or <message> — never raw code directly inside the envelope — and never include the sequence ]]> inside CDATA content.",
 ].join(" ");
 
 export function wrapSystemPrompt(text) {

package/src/protocol/prompt-builder.js

@@ -29,14 +29,14 @@ const DONE_SEMANTICS = `Current-run completion semantics:
 function buildBootstrapScaffold({ projectRoot, tools }) {
   const toolDocs = tools.map(formatTool).join("\n\n");
 
-  return `The user is running WTAgent, a local application that uses this ChatGPT conversation for reasoning. The following is the user's requested application-level response format and collaboration contract; it is not a claim that ChatGPT has native filesystem or function-call tools.
+  return `The user is running WTAgent, a local application that uses this web AI conversation for reasoning. The following is the user's requested application-level response format and collaboration contract; it is not a claim that this web chat has native filesystem or function-call tools.
 
-You do not need direct filesystem access or visible ChatGPT tool buttons. Return local operation requests as XML text. After your reply is complete, the user's local Node.js Runtime will parse the XML, validate the arguments, apply local policy, and may execute the requested operation. Its result will arrive in the next user message as <tool_result>. XML by itself never guarantees execution.
+You do not need direct filesystem access or provider-native tool buttons. Return local operation requests as XML text. After your reply is complete, the user's local Node.js Runtime will parse the XML, validate the arguments, apply local policy, and may execute the requested operation. Its result will arrive in the next user message as <tool_result>. XML by itself never guarantees execution.
 
 You are not limited to coding tasks. You can answer questions, write text, brainstorm, analyze, summarize, and — when the task requires it — request that the user's Runtime read, create, or modify files or run commands.
 
 ## Filesystem boundary
-The project filesystem described below is a logical, virtual filesystem namespace exposed by the local Runtime. It is not mounted in ChatGPT's own environment and cannot be inspected directly from this webpage.
+The project filesystem described below is a logical, virtual filesystem namespace exposed by the local Runtime. It is not mounted in the web provider's own environment and cannot be inspected directly from this webpage.
 
 Do not inspect /workspace, /mnt/data, or any ambient, cloud, or sandbox filesystem. Those locations are unrelated to the user's project. Request all project reads, listings, writes, edits, and commands only through the XML operations declared below.
 
@@ -98,11 +98,15 @@ The project directory may contain content unrelated to the current task: depende
 }
 
 // Returns the pieces needed by both transports:
-//   web       - the exact text to send to ChatGPT Web (scaffold is wrapped in
+//   web       - the exact text to send to the web AI (scaffold is wrapped in
 //               <agent_protocol> markers, the user task follows outside them)
 //   developer - the transport scaffold, exposed for diagnostics/tests only
 //   user      - the user task, for the canonical user message
-export function buildBootstrapPrompt({ task, projectRoot, tools }) {
+export function buildBootstrapPrompt({
+  task,
+  projectRoot,
+  tools,
+}) {
   const developer = buildBootstrapScaffold({ projectRoot, tools });
   const web = `${wrapSystemPrompt(developer)}\n\n## User task\n${task}`;
   return { web, developer, user: task };