@cortexkit/aft-opencode 0.18.4 → 0.19.1

package/src/shared/last-user-model.ts

@@ -1,133 +0,0 @@
-/**
- * Cache-busting fix: every PromptInput we send to OpenCode starts a new
- * assistant turn (via `noReply: false`) or stores a new user message
- * (via `noReply: true`). OpenCode's `createUserMessage` (in
- * `packages/opencode/src/session/prompt.ts`) only preserves the user's
- * model variant if we pass it explicitly — otherwise it falls back to
- * `agent.variant` or undefined, silently switching the next assistant
- * turn off the variant the human chose. That switch evicts the
- * provider's prefix cache on every notification.
- *
- * This module fetches the last real user message's `{ providerID,
- * modelID, variant }` and exposes it so prompt callers can include it
- * verbatim in `PromptInput.model` + `PromptInput.variant`. Results are
- * memoised per session for a short window so a batch of warnings or
- * bg-completions only hits the messages API once.
- */
-
-interface SessionMessageInfo {
-  id?: string;
-  role?: string;
-  parts?: Array<{ ignored?: boolean }>;
-  model?: {
-    providerID?: string;
-    modelID?: string;
-    variant?: string;
-  };
-}
-
-interface SessionMessage {
-  info?: SessionMessageInfo;
-  parts?: Array<{ ignored?: boolean }>;
-}
-
-interface OpenCodeClientShape {
-  session?: {
-    messages?: (input: { path: { id: string } }) => Promise<{ data?: SessionMessage[] }>;
-  };
-}
-
-export interface LastUserModel {
-  providerID: string;
-  modelID: string;
-  variant?: string;
-}
-
-interface CacheEntry {
-  expiresAt: number;
-  model: LastUserModel | null;
-}
-
-const CACHE_TTL_MS = 5_000;
-const CACHE_MAX_ENTRIES = 100;
-const cache = new Map<string, CacheEntry>();
-
-/**
- * Returns the most recent real user message's model + variant for the
- * session, or `null` when the session has no user messages or the
- * client doesn't expose `session.messages`. Result is cached for
- * {@link CACHE_TTL_MS} ms per session — long enough to coalesce a
- * batch of notifications, short enough that an actual variant change
- * inside the conversation is picked up promptly.
- *
- * NOTE: Skips synthetic user messages we just produced ourselves
- * (those whose only parts are `ignored: true`). Otherwise our own
- * announcement could pin the variant after a single round-trip and
- * defeat the fix.
- */
-export async function getLastUserModel(
-  client: unknown,
-  sessionId: string,
-): Promise<LastUserModel | null> {
-  const now = Date.now();
-  const cached = cache.get(sessionId);
-  if (cached && cached.expiresAt > now) {
-    cache.delete(sessionId);
-    cache.set(sessionId, cached);
-    return cached.model;
-  }
-  if (cached) cache.delete(sessionId);
-
-  const c = client as OpenCodeClientShape;
-  const fetcher = c?.session?.messages;
-  if (typeof fetcher !== "function") {
-    return null;
-  }
-
-  let messages: SessionMessage[];
-  try {
-    const result = await fetcher({ path: { id: sessionId } });
-    messages = result?.data ?? [];
-  } catch {
-    // Don't cache failures — a transient API error shouldn't pin the
-    // session's variant resolution to "unknown" for 5 s.
-    return null;
-  }
-
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const info = messages[i]?.info;
-    if (info?.role !== "user") continue;
-    if (isSyntheticIgnoredMessage(messages[i])) continue;
-    const model = info.model;
-    if (!model?.providerID || !model?.modelID) continue;
-    const resolved: LastUserModel = {
-      providerID: model.providerID,
-      modelID: model.modelID,
-      ...(model.variant ? { variant: model.variant } : {}),
-    };
-    setCache(sessionId, resolved);
-    return resolved;
-  }
-
-  return null;
-}
-
-function setCache(sessionId: string, model: LastUserModel | null): void {
-  if (cache.has(sessionId)) cache.delete(sessionId);
-  cache.set(sessionId, { expiresAt: Date.now() + CACHE_TTL_MS, model });
-  while (cache.size > CACHE_MAX_ENTRIES) {
-    const oldest = cache.keys().next().value;
-    if (typeof oldest !== "string") break;
-    cache.delete(oldest);
-  }
-}
-
-function isSyntheticIgnoredMessage(message: SessionMessage | undefined): boolean {
-  const parts = message?.info?.parts ?? message?.parts;
-  return Array.isArray(parts) && parts.length > 0 && parts.every((part) => part?.ignored === true);
-}
-
-/** Test-only: drop the cache so unit tests can simulate fresh sessions. */
-export function __resetLastUserModelCacheForTests(): void {
-  cache.clear();
-}

package/src/shared/url-fetch.ts

@@ -1,465 +0,0 @@
-import { createHash } from "node:crypto";
-import { lookup } from "node:dns/promises";
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { isIP } from "node:net";
-import { join } from "node:path";
-import { Agent, type Dispatcher, fetch as undiciFetch } from "undici";
-import { log, warn } from "../logger";
-
-/** Max response body size (10 MB) */
-const MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
-/** Cache TTL: 1 day */
-const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
-/** Fetch timeout: 30 seconds */
-const FETCH_TIMEOUT_MS = 30_000;
-const MAX_REDIRECTS = 5;
-
-interface FetchUrlOptions {
-  allowPrivate?: boolean;
-  /** Test-only injection point. Production fetches use undici with DNS pinning. */
-  fetchImpl?: FetchImpl;
-  /** Test-only injection point. Production DNS resolution uses node:dns/promises.lookup. */
-  lookup?: LookupFn;
-  /** Test-only injection point for observing the DNS-pinned dispatcher. */
-  dispatcherFactory?: (validatedIp: string) => Dispatcher;
-}
-
-type LookupFn = typeof lookup;
-interface FetchInit {
-  signal?: AbortSignal;
-  redirect?: "manual";
-  dispatcher?: Dispatcher;
-  headers?: Record<string, string>;
-}
-
-type FetchImpl = (input: string, init: FetchInit) => Promise<Response>;
-
-interface CacheMeta {
-  url: string;
-  contentType: string;
-  extension: string;
-  fetchedAt: number;
-}
-
-function cacheDir(storageDir: string): string {
-  return join(storageDir, "url_cache");
-}
-
-function hashUrl(url: string): string {
-  return createHash("sha256").update(url).digest("hex").slice(0, 16);
-}
-
-function metaPath(storageDir: string, hash: string): string {
-  return join(cacheDir(storageDir), `${hash}.meta.json`);
-}
-
-function contentPath(storageDir: string, hash: string, extension: string): string {
-  return join(cacheDir(storageDir), `${hash}${extension}`);
-}
-
-/** Exported for unit tests. */
-export function _isPrivateIpv4(address: string): boolean {
-  const parts = address.split(".").map((part) => Number.parseInt(part, 10));
-  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part))) return true;
-  const [a, b] = parts;
-  return (
-    a === 0 || // 0.0.0.0/8 — wildcard, blocked to prevent local-host bypass
-    a === 10 ||
-    a === 127 ||
-    (a === 172 && b >= 16 && b <= 31) ||
-    (a === 192 && b === 168) ||
-    (a === 169 && b === 254) ||
-    a >= 224 // multicast (224/4) and reserved (240/4)
-  );
-}
-
-/**
- * Expand a possibly-compressed IPv6 address to 8 hextets (numbers).
- * Returns null on parse failure.
- */
-function expandIpv6(addr: string): number[] | null {
-  if (addr === "::") return [0, 0, 0, 0, 0, 0, 0, 0];
-  // Reject more than one "::"
-  const dcMatches = addr.match(/::/g);
-  if (dcMatches && dcMatches.length > 1) return null;
-
-  // Handle dotted-quad tail by converting to two hextets.
-  let normalized = addr;
-  const lastColon = normalized.lastIndexOf(":");
-  if (lastColon !== -1) {
-    const tail = normalized.slice(lastColon + 1);
-    if (tail.includes(".")) {
-      const octets = tail.split(".").map((p) => Number.parseInt(p, 10));
-      if (octets.length !== 4 || octets.some((o) => Number.isNaN(o) || o < 0 || o > 255)) {
-        return null;
-      }
-      const h1 = ((octets[0] << 8) | octets[1]).toString(16);
-      const h2 = ((octets[2] << 8) | octets[3]).toString(16);
-      normalized = `${normalized.slice(0, lastColon)}:${h1}:${h2}`;
-    }
-  }
-
-  let parts: string[];
-  if (normalized.includes("::")) {
-    const [left, right] = normalized.split("::");
-    const leftParts = left ? left.split(":") : [];
-    const rightParts = right ? right.split(":") : [];
-    const fill = 8 - leftParts.length - rightParts.length;
-    if (fill < 0) return null;
-    parts = [...leftParts, ...Array(fill).fill("0"), ...rightParts];
-  } else {
-    parts = normalized.split(":");
-  }
-
-  if (parts.length !== 8) return null;
-  const hextets = parts.map((p) => {
-    const n = Number.parseInt(p, 16);
-    return Number.isNaN(n) || n < 0 || n > 0xffff ? -1 : n;
-  });
-  if (hextets.some((h) => h === -1)) return null;
-  return hextets;
-}
-
-function isPrivateIp(address: string): boolean {
-  if (!address.includes(":")) {
-    return _isPrivateIpv4(address);
-  }
-
-  const lower = address.toLowerCase();
-  // Strip optional zone identifier (fe80::1%eth0 → fe80::1).
-  const noZone = lower.split("%")[0];
-
-  // Expand to 8 hextets so we can reliably detect IPv4-mapped/compatible
-  // forms even after URL canonicalization (e.g. [::ffff:127.0.0.1] →
-  // [::ffff:7f00:1]).
-  const hextets = expandIpv6(noZone);
-  if (hextets) {
-    // IPv4-mapped (::ffff:X.X.X.X) and IPv4-compatible (::X.X.X.X) — extract
-    // the embedded IPv4 from the last two hextets and check against IPv4 ranges.
-    const top6Zero = hextets.slice(0, 6).every((h) => h === 0);
-    const isMapped =
-      hextets[0] === 0 &&
-      hextets[1] === 0 &&
-      hextets[2] === 0 &&
-      hextets[3] === 0 &&
-      hextets[4] === 0 &&
-      hextets[5] === 0xffff;
-    if (isMapped || top6Zero) {
-      const a = (hextets[6] >> 8) & 0xff;
-      const b = hextets[6] & 0xff;
-      const c = (hextets[7] >> 8) & 0xff;
-      const d = hextets[7] & 0xff;
-      const ipv4 = `${a}.${b}.${c}.${d}`;
-      // ::1 (loopback) and :: (unspecified) both fall into top6Zero and last
-      // hextet 0 or 1 — _isPrivateIpv4 already blocks 0.0.0.0 and 127/8.
-      if (top6Zero && hextets[6] === 0 && hextets[7] <= 1) {
-        return true;
-      }
-      return _isPrivateIpv4(ipv4);
-    }
-
-    const firstHextet = hextets[0];
-    return (
-      // fe80::/10 link-local
-      (firstHextet >= 0xfe80 && firstHextet <= 0xfebf) ||
-      // fc00::/7 unique local
-      (firstHextet >= 0xfc00 && firstHextet <= 0xfdff) ||
-      // ff00::/8 multicast
-      firstHextet >= 0xff00
-    );
-  }
-
-  // Could not expand — be conservative and block.
-  return true;
-}
-
-async function assertPublicUrl(
-  url: URL,
-  allowPrivate: boolean,
-  dnsLookup: LookupFn = lookup,
-): Promise<string | undefined> {
-  if (url.protocol !== "http:" && url.protocol !== "https:") {
-    throw new Error(`Only http:// and https:// URLs are supported, got: ${url.protocol}`);
-  }
-  if (allowPrivate) return undefined;
-
-  // URL.hostname returns IPv6 literals wrapped in brackets ("[::1]") per WHATWG.
-  // Strip them before checking the address.
-  const hostname = url.hostname.replace(/^\[|\]$/g, "");
-
-  // If the hostname is already a literal IP, check it directly — skip DNS so we
-  // also catch malformed IPv6 forms (::127.0.0.1, ::ffff:127.0.0.1) that some
-  // resolvers reject as "not found" instead of returning the embedded IPv4.
-  if (isIP(hostname) || hostname.includes(":")) {
-    if (isPrivateIp(hostname)) {
-      throw new Error(`Blocked private URL host ${url.hostname} (${hostname})`);
-    }
-    return hostname;
-  }
-
-  const addresses = await dnsLookup(hostname, { all: true, verbatim: true });
-  for (const { address } of addresses) {
-    if (isPrivateIp(address)) {
-      throw new Error(`Blocked private URL host ${url.hostname} (${address})`);
-    }
-  }
-  if (addresses.length === 0) {
-    throw new Error(`Failed to resolve URL host ${url.hostname}`);
-  }
-  return addresses[0].address;
-}
-
-function createPinnedDispatcher(validatedIp: string): Dispatcher {
-  return new Agent({
-    connect: {
-      lookup: (_hostname, _opts, callback) => {
-        callback(null, validatedIp, validatedIp.includes(":") ? 6 : 4);
-      },
-    },
-  });
-}
-
-function resolveRedirectUrl(currentUrl: URL, location: string | null): URL {
-  if (!location) {
-    throw new Error(`Redirect from ${currentUrl.href} missing Location header`);
-  }
-  return new URL(location, currentUrl);
-}
-
-async function fetchWithRedirects(
-  startUrl: URL,
-  allowPrivate: boolean,
-  deps: Pick<FetchUrlOptions, "dispatcherFactory" | "fetchImpl" | "lookup"> = {},
-): Promise<Response> {
-  let currentUrl = startUrl;
-  const fetchImpl = deps.fetchImpl ?? (undiciFetch as FetchImpl);
-  const dnsLookup = deps.lookup ?? lookup;
-
-  for (let redirectCount = 0; redirectCount <= MAX_REDIRECTS; redirectCount++) {
-    const validatedIp = await assertPublicUrl(currentUrl, allowPrivate, dnsLookup);
-    const dispatcher = validatedIp
-      ? (deps.dispatcherFactory ?? createPinnedDispatcher)(validatedIp)
-      : undefined;
-
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-    let response: Response;
-    try {
-      response = await fetchImpl(currentUrl.href, {
-        signal: controller.signal,
-        redirect: "manual",
-        dispatcher,
-        headers: {
-          "user-agent": "aft-opencode-plugin",
-          // Prioritize markdown for content-negotiating servers (GitHub API, many docs sites).
-          // `application/vnd.github.raw` is GitHub's custom type — returns raw markdown from
-          // repo file and readme endpoints. Falls back to HTML if markdown is not available.
-          accept:
-            "application/vnd.github.raw, text/markdown, text/x-markdown, text/html;q=0.9, text/plain;q=0.5",
-        },
-      });
-    } catch (err) {
-      throw new Error(`Failed to fetch ${currentUrl.href}: ${(err as Error).message}`);
-    } finally {
-      clearTimeout(timer);
-    }
-
-    if (response.status < 300 || response.status >= 400) {
-      return response;
-    }
-
-    if (redirectCount === MAX_REDIRECTS) {
-      throw new Error(`Too many redirects fetching ${startUrl.href}`);
-    }
-    currentUrl = resolveRedirectUrl(currentUrl, response.headers.get("location"));
-  }
-
-  throw new Error(`Too many redirects fetching ${startUrl.href}`);
-}
-
-/**
- * Map a Content-Type header to a file extension AFT can parse.
- * Returns null for unsupported types.
- */
-function resolveExtension(contentType: string): string | null {
-  // Normalize: strip parameters (after `;`) AND pick the first value if the server
-  // echoed back a comma-separated list (GitHub API does this for /readme endpoints).
-  const lower = contentType.toLowerCase().split(";")[0].split(",")[0].trim();
-  if (
-    lower === "text/html" ||
-    lower === "application/xhtml+xml" ||
-    lower === "application/vnd.github.html" ||
-    lower === "application/vnd.github+html"
-  ) {
-    return ".html";
-  }
-  if (
-    lower === "text/markdown" ||
-    lower === "text/x-markdown" ||
-    lower === "application/markdown" ||
-    // GitHub API raw content type — returns raw markdown for README endpoints
-    lower === "application/vnd.github.raw" ||
-    lower === "application/vnd.github+raw" ||
-    lower === "application/vnd.github.v3.raw"
-  ) {
-    return ".md";
-  }
-  if (lower === "text/plain") {
-    // treat plain text as markdown so aft_outline can show headings if present
-    return ".md";
-  }
-  return null;
-}
-
-/**
- * Fetch a URL to a cached temp file. Uses disk cache with 1-day TTL.
- * Returns the cached file path the Rust outline/zoom command can read.
- * Throws on errors (invalid URL, network failure, unsupported content type, oversized body).
- */
-export async function fetchUrlToTempFile(
-  url: string,
-  storageDir: string,
-  options: FetchUrlOptions = {},
-): Promise<string> {
-  let parsed: URL;
-  try {
-    parsed = new URL(url);
-  } catch {
-    throw new Error(`Invalid URL: ${url}`);
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new Error(`Only http:// and https:// URLs are supported, got: ${parsed.protocol}`);
-  }
-  const allowPrivate = options.allowPrivate === true;
-
-  const dir = cacheDir(storageDir);
-  mkdirSync(dir, { recursive: true });
-
-  const hash = hashUrl(url);
-  const metaFile = metaPath(storageDir, hash);
-
-  // Check cache
-  if (existsSync(metaFile)) {
-    try {
-      const meta = JSON.parse(readFileSync(metaFile, "utf8")) as CacheMeta;
-      const age = Date.now() - meta.fetchedAt;
-      const cached = contentPath(storageDir, hash, meta.extension);
-      if (age < CACHE_TTL_MS && existsSync(cached)) {
-        log(`URL cache hit: ${url} (${Math.round(age / 1000)}s old)`);
-        return cached;
-      }
-    } catch {
-      // corrupted meta, re-fetch
-    }
-  }
-
-  log(`Fetching URL: ${url}`);
-  const response = await fetchWithRedirects(parsed, allowPrivate, options);
-
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status} ${response.statusText} fetching ${url}`);
-  }
-
-  const contentType = response.headers.get("content-type") || "text/plain";
-  const extension = resolveExtension(contentType);
-  if (!extension) {
-    throw new Error(
-      `Unsupported content type '${contentType}' for ${url}. Supported: text/html, text/markdown, text/plain`,
-    );
-  }
-
-  const lengthHeader = response.headers.get("content-length");
-  if (lengthHeader) {
-    const length = Number.parseInt(lengthHeader, 10);
-    if (Number.isFinite(length) && length > MAX_RESPONSE_BYTES) {
-      throw new Error(`Response too large: ${length} bytes (max ${MAX_RESPONSE_BYTES})`);
-    }
-  }
-
-  // Stream with size cap
-  const reader = response.body?.getReader();
-  if (!reader) {
-    throw new Error(`Failed to read response body for ${url}`);
-  }
-  const chunks: Uint8Array[] = [];
-  let total = 0;
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    if (value) {
-      total += value.length;
-      if (total > MAX_RESPONSE_BYTES) {
-        reader.cancel().catch(() => {});
-        throw new Error(`Response exceeded ${MAX_RESPONSE_BYTES} bytes, aborted`);
-      }
-      chunks.push(value);
-    }
-  }
-
-  // Write content and meta atomically
-  const body = Buffer.concat(chunks);
-  const contentFile = contentPath(storageDir, hash, extension);
-  const tmpContent = `${contentFile}.tmp-${process.pid}`;
-  writeFileSync(tmpContent, body);
-  const { renameSync } = await import("node:fs");
-  renameSync(tmpContent, contentFile);
-
-  const meta: CacheMeta = {
-    url,
-    contentType,
-    extension,
-    fetchedAt: Date.now(),
-  };
-  const tmpMeta = `${metaFile}.tmp-${process.pid}`;
-  writeFileSync(tmpMeta, JSON.stringify(meta));
-  renameSync(tmpMeta, metaFile);
-
-  log(`URL cached (${total} bytes): ${url}`);
-  return contentFile;
-}
-
-/**
- * Remove cache entries older than TTL. Called periodically at plugin startup.
- */
-export function cleanupUrlCache(storageDir: string): void {
-  const dir = cacheDir(storageDir);
-  if (!existsSync(dir)) return;
-
-  let removed = 0;
-  try {
-    for (const entry of readdirSync(dir)) {
-      if (!entry.endsWith(".meta.json")) continue;
-      const metaFile = join(dir, entry);
-      try {
-        const meta = JSON.parse(readFileSync(metaFile, "utf8")) as CacheMeta;
-        const age = Date.now() - meta.fetchedAt;
-        if (age > CACHE_TTL_MS) {
-          const hash = entry.slice(0, -".meta.json".length);
-          const content = contentPath(storageDir, hash, meta.extension);
-          if (existsSync(content)) unlinkSync(content);
-          unlinkSync(metaFile);
-          removed++;
-        }
-      } catch {
-        // corrupted meta, remove it too
-        try {
-          unlinkSync(metaFile);
-          removed++;
-        } catch {}
-      }
-    }
-  } catch (err) {
-    warn(`URL cache cleanup failed: ${(err as Error).message}`);
-    return;
-  }
-  if (removed > 0) {
-    log(`URL cache cleanup: removed ${removed} stale entries`);
-  }
-}