latent-opencode 0.0.0-stage → 0.1.0-alpha.1

package/README.md

@@ -1,3 +1,18 @@
-# Temporary Holding Version
+# latent-opencode
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Earn while your agent works, without leaving your own OpenCode TUI (v2.2+).
+One labelled sponsored line sits in the prompt footer during a turn. The
+plugin only draws in the terminal: it never reads or changes the model's
+request or reply.
+
+    opencode plugin add latent-opencode
+
+| Command | |
+| --- | --- |
+| `/latent` | wallet, balance, sponsored line on/off |
+| `/latent-login` | connect the wallet Earn pays into |
+| `/latent-open` | open the sponsored link |
+
+The wallet is shared with every Latent surface (`~/.latent-protocol`), so a
+login from `npx latentcode login` works here too. Prefer a dedicated app?
+`npx latentcode`.

package/dist/runtime.js

@@ -0,0 +1,920 @@
+// ../src/ads/controller.ts
+import { randomUUID } from "node:crypto";
+
+// ../src/ads/sanitize.ts
+var ESC_SEQ = /\x1b\][\s\S]*?(?:\x07|\x1b\\|$)|\x1b\[[0-?]*[ -/]*[@-~]|\x1b[ -/]*[0-~]|\x1b[@-_]/g;
+var CONTROL = /[\x00-\x1f\x7f-\x9f]/g;
+var BIDI = /[‪-‮⁦-⁩‎‏؜]/g;
+function sanitizeAdText(input, max = 140) {
+  let s = String(input ?? "");
+  s = s.replace(ESC_SEQ, "").replace(CONTROL, " ").replace(BIDI, "");
+  s = s.replace(/\s+/g, " ").trim();
+  if (max > 0 && s.length > max) s = `${s.slice(0, Math.max(0, max - 1)).trimEnd()}\u2026`;
+  return s;
+}
+var AD_LIMITS = { title: 30, body: 140, cta_text: 24 };
+
+// ../src/ads/adline.ts
+var WORD = /[\p{L}\p{N}]/u;
+var LEAD_SEP = /^[\s\-:–—]+/;
+function clampField(value, max) {
+  const t = value.trim();
+  if (t.length <= max) return t;
+  return `${t.slice(0, Math.max(1, max - 1)).trimEnd()}\u2026`;
+}
+function dedupeBrand(brand, body) {
+  let t = body.trim();
+  const b = brand.trim();
+  if (!b) return t;
+  const lb = b.toLowerCase();
+  while (t.toLowerCase().startsWith(lb)) {
+    const after = t.charAt(b.length);
+    if (after !== "" && WORD.test(after)) break;
+    const rest = t.slice(b.length).replace(LEAD_SEP, "");
+    if (rest === t) break;
+    t = rest;
+    if (t === "") break;
+  }
+  return t;
+}
+function composeAdCopy(title, body) {
+  const brandRaw = sanitizeAdText(title, 0);
+  const bodyRaw = sanitizeAdText(body, 0);
+  return { brand: clampField(brandRaw, 30), line: clampField(dedupeBrand(brandRaw, bodyRaw), 60) };
+}
+function isSafeUrl(raw, allowLoopbackHttp = false) {
+  if (typeof raw !== "string" || !raw) return false;
+  if (/[\x00-\x20\x7f-\x9f]/.test(raw)) return false;
+  try {
+    const u = new URL(raw);
+    if (u.username || u.password) return false;
+    if (u.protocol === "https:") return true;
+    return allowLoopbackHttp && u.protocol === "http:" && (u.hostname === "127.0.0.1" || u.hostname === "localhost");
+  } catch {
+    return false;
+  }
+}
+function displayUrl(url) {
+  return url.startsWith("https://") ? url.slice("https://".length).replace(/\/$/, "") : "";
+}
+function clickLink(server, ad, wallet, ctaUrl) {
+  const base = server.replace(/\/+$/, "");
+  if (!ad.click_token || !isSafeUrl(base, true)) return ctaUrl;
+  return `${base}/ad/click?ad=${encodeURIComponent(ad.ad_id)}&w=${encodeURIComponent(wallet)}&t=${encodeURIComponent(ad.click_token)}`;
+}
+var BADGE_COLORS = ["#F87171", "#FB923C", "#FBBF24", "#A3E635", "#34D399", "#22D3EE", "#60A5FA", "#A78BFA", "#F472B6"];
+function adBadge(brand) {
+  const letter = ([...brand].find((c) => /[\p{L}\p{N}]/u.test(c)) ?? "").toLocaleUpperCase();
+  let h = 2166136261;
+  for (const c of brand.toLowerCase()) h = Math.imul(h ^ c.codePointAt(0), 16777619);
+  return { letter: letter || "\u2022", color: BADGE_COLORS[(h >>> 0) % BADGE_COLORS.length] };
+}
+
+// ../src/ads/classify.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var KEYWORDS = {
+  "frontend-ui": [
+    "react",
+    "vue",
+    "svelte",
+    "angular",
+    "next",
+    "nuxt",
+    "tailwind",
+    "css",
+    "component",
+    "frontend",
+    "ui",
+    "ux",
+    "webpack",
+    "vite",
+    "dom",
+    "jsx",
+    "tsx"
+  ],
+  backend: [
+    "api",
+    "server",
+    "express",
+    "fastapi",
+    "flask",
+    "django",
+    "rails",
+    "spring",
+    "endpoint",
+    "rest",
+    "graphql",
+    "grpc",
+    "middleware",
+    "auth",
+    "jwt",
+    "route"
+  ],
+  databases: [
+    "sql",
+    "postgres",
+    "postgresql",
+    "mysql",
+    "sqlite",
+    "mongodb",
+    "mongo",
+    "redis",
+    "prisma",
+    "query",
+    "schema",
+    "migration",
+    "index",
+    "orm",
+    "database"
+  ],
+  "devops-infra": [
+    "docker",
+    "kubernetes",
+    "k8s",
+    "terraform",
+    "ansible",
+    "ci",
+    "cd",
+    "pipeline",
+    "deploy",
+    "nginx",
+    "aws",
+    "gcp",
+    "azure",
+    "helm",
+    "infra",
+    "devops",
+    "compose"
+  ],
+  "ai-ml": [
+    "llm",
+    "gpt",
+    "openai",
+    "anthropic",
+    "claude",
+    "embedding",
+    "vector",
+    "rag",
+    "pytorch",
+    "tensorflow",
+    "model",
+    "training",
+    "inference",
+    "prompt",
+    "agent",
+    "ml"
+  ],
+  "web3-crypto": [
+    "solidity",
+    "ethereum",
+    "evm",
+    "wallet",
+    "web3",
+    "onchain",
+    "contract",
+    "erc20",
+    "erc721",
+    "base",
+    "usdc",
+    "x402",
+    "defi",
+    "token",
+    "crypto",
+    "blockchain"
+  ],
+  mobile: [
+    "swift",
+    "swiftui",
+    "kotlin",
+    "android",
+    "ios",
+    "flutter",
+    "dart",
+    "react-native",
+    "expo",
+    "xcode",
+    "mobile"
+  ],
+  "data-eng": [
+    "pandas",
+    "spark",
+    "airflow",
+    "etl",
+    "dbt",
+    "kafka",
+    "snowflake",
+    "bigquery",
+    "warehouse",
+    "dataframe",
+    "parquet",
+    "pipeline",
+    "analytics"
+  ]
+};
+var MANIFESTS = [
+  "package.json",
+  "requirements.txt",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "Gemfile",
+  "pom.xml",
+  "build.gradle"
+];
+function readManifestText(cwd) {
+  const parts = [];
+  for (const name of MANIFESTS) {
+    const p = join(cwd, name);
+    if (!existsSync(p)) continue;
+    try {
+      parts.push(readFileSync(p, "utf8"));
+    } catch {
+    }
+  }
+  return parts.join("\n");
+}
+function scoreText(haystack) {
+  const scores = /* @__PURE__ */ new Map();
+  const lower = haystack.toLowerCase();
+  for (const [cat, words] of Object.entries(KEYWORDS)) {
+    let hits = 0;
+    for (const w of words) {
+      const re = new RegExp(`(?:^|[^a-z0-9])${w}(?=[^a-z0-9]|$)`, "g");
+      const m = lower.match(re);
+      if (m) hits += m.length;
+    }
+    if (hits) scores.set(cat, hits);
+  }
+  return scores;
+}
+function classifyPrompt(prompt, cwd = process.cwd()) {
+  const promptScores = scoreText(prompt || "");
+  const manifestScores = scoreText(readManifestText(cwd));
+  const total = /* @__PURE__ */ new Map();
+  for (const [c, n] of promptScores) total.set(c, (total.get(c) ?? 0) + n);
+  for (const [c, n] of manifestScores) total.set(c, (total.get(c) ?? 0) + n * 2);
+  let best = "general";
+  let bestScore = 0;
+  for (const [c, n] of total) {
+    if (n > bestScore) {
+      best = c;
+      bestScore = n;
+    }
+  }
+  return best;
+}
+
+// ../src/ads/controller.ts
+var MIN_VISIBLE_MS = 1e4;
+var ROTATE_MS = 1e4;
+var HOLD_MS = 27e4;
+function safeUrl(raw) {
+  return raw && isSafeUrl(raw) ? new URL(raw).toString() : "";
+}
+function toDisplayAd(ad, opts = {}) {
+  const { brand, line } = composeAdCopy(ad.title, ad.body);
+  if (!brand && !line) return null;
+  const url = safeUrl(ad.cta_url);
+  return {
+    ad,
+    title: brand,
+    body: line,
+    ctaText: sanitizeAdText(ad.cta_text, AD_LIMITS.cta_text) || "Learn more",
+    url,
+    link: url && opts.server && opts.wallet ? clickLink(opts.server, ad, opts.wallet, url) : url,
+    shownUrl: displayUrl(url),
+    earn: typeof ad.earn_amount === "number" && Number.isFinite(ad.earn_amount) ? ad.earn_amount : 0,
+    eventUuid: randomUUID(),
+    fetchedAt: opts.now ?? Date.now()
+  };
+}
+var AdController = class {
+  o;
+  working = false;
+  current = null;
+  shownAt = 0;
+  visibleMs = 0;
+  billed = false;
+  lastTick = 0;
+  fetching = false;
+  generation = 0;
+  context = "general";
+  impressions = 0;
+  sessionEarned = 0;
+  listeners = /* @__PURE__ */ new Set();
+  /** Cached for useSyncExternalStore — must be referentially stable between emits. */
+  snap = null;
+  constructor(opts) {
+    this.o = {
+      ...opts,
+      cwd: opts.cwd ?? process.cwd(),
+      now: opts.now ?? Date.now,
+      minVisibleMs: opts.minVisibleMs ?? MIN_VISIBLE_MS,
+      rotateMs: opts.rotateMs ?? ROTATE_MS,
+      holdMs: opts.holdMs ?? HOLD_MS,
+      classify: opts.classify ?? ((p, cwd) => classifyPrompt(p, cwd))
+    };
+    opts.focus.onChange(() => this.emit());
+  }
+  get status() {
+    if (!this.o.enabled) return "disabled";
+    if (!this.o.wallet) return "no-wallet";
+    return "ok";
+  }
+  /** The wallet changed (in-app login). Earnings from here on go to it. */
+  setWallet(wallet) {
+    if (wallet === this.o.wallet) return;
+    this.o.wallet = wallet;
+    this.clear();
+    if (this.working) void this.fetchNext();
+    this.emit();
+  }
+  setEnabled(enabled) {
+    this.o.enabled = enabled;
+    if (!enabled) this.clear();
+    this.emit();
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  snapshot() {
+    if (this.snap) return this.snap;
+    return this.snap = {
+      status: this.status,
+      current: this.working ? this.current : null,
+      visibleMs: this.visibleMs,
+      billed: this.billed,
+      focusTracked: this.o.focus.known,
+      impressions: this.impressions,
+      sessionEarned: this.sessionEarned,
+      context: this.context
+    };
+  }
+  /** Called on execution start/end. `prompt` is classified locally, never sent. */
+  setWorking(working, prompt = "") {
+    if (working === this.working) return;
+    this.working = working;
+    this.lastTick = this.o.now();
+    if (working) {
+      this.context = this.o.classify(prompt, this.o.cwd);
+      if (!this.holding()) {
+        this.clear();
+        void this.fetchNext();
+      }
+    } else if (this.billed || !this.current) {
+      this.clear();
+    } else {
+      this.generation += 1;
+    }
+    this.emit();
+  }
+  /** An un-billed ad that may still be shown and billed. */
+  holding() {
+    return !!this.current && !this.billed && this.o.now() - this.current.fetchedAt < this.o.holdMs;
+  }
+  /** Advance the attention clock. Call every ~250ms. */
+  tick() {
+    const now = this.o.now();
+    const dt = Math.max(0, now - this.lastTick);
+    this.lastTick = now;
+    if (!this.working || !this.current) return;
+    if (!this.billed && !this.holding()) {
+      this.clear();
+      void this.fetchNext();
+      return;
+    }
+    if (this.o.focus.focused) this.visibleMs += dt;
+    if (!this.billed && this.visibleMs >= this.o.minVisibleMs) {
+      this.billed = true;
+      const shown = this.current;
+      void this.o.api.impression({
+        ad: shown.ad,
+        wallet: this.o.wallet,
+        context: this.context,
+        displayedMs: this.visibleMs,
+        focusTracked: this.o.focus.known,
+        eventUuid: shown.eventUuid
+      }).then((result) => {
+        if (result !== "tracked") return;
+        this.impressions += 1;
+        this.sessionEarned += shown.earn;
+        this.emit();
+      }).catch(() => {
+      });
+      this.emit();
+    }
+    if (this.billed && now - this.shownAt >= this.o.rotateMs && !this.fetching) {
+      void this.fetchNext();
+    }
+  }
+  /** User asked to open the ad (keyboard): the tracked link, or null. The server counts the click on redirect. */
+  click() {
+    const ad = this.working ? this.current : null;
+    return ad?.link || null;
+  }
+  clear() {
+    this.generation += 1;
+    this.current = null;
+    this.visibleMs = 0;
+    this.billed = false;
+  }
+  async fetchNext() {
+    if (this.status !== "ok" || this.fetching) return;
+    this.fetching = true;
+    const gen = this.generation;
+    try {
+      const ad = await this.o.api.request({ wallet: this.o.wallet, context: this.context, sessionId: this.o.sessionId });
+      if (gen !== this.generation || !this.working || this.status !== "ok") return;
+      const display = ad ? toDisplayAd(ad, { server: this.o.api.server, wallet: this.o.wallet, now: this.o.now() }) : null;
+      if (!display) {
+        if (this.current) this.shownAt = this.o.now();
+        return;
+      }
+      this.current = display;
+      this.shownAt = this.o.now();
+      this.lastTick = this.shownAt;
+      this.visibleMs = 0;
+      this.billed = false;
+      this.emit();
+    } finally {
+      this.fetching = false;
+    }
+  }
+  emit() {
+    this.snap = null;
+    for (const fn of this.listeners) fn();
+  }
+};
+
+// ../src/ads/config.ts
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+var DEFAULT_SERVER = "https://api.latentprotocol.xyz";
+var AGENT_LATENTCODE = "latentcode";
+function configDir() {
+  return join2(homedir(), ".latent-protocol");
+}
+function configFile() {
+  return join2(configDir(), "config.json");
+}
+function deviceIdFile() {
+  return join2(configDir(), "device_id");
+}
+var DEVICE_CREDENTIAL_RE = /^[0-9a-f]{32}\.\d+\.[A-Za-z0-9_-]+$/i;
+var WALLET_RE = /^0x[0-9a-fA-F]{40}$/;
+function loadConfig() {
+  try {
+    return JSON.parse(readFileSync2(configFile(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(data) {
+  mkdirSync(configDir(), { recursive: true });
+  const next = { ...loadConfig(), ...data };
+  writeFileSync(configFile(), JSON.stringify(next, null, 2) + "\n");
+  return next;
+}
+function resolveServer(cfg = loadConfig()) {
+  return (process.env.LATENTCODE_ADS_SERVER || cfg.server || process.env.ADS_SERVER || DEFAULT_SERVER).replace(/\/+$/, "");
+}
+function resolveWallet(cfg = loadConfig()) {
+  const w = cfg.wallet || process.env.ADS_WALLET || "";
+  return WALLET_RE.test(w) ? w : "";
+}
+function adsEnabled(cfg = loadConfig(), key = "latentcode_ads") {
+  const env = process.env.ADS_ENABLED;
+  if (env !== void 0) return !["false", "0", "no"].includes(env.toLowerCase());
+  return cfg[key] !== false;
+}
+function deviceId() {
+  try {
+    const existing = readFileSync2(deviceIdFile(), "utf8").trim();
+    if (DEVICE_CREDENTIAL_RE.test(existing)) return existing;
+  } catch {
+  }
+  return "";
+}
+async function ensureDeviceCredential(server) {
+  const current = deviceId();
+  if (current) return current;
+  let credential = "";
+  try {
+    const res = await fetch(`${server}/device/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: "{}",
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!res.ok) return "";
+    credential = ((await res.json()).credential || "").trim();
+  } catch {
+    return "";
+  }
+  if (!DEVICE_CREDENTIAL_RE.test(credential)) return "";
+  try {
+    mkdirSync(configDir(), { recursive: true });
+    writeFileSync(deviceIdFile(), credential, { flag: "wx" });
+    return credential;
+  } catch {
+    return deviceId() || credential;
+  }
+}
+
+// ../src/ads/killswitch.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+var KILL_TTL_MS = 5 * 6e4;
+var KILL_STALE_GRACE_MS = 60 * 6e4;
+var KILL_SOFT_GRACE_MS = 10 * 6e4;
+var GUARD_TRIP_AFTER = 5;
+var GUARD_COOLDOWN_MS = 10 * 6e4;
+function healthFile() {
+  return join3(configDir(), "latentcode-health.json");
+}
+function load() {
+  try {
+    const s = JSON.parse(readFileSync3(healthFile(), "utf8"));
+    return s.server === resolveServer() ? s : {};
+  } catch {
+    return {};
+  }
+}
+function save(s) {
+  try {
+    mkdirSync2(configDir(), { recursive: true });
+    writeFileSync2(healthFile(), JSON.stringify({ ...s, server: resolveServer() }));
+  } catch {
+  }
+}
+function shouldServe(now = Date.now(), state = load()) {
+  if (state.killed && state.killCheckedAt !== void 0) {
+    const grace = KILL_TTL_MS + (state.killKind === "unreachable" ? KILL_SOFT_GRACE_MS : KILL_STALE_GRACE_MS);
+    if (now - state.killCheckedAt < grace) return { ok: false, reason: "killswitch" };
+  }
+  if (state.guardOpenUntil !== void 0 && now < state.guardOpenUntil) {
+    return { ok: false, reason: "incident-backoff" };
+  }
+  return { ok: true };
+}
+async function refreshKillswitch(server = resolveServer(), now = Date.now()) {
+  const s = load();
+  if (s.killCheckedAt !== void 0 && now - s.killCheckedAt < KILL_TTL_MS) return;
+  const failSafe = (reason) => save({ ...s, killCheckedAt: now, killed: true, killKind: "unreachable", killReason: reason });
+  try {
+    const res = await fetch(`${server.replace(/\/+$/, "")}/killswitch`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (res.status === 404) {
+      save({ ...s, killCheckedAt: now, killed: false, killKind: void 0, killReason: void 0 });
+      return;
+    }
+    if (!res.ok) {
+      failSafe(`server ${res.status}`);
+      return;
+    }
+    const j = await res.json();
+    save({
+      ...s,
+      killCheckedAt: now,
+      killed: Boolean(j.killed),
+      killKind: j.killed ? "explicit" : void 0,
+      killReason: j.reason
+    });
+  } catch {
+    failSafe("server-unreachable");
+  }
+}
+function recordServerResult(ok, now = Date.now()) {
+  const s = load();
+  if (ok) {
+    if (s.consecutiveFailures || s.guardOpenUntil !== void 0) {
+      save({ ...s, consecutiveFailures: 0, guardOpenUntil: void 0 });
+    }
+    return;
+  }
+  const n = (s.consecutiveFailures ?? 0) + 1;
+  const next = { ...s, consecutiveFailures: n };
+  if (n >= GUARD_TRIP_AFTER) next.guardOpenUntil = now + GUARD_COOLDOWN_MS;
+  save(next);
+}
+
+// ../src/ads/api.ts
+var SURFACE_WORKING_BAR = "status_line";
+function httpAdApi(server = resolveServer(), identity = {}) {
+  const agent = identity.agent ?? AGENT_LATENTCODE;
+  const surface = identity.surface ?? SURFACE_WORKING_BAR;
+  return {
+    server,
+    async request({ wallet, context, sessionId }) {
+      void refreshKillswitch(server);
+      if (!shouldServe().ok) return null;
+      const device = await ensureDeviceCredential(server);
+      try {
+        const res = await fetch(`${server}/ad/request`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            user_wallet: wallet,
+            agent,
+            context: context.slice(0, 100),
+            surface,
+            tags: context ? [context] : [],
+            session_id: sessionId,
+            device_id: device
+          }),
+          signal: AbortSignal.timeout(2e3)
+        });
+        recordServerResult(res.status < 500);
+        if (res.status !== 200) return null;
+        const ad = await res.json();
+        return ad && typeof ad.ad_id === "string" ? ad : null;
+      } catch {
+        recordServerResult(false);
+        return null;
+      }
+    },
+    async impression({ ad, wallet, context, displayedMs, focusTracked, eventUuid }) {
+      if (!shouldServe().ok) return "error";
+      const device = await ensureDeviceCredential(server);
+      try {
+        const res = await fetch(`${server}/ad/impression`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            ad_id: ad.ad_id,
+            user_wallet: wallet,
+            token: ad.impression_token ?? "",
+            agent,
+            surface,
+            context,
+            device_id: device,
+            event_uuid: eventUuid,
+            displayed_ms: Math.round(displayedMs),
+            // Attention signal: the dwell above was measured with real terminal
+            // focus events, not assumed. Servers that don't know it ignore it.
+            focus_tracked: focusTracked
+          }),
+          signal: AbortSignal.timeout(2e3)
+        });
+        recordServerResult(res.status < 500);
+        if (!res.ok) return "error";
+        const status = (await res.json().catch(() => ({}))).status;
+        return status === "tracked" || status === "skipped" || status === "unearned" ? status : "error";
+      } catch {
+        recordServerResult(false);
+        return "error";
+      }
+    },
+    async balance(wallet) {
+      try {
+        const res = await fetch(`${server}/earnings/${wallet}`, { signal: AbortSignal.timeout(4e3) });
+        if (!res.ok) return null;
+        return Number((await res.json()).balance ?? 0);
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+
+// ../src/ads/attention.ts
+var FOCUS_IN = "\x1B[I";
+var FOCUS_OUT = "\x1B[O";
+var FocusTracker = class {
+  /** True once the terminal has sent at least one focus event. */
+  known = false;
+  focusedNow = true;
+  listeners = /* @__PURE__ */ new Set();
+  get focused() {
+    return this.focusedNow;
+  }
+  onChange(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  set(focused) {
+    this.known = true;
+    if (focused === this.focusedNow) return;
+    this.focusedNow = focused;
+    for (const fn of this.listeners) fn(focused);
+  }
+  /**
+   * Consume focus sequences from a raw stdin chunk and return the rest, so the
+   * UI never sees them as keystrokes.
+   */
+  filter(chunk) {
+    if (!chunk.includes("\x1B[")) return chunk;
+    let out = "";
+    let i = 0;
+    while (i < chunk.length) {
+      if (chunk.startsWith(FOCUS_IN, i)) {
+        this.set(true);
+        i += FOCUS_IN.length;
+      } else if (chunk.startsWith(FOCUS_OUT, i)) {
+        this.set(false);
+        i += FOCUS_OUT.length;
+      } else {
+        out += chunk[i];
+        i += 1;
+      }
+    }
+    return out;
+  }
+};
+
+// ../src/account/privy.ts
+function trimServer(server) {
+  return server.replace(/\/+$/, "");
+}
+async function readJson(res) {
+  try {
+    return await res.json();
+  } catch {
+    return { detail: await res.text().catch(() => `HTTP ${res.status}`) };
+  }
+}
+async function fetchAuthConfig(server, fetchImpl = fetch) {
+  const res = await fetchImpl(`${trimServer(server)}/auth/config`);
+  const body = await readJson(res);
+  if (!res.ok) {
+    throw new Error(
+      typeof body.detail === "string" ? body.detail : `auth config HTTP ${res.status}`
+    );
+  }
+  if (!body.privy_app_id) {
+    throw new Error(
+      "Privy is not configured on the ad server (PRIVY_APP_ID). Use `latentcode login --wallet 0x\u2026` instead."
+    );
+  }
+  return {
+    privy_app_id: String(body.privy_app_id),
+    authorize_url: String(body.authorize_url || "https://www.latentprotocol.xyz/authorize"),
+    configured: Boolean(body.configured)
+  };
+}
+async function startDeviceAuth(appId, fetchImpl = fetch) {
+  const res = await fetchImpl("https://auth.privy.io/api/oauth/v2/device_authorization", {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "privy-app-id": appId },
+    body: "{}"
+  });
+  const body = await readJson(res);
+  if (!res.ok) {
+    if (body.error === "device_auth_not_enabled" || /device authorization is not enabled/i.test(String(body.error || ""))) {
+      throw new Error(
+        "Privy CLI/agent access is off. Enable it in the Privy Dashboard (Authentication \u2192 Advanced) or use `latentcode login --wallet 0x\u2026`."
+      );
+    }
+    if (res.status === 403) {
+      throw new Error(
+        "auth.privy.io refused the request (403). If you are behind a proxy or VPN, that is the likely cause; otherwise check that CLI/agent access is on in the Privy Dashboard. Or use `latentcode login --wallet 0x\u2026`."
+      );
+    }
+    throw new Error(`device_authorization HTTP ${res.status}`);
+  }
+  if (!body.device_code || !body.user_code) {
+    throw new Error("device_authorization returned no codes");
+  }
+  return {
+    device_code: String(body.device_code),
+    user_code: String(body.user_code),
+    verification_uri: String(body.verification_uri || ""),
+    verification_uri_complete: String(
+      body.verification_uri_complete || `${body.verification_uri}?user_code=${body.user_code}`
+    ),
+    expires_in: Number(body.expires_in || 600),
+    interval: Math.max(1, Number(body.interval || 5))
+  };
+}
+async function pollDeviceToken(appId, deviceCode, opts) {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const now = opts.now ?? Date.now;
+  const deadline = now() + opts.expiresInSec * 1e3;
+  let interval = opts.intervalSec;
+  while (now() < deadline) {
+    await sleep(interval * 1e3);
+    const res = await fetchImpl("https://auth.privy.io/api/oauth/v2/token", {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "privy-app-id": appId },
+      body: JSON.stringify({
+        // RFC 8628 §3.4 — Privy rejects the bare "device_code" with a 400.
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: deviceCode
+      })
+    });
+    const body = await readJson(res);
+    if (res.ok && body.access_token) {
+      return {
+        access_token: body.access_token,
+        refresh_token: body.refresh_token,
+        expires_in: body.expires_in
+      };
+    }
+    const err = String(body.error || "");
+    if (err === "authorization_pending") continue;
+    if (err === "slow_down") {
+      interval += 5;
+      continue;
+    }
+    if (err === "expired_token") throw new Error("Auth link expired \u2014 run `latentcode login` again.");
+    if (err === "access_denied") throw new Error("Authorization denied in the browser.");
+    if (!res.ok && !err) throw new Error(`token HTTP ${res.status}`);
+    throw new Error(err || `token HTTP ${res.status}`);
+  }
+  throw new Error("Auth link timed out \u2014 run `latentcode login` again.");
+}
+async function resolveSession(server, accessToken, fetchImpl = fetch) {
+  const res = await fetchImpl(`${trimServer(server)}/auth/session`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ access_token: accessToken })
+  });
+  const body = await readJson(res);
+  if (!res.ok) {
+    throw new Error(typeof body.detail === "string" ? body.detail : `session HTTP ${res.status}`);
+  }
+  if (!body.wallet || !body.privy_user_id) {
+    throw new Error("session returned no wallet");
+  }
+  return { wallet: body.wallet, privy_user_id: body.privy_user_id };
+}
+
+// ../src/account/login.ts
+function short(w) {
+  return `${w.slice(0, 6)}\u2026${w.slice(-4)}`;
+}
+async function loginWithAddress(address, deps) {
+  if (!WALLET_RE.test(address)) throw new Error(`Not an EVM address: ${address}`);
+  const prev = deps.load().wallet;
+  deps.save({ wallet: address, auth: "address", privy_user_id: void 0 });
+  deps.log(`Wallet set: ${short(address)}`);
+  return { wallet: address, method: "address", replaced: prev && prev !== address ? prev : void 0 };
+}
+async function loginWithAuthLink(deps) {
+  let cfg;
+  try {
+    cfg = await fetchAuthConfig(deps.server, deps.fetchImpl);
+  } catch (e) {
+    const why = e instanceof Error ? e.message : String(e);
+    throw new Error(
+      `Sign-in is unavailable on ${deps.server.replace(/\/+$/, "")} (${why}).
+You can still connect an address you control: latentcode login --wallet 0x\u2026`
+    );
+  }
+  const start = await startDeviceAuth(cfg.privy_app_id, deps.fetchImpl);
+  deps.log("Open this link to sign in and connect your Latent wallet:");
+  deps.log(`  ${start.verification_uri_complete}`);
+  deps.log(`Code: ${start.user_code}`);
+  deps.onLink?.({ url: start.verification_uri_complete, code: start.user_code });
+  deps.open(start.verification_uri_complete);
+  deps.log("Waiting for the browser\u2026");
+  const tokens = await pollDeviceToken(cfg.privy_app_id, start.device_code, {
+    intervalSec: start.interval,
+    expiresInSec: start.expires_in,
+    fetchImpl: deps.fetchImpl,
+    sleep: deps.sleep,
+    now: deps.now
+  });
+  const earner = await resolveSession(deps.server, tokens.access_token, deps.fetchImpl);
+  if (!WALLET_RE.test(earner.wallet)) throw new Error("The server returned an invalid wallet address.");
+  const prev = deps.load().wallet;
+  deps.save({ wallet: earner.wallet, privy_user_id: earner.privy_user_id, auth: "privy" });
+  deps.log(`Signed in. Earn mode pays into ${short(earner.wallet)}.`);
+  return { wallet: earner.wallet, method: "privy", replaced: prev && prev !== earner.wallet ? prev : void 0 };
+}
+
+// ../src/util/open.ts
+import { spawn } from "node:child_process";
+function openUrl(url) {
+  const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer" : "xdg-open";
+  try {
+    const child = spawn(opener, [url], { detached: true, stdio: "ignore" });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+
+// src/runtime.ts
+var AGENT_OPENCODE = "opencode";
+export {
+  AGENT_OPENCODE,
+  AdController,
+  FocusTracker,
+  adBadge,
+  adsEnabled,
+  httpAdApi,
+  loadConfig,
+  loginWithAddress,
+  loginWithAuthLink,
+  openUrl,
+  resolveServer,
+  resolveWallet,
+  saveConfig
+};

package/dist/tui.js

@@ -0,0 +1,225 @@
+import { effect as _$effect } from "@opentui/solid";
+import { memo as _$memo } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+/**
+ * Latent for OpenCode — a TUI-only plugin.
+ *
+ * One labelled sponsored line in the prompt footer while the agent works,
+ * billed by the same AdController as LatentCode (10 s view floor, one
+ * impression per ad, tracked clicks, kill switch). It only draws in the
+ * terminal: nothing here reads or rewrites the model's request or reply, and
+ * only the local classifier's slug leaves the machine.
+ *
+ *   opencode plugin add latent-opencode
+ *   /latent        status, wallet, on/off
+ *   /latent-login  connect the wallet Earn pays into (shared ~/.latent-protocol)
+ *   /latent-open   open the sponsored link (tracked redirect)
+ */
+import { Plugin } from "@opencode/plugin/tui";
+import { createSignal } from "solid-js";
+import { randomUUID } from "node:crypto";
+import { AGENT_OPENCODE, AdController, FocusTracker, adBadge, adsEnabled, httpAdApi, loadConfig, loginWithAuthLink, openUrl, resolveServer, resolveWallet, saveConfig } from "./runtime.js";
+const TICK_MS = 250;
+const EXECUTION_END = ["succeeded", "failed", "interrupted"];
+function short(w) {
+  return `${w.slice(0, 6)}…${w.slice(-4)}`;
+}
+
+/** The session id of an execution event, whatever envelope the host passes. */
+function sessionOf(e) {
+  return e?.data?.sessionID ?? e?.details?.data?.sessionID ?? e?.sessionID ?? "default";
+}
+export default Plugin.define({
+  id: "latent.ads",
+  setup(context) {
+    const server = resolveServer();
+    const api = httpAdApi(server, {
+      agent: AGENT_OPENCODE
+    });
+    const cfg = loadConfig();
+    const controller = new AdController({
+      api,
+      wallet: resolveWallet(cfg),
+      enabled: adsEnabled(cfg, "opencode_ads"),
+      sessionId: randomUUID(),
+      // A plugin does not own stdin, so terminal focus is unknown: dwell counts
+      // as focused and impressions say focus_tracked=false.
+      focus: new FocusTracker(),
+      cwd: context.location?.directory
+    });
+    const [snap, setSnap] = createSignal(controller.snapshot());
+    const unsubscribe = controller.subscribe(() => setSnap(controller.snapshot()));
+    const timer = setInterval(() => controller.tick(), TICK_MS);
+
+    // Working = at least one session executing.
+    const running = new Set();
+    const sync = () => controller.setWorking(running.size > 0);
+    const offs = [context.data.on("session.execution.started", e => {
+      running.add(sessionOf(e));
+      sync();
+    }), ...EXECUTION_END.map(k => context.data.on(`session.execution.${k}`, e => {
+      running.delete(sessionOf(e));
+      sync();
+    }))];
+    const t = context.theme;
+    const muted = t?.text?.muted ?? t?.text?.base;
+    const sponsoredLine = () => {
+      const s = snap();
+      if (s.status === "no-wallet") return (() => {
+        var _el$ = _$createElement("text");
+        _$insertNode(_el$, _$createTextNode(`◆ Latent: /latent-login to earn while you wait`));
+        _$setProp(_el$, "fg", muted);
+        return _el$;
+      })();
+      const ad = s.current;
+      if (s.status !== "ok" || !ad) return null;
+      const badge = adBadge(ad.title || ad.body);
+      return (() => {
+        var _el$3 = _$createElement("text"),
+          _el$4 = _$createTextNode(`◆ Sponsored │ `),
+          _el$5 = _$createElement("span"),
+          _el$6 = _$createTextNode(` `);
+        _$insertNode(_el$3, _el$4);
+        _$insertNode(_el$3, _el$5);
+        _$insertNode(_el$3, _el$6);
+        _$setProp(_el$3, "fg", muted);
+        _$insert(_el$5, () => ` ${badge.letter} `);
+        _$insert(_el$3, () => ad.title || ad.body, null);
+        _$insert(_el$3, (() => {
+          var _c$ = _$memo(() => !!(ad.title && ad.body));
+          return () => _c$() ? ` — ${ad.body}` : "";
+        })(), null);
+        _$insert(_el$3, (() => {
+          var _c$2 = _$memo(() => !!ad.shownUrl);
+          return () => _c$2() ? ` · ${ad.shownUrl}` : "";
+        })(), null);
+        _$insert(_el$3, (() => {
+          var _c$3 = _$memo(() => !!ad.link);
+          return () => _c$3() ? ` · /latent-open ${ad.ctaText}` : "";
+        })(), null);
+        _$insert(_el$3, (() => {
+          var _c$4 = _$memo(() => !!(s.billed && ad.earn > 0));
+          return () => _c$4() ? `  +$${ad.earn.toFixed(4)}` : "";
+        })(), null);
+        _$effect(_$p => _$setProp(_el$5, "style", {
+          bg: badge.color,
+          fg: "#111827"
+        }, _$p));
+        return _el$3;
+      })();
+    };
+    // Called inside a JSX expression so Solid re-runs it whenever the snapshot changes
+    // (a component body would run once and never update).
+    const unslot = context.ui.slot({
+      append: "prompt.footer.status",
+      render: () => _$memo(sponsoredLine)
+    });
+    let loggingIn = false;
+    const login = async () => {
+      if (loggingIn) return;
+      loggingIn = true;
+      try {
+        const result = await loginWithAuthLink({
+          server,
+          log: () => {},
+          onLink: ({
+            url,
+            code
+          }) => {
+            void context.ui.dialog.alert({
+              title: "Latent login",
+              message: `Open ${url}\nCode: ${code}`
+            });
+          },
+          open: openUrl,
+          load: loadConfig,
+          save: patch => void saveConfig(patch)
+        });
+        context.ui.dialog.clear();
+        controller.setWallet(result.wallet);
+        context.ui.toast.show({
+          title: "Latent",
+          message: `Earning into ${short(result.wallet)}`,
+          variant: "success"
+        });
+      } catch (e) {
+        context.ui.toast.show({
+          title: "Latent",
+          message: e instanceof Error ? e.message : String(e),
+          variant: "error"
+        });
+      } finally {
+        loggingIn = false;
+      }
+    };
+    const status = async () => {
+      const s = controller.snapshot();
+      const wallet = resolveWallet(loadConfig());
+      const balance = wallet ? await api.balance(wallet) : null;
+      const choice = await context.ui.dialog.select({
+        title: wallet ? `Latent — ${short(wallet)}${balance !== null ? ` · $${balance.toFixed(4)}` : ""}` : "Latent — no wallet",
+        options: [{
+          title: `Sponsored line: ${s.status === "disabled" ? "off" : "on"}`,
+          value: "toggle",
+          description: `${s.impressions} paid views this session`
+        }, {
+          title: wallet ? "Switch wallet" : "Connect wallet",
+          value: "login"
+        }]
+      });
+      if (choice === "toggle") {
+        const on = s.status === "disabled";
+        saveConfig({
+          opencode_ads: on
+        });
+        controller.setEnabled(on);
+      } else if (choice === "login") void login();
+    };
+    context.keymap.layer(() => ({
+      mode: "global",
+      commands: [{
+        id: "latent.status",
+        title: "Latent: status / on-off",
+        group: "Latent",
+        palette: true,
+        slash: {
+          name: "latent"
+        },
+        run: () => void status()
+      }, {
+        id: "latent.login",
+        title: "Latent: connect wallet",
+        group: "Latent",
+        palette: true,
+        slash: {
+          name: "latent-login"
+        },
+        run: () => void login()
+      }, {
+        id: "latent.open",
+        title: "Latent: open sponsored link",
+        group: "Latent",
+        palette: true,
+        slash: {
+          name: "latent-open"
+        },
+        run: () => {
+          const link = controller.click();
+          if (link) openUrl(link);else context.ui.toast.show({
+            message: "No sponsored line on screen"
+          });
+        }
+      }]
+    }));
+    return () => {
+      clearInterval(timer);
+      unsubscribe();
+      offs.forEach(off => off());
+      unslot?.();
+    };
+  }
+});

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "latent-opencode",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-alpha.1",
+  "description": "Earn from one labelled sponsored line in your own OpenCode terminal UI. Never reads or changes the model's request or reply.",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    "./tui": "./dist/tui.js"
+  },
+  "files": [
+    "dist/tui.js",
+    "dist/runtime.js",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@opencode/plugin": "^2.2.0"
+  },
+  "peerDependencies": {
+    "@opentui/core": ">=0.6.6",
+    "@opentui/solid": ">=0.6.6",
+    "solid-js": ">=1.9.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/enzoonchain/latentcode.git",
+    "directory": "opencode-plugin"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "latent"
+  ]
+}