ashlr-plugin 1.36.4

package/servers/_http-helpers.ts

@@ -0,0 +1,151 @@
+/**
+ * Shared HTTP helpers used by both ashlr-http and ashlr-webfetch servers.
+ * Extracted here so webfetch-server.ts can import without triggering
+ * http-server's top-level `await server.connect(transport)`.
+ */
+
+// ---------- safety ----------
+
+export function isPrivateHost(host: string): boolean {
+  if (process.env.ASHLR_HTTP_ALLOW_PRIVATE === "1") return false;
+  const h = host.toLowerCase();
+  if (h === "localhost" || h === "::1" || h.endsWith(".localhost")) return true;
+  const v4 = /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/.exec(h);
+  if (v4) {
+    const [a, b] = [parseInt(v4[1]!, 10), parseInt(v4[2]!, 10)];
+    if (a === 10) return true;
+    if (a === 127) return true;
+    if (a === 192 && b === 168) return true;
+    if (a === 172 && b >= 16 && b <= 31) return true;
+    if (a === 169 && b === 254) return true; // link-local (metadata endpoint)
+    if (a === 0) return true;                 // RFC 1122 "this network"
+    if (a >= 224) return true;                // multicast + reserved
+  }
+  return false;
+}
+
+// ---------- safe fetch with manual redirect validation ----------
+
+export interface SafeFetchOptions extends RequestInit {
+  /** Max redirect hops. Default 5. */
+  maxRedirects?: number;
+  /** AbortSignal to cancel the whole chain (not just one hop). */
+  signal?: AbortSignal;
+}
+
+/**
+ * fetch() with SSRF-safe manual redirect handling.
+ *
+ * The native `fetch(url, { redirect: "follow" })` silently follows 3xx
+ * redirects without re-checking the target — an attacker can hand us a
+ * public URL that redirects to 127.0.0.1 or 169.254.169.254 (cloud
+ * metadata) and bypass `isPrivateHost` entirely. This wrapper validates
+ * every hop: if any redirect Location points at a private host (and
+ * `ASHLR_HTTP_ALLOW_PRIVATE` isn't set), it throws before any bytes are
+ * read from the internal target.
+ *
+ * Callers should use this in place of fetch() anywhere user-supplied URLs
+ * are involved.
+ */
+export async function safeFetch(
+  url: string,
+  opts: SafeFetchOptions = {},
+): Promise<Response> {
+  const maxRedirects = opts.maxRedirects ?? 5;
+  let currentUrl = url;
+  const { maxRedirects: _drop, ...fetchOpts } = opts;
+
+  for (let hop = 0; hop <= maxRedirects; hop++) {
+    let parsed: URL;
+    try { parsed = new URL(currentUrl); } catch { throw new Error(`invalid URL: ${currentUrl}`); }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new Error(`unsupported scheme: ${parsed.protocol} (http/https only)`);
+    }
+    if (isPrivateHost(parsed.hostname)) {
+      throw new Error(
+        hop === 0
+          ? `refusing private host ${parsed.hostname}; set ASHLR_HTTP_ALLOW_PRIVATE=1 to override`
+          : `refusing redirect to private host ${parsed.hostname} (hop ${hop}); set ASHLR_HTTP_ALLOW_PRIVATE=1 to override`,
+      );
+    }
+
+    const res = await fetch(currentUrl, { ...fetchOpts, redirect: "manual" });
+    // 2xx/4xx/5xx → return directly, caller handles. 3xx → follow if we have budget.
+    if (res.status < 300 || res.status >= 400) return res;
+    const location = res.headers.get("location");
+    if (!location) return res; // malformed 3xx, return as-is
+    // Resolve relative redirects against the current URL.
+    currentUrl = new URL(location, currentUrl).toString();
+  }
+  throw new Error(`too many redirects (> ${maxRedirects})`);
+}
+
+// ---------- HTML compressor ----------
+
+export function compressHtml(raw: string): string {
+  let s = raw;
+  s = s.replace(/<script[\s\S]*?<\/script>/gi, "");
+  s = s.replace(/<style[\s\S]*?<\/style>/gi, "");
+  s = s.replace(/<noscript[\s\S]*?<\/noscript>/gi, "");
+  s = s.replace(/<svg[\s\S]*?<\/svg>/gi, "");
+  s = s.replace(/<(nav|footer|aside|header|form)[^>]*>[\s\S]*?<\/\1>/gi, "");
+  const mainMatch = s.match(/<(main|article)\b[^>]*>([\s\S]*?)<\/\1>/i);
+  if (mainMatch) s = mainMatch[2]!;
+  s = s.replace(/<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi, (_, lvl, t) => "\n" + "#".repeat(+lvl) + " " + stripTags(t) + "\n");
+  s = s.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_, t) => "• " + stripTags(t) + "\n");
+  s = s.replace(/<a [^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi, (_, href, t) => stripTags(t) + ` (${href})`);
+  s = s.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, (_, t) => "\n```\n" + decodeEntities(stripTags(t)) + "\n```\n");
+  s = s.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, (_, t) => "`" + stripTags(t) + "`");
+  s = s.replace(/<br\s*\/?>/gi, "\n");
+  s = s.replace(/<p[^>]*>/gi, "\n");
+  s = s.replace(/<\/p>/gi, "\n");
+  s = stripTags(s);
+  s = decodeEntities(s);
+  s = s.replace(/\n{3,}/g, "\n\n").trim();
+  return s;
+}
+
+function stripTags(s: string): string {
+  return s.replace(/<[^>]+>/g, "");
+}
+
+function decodeEntities(s: string): string {
+  return s
+    .replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'")
+    .replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(+n));
+}
+
+// ---------- JSON compressor ----------
+
+export function compressJson(raw: string): string {
+  try {
+    const obj = JSON.parse(raw);
+    return JSON.stringify(elideLongArrays(obj), null, 2);
+  } catch {
+    return raw;
+  }
+}
+
+function elideLongArrays(v: any): any {
+  if (Array.isArray(v)) {
+    if (v.length > 20) {
+      const head = v.slice(0, 10).map(elideLongArrays);
+      const tail = v.slice(-5).map(elideLongArrays);
+      return [...head, `[... ${v.length - 15} elided ...]`, ...tail];
+    }
+    return v.map(elideLongArrays);
+  }
+  if (v && typeof v === "object") {
+    const o: any = {};
+    for (const [k, val] of Object.entries(v)) {
+      if (typeof val === "string" && val.length > 300) {
+        o[k] = val.slice(0, 280) + "…";
+      } else {
+        o[k] = elideLongArrays(val);
+      }
+    }
+    return o;
+  }
+  return v;
+}

package/servers/_identity-hash.ts

@@ -0,0 +1,151 @@
+/**
+ * _identity-hash.ts — WAD-D identity hashing.
+ *
+ * The WAD-D (weekly-active-developers-using-it-daily) north-star metric needs
+ * a way to count *distinct developers* on the backend without ever learning
+ * who any of them actually are. This module provides that anonymous identity.
+ *
+ * Identity scheme:
+ *   - machineHash = sha256(machine_id + quarterly_salt)
+ *     * machine_id is a stable random UUID stored at ~/.ashlr/machine-id,
+ *       generated on first call. Never overwritten. No PII.
+ *     * quarterly_salt = "salt_${year}Q${quarter}" derived deterministically
+ *       from the current UTC date. Rotates every 3 months without any manual
+ *       ops or remote config — the same client running 3 months later
+ *       computes a *different* hash for the same machine_id. The backend
+ *       therefore cannot reconstruct cross-quarter user identity.
+ *
+ *   - githubHash = sha256(github_login + quarterly_salt) IFF a Pro/Team
+ *     token has been validated AND the cached UserMe payload includes a
+ *     `githubLogin`. Otherwise `null` — never inferred, never guessed.
+ *
+ * Both hashes are hex-encoded sha256 (lowercase, 64 chars each). Identical
+ * across calls within the same quarter; different across quarters.
+ *
+ * No new dependencies — uses Node's built-in `crypto.createHash`.
+ */
+
+import { createHash, randomUUID } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+
+function home(): string {
+  return process.env.HOME ?? homedir();
+}
+
+export function machineIdPath(homeDir: string = home()): string {
+  return join(homeDir, ".ashlr", "machine-id");
+}
+
+function proTokenCachePath(homeDir: string = home()): string {
+  return join(homeDir, ".ashlr", "pro-token-cache.json");
+}
+
+// ---------------------------------------------------------------------------
+// machine_id — read or generate
+// ---------------------------------------------------------------------------
+
+/**
+ * Read the stable machine id from disk, generating one on first call.
+ * Always returns a non-empty string. Never throws.
+ */
+export function getOrCreateMachineId(homeDir: string = home()): string {
+  const p = machineIdPath(homeDir);
+  try {
+    if (existsSync(p)) {
+      const raw = readFileSync(p, "utf-8").trim();
+      if (raw.length > 0) return raw;
+    }
+  } catch {
+    /* fall through to create */
+  }
+  const id = randomUUID();
+  try {
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, id, "utf-8");
+  } catch {
+    /* best-effort — in-memory id still returned */
+  }
+  return id;
+}
+
+// ---------------------------------------------------------------------------
+// Quarterly salt — deterministic from current UTC year + quarter
+// ---------------------------------------------------------------------------
+
+/**
+ * Derive the quarterly salt for a given Date (defaults to now, UTC).
+ * Format: `salt_${year}Q${quarter}` where quarter ∈ {1, 2, 3, 4}.
+ *
+ * Exported so tests can mock the date input deterministically.
+ */
+export function quarterlySalt(now: Date = new Date()): string {
+  const year = now.getUTCFullYear();
+  const monthIndex = now.getUTCMonth(); // 0–11
+  const quarter = Math.floor(monthIndex / 3) + 1; // 1–4
+  return `salt_${year}Q${quarter}`;
+}
+
+// ---------------------------------------------------------------------------
+// githubLogin — try to read from the pro-token cache (best-effort)
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns the github_login of the currently signed-in Pro/Team user, or null
+ * when not signed in or when the cache doesn't include the field.
+ *
+ * This is intentionally tolerant: we never want a malformed cache or a
+ * partial UserMe response to throw on the hot path.
+ */
+export function readGithubLoginFromCache(homeDir: string = home()): string | null {
+  try {
+    const p = proTokenCachePath(homeDir);
+    if (!existsSync(p)) return null;
+    const raw = readFileSync(p, "utf-8");
+    const parsed = JSON.parse(raw) as { githubLogin?: unknown; valid?: unknown };
+    if (parsed.valid !== true) return null;
+    if (typeof parsed.githubLogin !== "string") return null;
+    const login = parsed.githubLogin.trim();
+    return login.length > 0 ? login : null;
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export interface IdentityHash {
+  /** sha256(machine_id + quarterly_salt) — hex, lowercase, 64 chars. */
+  machineHash: string;
+  /** sha256(github_login + quarterly_salt) when signed-in Pro/Team; else null. */
+  githubHash: string | null;
+}
+
+/**
+ * Compute the WAD-D identity hash pair. Defaults to "now" in UTC for the
+ * quarterly salt; tests can pass an explicit `now` to verify quarter rotation.
+ */
+export function getIdentityHash(opts: { now?: Date; homeDir?: string } = {}): IdentityHash {
+  const homeDir = opts.homeDir ?? home();
+  const now = opts.now ?? new Date();
+  const salt = quarterlySalt(now);
+
+  const machineId = getOrCreateMachineId(homeDir);
+  const machineHash = sha256Hex(machineId + salt);
+
+  const login = readGithubLoginFromCache(homeDir);
+  const githubHash = login ? sha256Hex(login + salt) : null;
+
+  return { machineHash, githubHash };
+}
+
+function sha256Hex(input: string): string {
+  return createHash("sha256").update(input).digest("hex");
+}

package/servers/_llm-providers/anthropic.ts

@@ -0,0 +1,132 @@
+/**
+ * Anthropic Haiku 4.5 provider.
+ *
+ * Availability: checks ANTHROPIC_API_KEY env var, then falls back to reading
+ * ~/.claude/.credentials.json (where Claude Code stores its OAuth token).
+ *
+ * On availability: returns true + caches.
+ * On network failure: throws so the dispatcher can fall through to next provider.
+ */
+
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import type { LlmProvider, LlmSummarizeResult } from "./types.ts";
+
+const MODEL = "claude-haiku-4-5-20251001";
+const API_BASE = "https://api.anthropic.com";
+const ANTHROPIC_VERSION = "2023-06-01";
+
+function home(): string {
+  return process.env.HOME ?? homedir();
+}
+
+/**
+ * Try to read the Anthropic API key from Claude Code's credential store.
+ * Claude Code writes OAuth tokens to ~/.claude/.credentials.json under the
+ * `claudeAiOauth` key. We extract `accessToken` from that entry.
+ *
+ * Returns null if the file doesn't exist or doesn't contain an API key shape.
+ */
+async function readClaudeCredentials(): Promise<string | null> {
+  try {
+    const path = join(home(), ".claude", ".credentials.json");
+    const raw = await readFile(path, "utf-8");
+    const parsed = JSON.parse(raw) as Record<string, unknown>;
+    // Claude Code OAuth shape: { claudeAiOauth: { accessToken: "..." } }
+    const oauth = parsed["claudeAiOauth"];
+    if (oauth && typeof oauth === "object") {
+      const token = (oauth as Record<string, unknown>)["accessToken"];
+      if (typeof token === "string" && token.length > 0) return token;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/** Resolve API key: env var takes priority over credential file. */
+async function resolveApiKey(): Promise<string | null> {
+  const env = process.env.ANTHROPIC_API_KEY;
+  if (env && env.trim().length > 0) return env.trim();
+  return readClaudeCredentials();
+}
+
+// Cache availability check for the process lifetime (key presence is stable).
+let _availableCache: boolean | null = null;
+
+export const anthropicProvider: LlmProvider = {
+  name: "anthropic",
+
+  async isAvailable(): Promise<boolean> {
+    if (_availableCache !== null) return _availableCache;
+    const key = await resolveApiKey();
+    _availableCache = key !== null && key.length > 0;
+    return _availableCache;
+  },
+
+  async summarize(
+    text: string,
+    prompt: string,
+    opts?: { maxTokens?: number },
+  ): Promise<LlmSummarizeResult> {
+    const apiKey = await resolveApiKey();
+    if (!apiKey) throw new Error("Anthropic: no API key available");
+
+    const maxTokens = opts?.maxTokens ?? 800;
+    const t0 = Date.now();
+
+    const ctl = new AbortController();
+    const timer = setTimeout(() => ctl.abort(), 15_000);
+
+    let res: Response;
+    try {
+      res = await fetch(`${API_BASE}/v1/messages`, {
+        method: "POST",
+        signal: ctl.signal,
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": ANTHROPIC_VERSION,
+        },
+        body: JSON.stringify({
+          model: MODEL,
+          max_tokens: maxTokens,
+          system: prompt,
+          messages: [{ role: "user", content: text }],
+        }),
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Anthropic API error ${res.status}: ${body.slice(0, 200)}`);
+    }
+
+    const latencyMs = Date.now() - t0;
+    const j = (await res.json()) as {
+      content?: Array<{ type: string; text?: string }>;
+      usage?: { input_tokens?: number; output_tokens?: number };
+    };
+
+    const output = (j.content ?? [])
+      .filter((b) => b.type === "text")
+      .map((b) => b.text ?? "")
+      .join("")
+      .trim();
+
+    if (!output) throw new Error("Anthropic: empty response");
+
+    const inTokens = j.usage?.input_tokens ?? 0;
+    const outTokens = j.usage?.output_tokens ?? 0;
+
+    return { output, inTokens, outTokens, latencyMs };
+  },
+};
+
+/** Test hook: reset the availability cache (so tests can toggle ANTHROPIC_API_KEY). */
+export function _resetAnthropicAvailabilityCache(): void {
+  _availableCache = null;
+}

package/servers/_llm-providers/cloud.ts

@@ -0,0 +1,195 @@
+/**
+ * Cloud LLM provider — ashlr hosted Anthropic Haiku proxy.
+ *
+ * For Pro users who don't have their own Anthropic API key. The backend at
+ * POST /llm/summarize handles billing, rate limiting, and cost caps so the
+ * user pays a flat $12/mo instead of managing Anthropic credits.
+ *
+ * Endpoint: ASHLR_API_URL (default: https://api.ashlr.ai) + /llm/summarize
+ * Auth:     Authorization: Bearer <contents of ~/.ashlr/pro-token>
+ * Timeout:  5s (Pro users expect fast responses)
+ *
+ * Error handling:
+ *   429 (rate-limit OR daily cap)  → throws CloudRateLimitError (dispatcher falls through)
+ *   5xx                            → throws generic Error (dispatcher falls through)
+ *   network / timeout              → throws generic Error (dispatcher falls through)
+ */
+
+import { existsSync } from "fs";
+import { readFile, stat } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import type { LlmProvider, LlmSummarizeResult } from "./types.ts";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const SUMMARIZE_TIMEOUT_MS = 5_000;
+/** Cache isAvailable() result for 24h — token presence is stable within a session. */
+const AVAIL_CACHE_TTL_MS = 24 * 60 * 60 * 1_000;
+
+// ---------------------------------------------------------------------------
+// Typed error for rate-limit / daily-cap responses
+// ---------------------------------------------------------------------------
+
+export class CloudRateLimitError extends Error {
+  /** Value of the Retry-After header when present (seconds), else undefined. */
+  readonly retryAfterSecs: number | undefined;
+  /** HTTP status returned by the backend (always 429). */
+  readonly statusCode: number;
+
+  constructor(message: string, statusCode: number, retryAfterSecs?: number) {
+    super(message);
+    this.name = "CloudRateLimitError";
+    this.statusCode = statusCode;
+    this.retryAfterSecs = retryAfterSecs;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function home(): string {
+  return process.env.HOME ?? homedir();
+}
+
+function proTokenPath(): string {
+  return join(home(), ".ashlr", "pro-token");
+}
+
+function apiBase(): string {
+  return (process.env.ASHLR_API_URL ?? "https://api.ashlr.ai").replace(/\/$/, "");
+}
+
+async function readProToken(): Promise<string | null> {
+  const path = proTokenPath();
+  if (!existsSync(path)) return null;
+  try {
+    const token = (await readFile(path, "utf-8")).trim();
+    return token.length > 0 ? token : null;
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Availability cache
+// ---------------------------------------------------------------------------
+
+let _availCache: { available: boolean; expiresAt: number } | null = null;
+
+/** Reset availability cache (test hook). */
+export function _resetCloudAvailabilityCache(): void {
+  _availCache = null;
+}
+
+// ---------------------------------------------------------------------------
+// Provider
+// ---------------------------------------------------------------------------
+
+export const cloudProvider: LlmProvider = {
+  name: "cloud",
+
+  async isAvailable(): Promise<boolean> {
+    const now = Date.now();
+    if (_availCache && now < _availCache.expiresAt) return _availCache.available;
+
+    const path = proTokenPath();
+    let available = false;
+
+    if (existsSync(path)) {
+      try {
+        // Lightweight check: file exists AND was validated within last 24h
+        // (Track P1 will upgrade this to full JWT validation when it lands).
+        const s = await stat(path);
+        const token = (await readFile(path, "utf-8")).trim();
+        available = token.length > 0 && now - s.mtimeMs < AVAIL_CACHE_TTL_MS;
+      } catch {
+        available = false;
+      }
+    }
+
+    _availCache = { available, expiresAt: now + AVAIL_CACHE_TTL_MS };
+    return available;
+  },
+
+  async summarize(
+    text: string,
+    prompt: string,
+    opts?: { maxTokens?: number },
+  ): Promise<LlmSummarizeResult> {
+    const token = await readProToken();
+    if (!token) throw new Error("cloud provider: no pro-token found");
+
+    const url = `${apiBase()}/llm/summarize`;
+    const maxTokens = opts?.maxTokens;
+    const t0 = Date.now();
+
+    const ctl = new AbortController();
+    const timer = setTimeout(() => ctl.abort(), SUMMARIZE_TIMEOUT_MS);
+
+    let res: Response;
+    try {
+      res = await fetch(url, {
+        method: "POST",
+        signal: ctl.signal,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({
+          text,
+          systemPrompt: prompt,
+          toolName: "ashlr__cloud",
+          ...(maxTokens !== undefined ? { maxTokens } : {}),
+        }),
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+
+    // 429 — rate limit (per-minute bucket) OR daily cap exhausted
+    if (res.status === 429) {
+      const body = await res.text().catch(() => "");
+      const retryHeader = res.headers.get("retry-after");
+      const retryAfterSecs = retryHeader ? parseInt(retryHeader, 10) : undefined;
+      throw new CloudRateLimitError(
+        `Cloud LLM rate limit: ${body.slice(0, 200)}`,
+        429,
+        Number.isFinite(retryAfterSecs) ? retryAfterSecs : undefined,
+      );
+    }
+
+    // 5xx — backend error; let dispatcher fall through to onnx/local/snipCompact
+    if (res.status >= 500) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Cloud LLM error ${res.status}: ${body.slice(0, 200)}`);
+    }
+
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Cloud LLM error ${res.status}: ${body.slice(0, 200)}`);
+    }
+
+    const latencyMs = Date.now() - t0;
+
+    const j = (await res.json()) as {
+      summary?: string;
+      inputTokens?: number;
+      outputTokens?: number;
+    };
+
+    if (!j.summary || j.summary.trim().length === 0) {
+      throw new Error("Cloud LLM: empty summary in response");
+    }
+
+    return {
+      output: j.summary.trim(),
+      inTokens: j.inputTokens ?? 0,
+      outTokens: j.outputTokens ?? 0,
+      latencyMs,
+    };
+  },
+};