@cortexkit/aft-opencode 0.9.1 → 0.11.0

package/src/shared/rpc-server.ts

@@ -0,0 +1,135 @@
+import { mkdirSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import { dirname } from "node:path";
+import { log, warn } from "../logger.js";
+import { rpcPortFilePath } from "./rpc-utils.js";
+
+type RpcHandler = (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
+
+export class AftRpcServer {
+  private server: Server | null = null;
+  private port = 0;
+  private handlers = new Map<string, RpcHandler>();
+  private portFilePath: string;
+
+  constructor(storageDir: string, directory: string) {
+    this.portFilePath = rpcPortFilePath(storageDir, directory);
+  }
+
+  /** Register an RPC method handler. */
+  handle(method: string, handler: RpcHandler): void {
+    this.handlers.set(method, handler);
+  }
+
+  /** Start the server on a random port, write port to disk. */
+  async start(): Promise<number> {
+    return new Promise((resolve, reject) => {
+      const server = createServer((req, res) => this.dispatch(req, res));
+
+      server.on("error", (err) => {
+        warn(`RPC server error: ${err.message}`);
+        reject(err);
+      });
+
+      server.listen(0, "127.0.0.1", () => {
+        const addr = server.address();
+        if (!addr || typeof addr === "string") {
+          reject(new Error("Failed to get server address"));
+          return;
+        }
+        this.port = addr.port;
+        this.server = server;
+
+        // Write port file atomically
+        try {
+          const dir = dirname(this.portFilePath);
+          mkdirSync(dir, { recursive: true });
+          const tmpPath = `${this.portFilePath}.tmp`;
+          writeFileSync(tmpPath, String(this.port), "utf-8");
+          renameSync(tmpPath, this.portFilePath);
+          log(`RPC server listening on 127.0.0.1:${this.port}`);
+        } catch (err) {
+          warn(`Failed to write RPC port file: ${err}`);
+        }
+
+        resolve(this.port);
+      });
+
+      // Don't keep the process alive just for the RPC server
+      server.unref();
+    });
+  }
+
+  /** Stop the server and clean up port file. */
+  stop(): void {
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+    try {
+      unlinkSync(this.portFilePath);
+    } catch {
+      // ignore
+    }
+  }
+
+  private dispatch(req: IncomingMessage, res: ServerResponse): void {
+    const url = req.url ?? "";
+
+    if (req.method === "GET" && url === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true, pid: process.pid }));
+      return;
+    }
+
+    if (req.method !== "POST" || !url.startsWith("/rpc/")) {
+      res.writeHead(404);
+      res.end("Not Found");
+      return;
+    }
+
+    const method = url.slice(5);
+    const handler = this.handlers.get(method);
+    if (!handler) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: `Unknown method: ${method}` }));
+      return;
+    }
+
+    let body = "";
+    req.on("data", (chunk: Buffer) => {
+      body += chunk.toString();
+      if (body.length > 1_048_576) {
+        res.writeHead(413);
+        res.end("Request too large");
+        req.destroy();
+      }
+    });
+
+    req.on("end", () => {
+      let params: Record<string, unknown> = {};
+      try {
+        if (body.length > 0) {
+          params = JSON.parse(body);
+        }
+      } catch {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid JSON" }));
+        return;
+      }
+
+      log(`RPC call: ${method} params=${JSON.stringify(params).slice(0, 200)}`);
+      handler(params)
+        .then((result) => {
+          log(`RPC result: ${method} => ${JSON.stringify(result).slice(0, 200)}`);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(result));
+        })
+        .catch((err) => {
+          log(`RPC error: ${method} => ${err}`);
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: String(err) }));
+        });
+    });
+  }
+}

package/src/shared/rpc-utils.ts

@@ -0,0 +1,21 @@
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+
+/**
+ * Compute a stable hash for a project directory.
+ * Used to scope RPC port files per-project so multiple
+ * OpenCode Desktop instances don't overwrite each other.
+ */
+export function projectHash(directory: string): string {
+  // Normalize: strip trailing slashes
+  const normalized = directory.replace(/\/+$/, "");
+  return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+
+/**
+ * Get the per-project RPC port file path.
+ */
+export function rpcPortFilePath(storageDir: string, directory: string): string {
+  const hash = projectHash(directory);
+  return join(storageDir, "rpc", hash, "port");
+}

package/src/shared/runtime.ts

@@ -0,0 +1,26 @@
+type BridgeLike = {
+  getBridge: (
+    directory: string,
+    sessionID: string,
+  ) => {
+    send: (command: string, params?: Record<string, unknown>) => Promise<Record<string, unknown>>;
+  };
+};
+
+const GLOBAL_KEY = "__AFT_SHARED_BRIDGE_POOL__";
+
+function getGlobalState(): { [GLOBAL_KEY]?: BridgeLike | null } {
+  return globalThis as { [GLOBAL_KEY]?: BridgeLike | null };
+}
+
+export function setSharedBridgePool(pool: BridgeLike): void {
+  getGlobalState()[GLOBAL_KEY] = pool;
+}
+
+export function getSharedBridgePool(): BridgeLike | null {
+  return getGlobalState()[GLOBAL_KEY] ?? null;
+}
+
+export function clearSharedBridgePool(): void {
+  getGlobalState()[GLOBAL_KEY] = null;
+}

package/src/shared/status.ts

@@ -0,0 +1,206 @@
+export interface AftStatusSnapshot {
+  version: string;
+  project_root: string | null;
+  features: {
+    format_on_edit: boolean;
+    validate_on_edit: string;
+    restrict_to_project_root: boolean;
+    experimental_search_index: boolean;
+    experimental_semantic_search: boolean;
+  };
+  search_index: {
+    status: string;
+    files: number | null;
+    trigrams: number | null;
+  };
+  semantic_index: {
+    status: string;
+    entries: number | null;
+    dimension: number | null;
+  };
+  disk: {
+    storage_dir: string | null;
+    trigram_disk_bytes: number;
+    semantic_disk_bytes: number;
+  };
+  lsp_servers: number;
+  symbol_cache: {
+    local_entries: number;
+    warm_entries: number;
+  };
+  storage_dir: string | null;
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : {};
+}
+
+function readString(value: unknown, fallback = ""): string {
+  return typeof value === "string" ? value : fallback;
+}
+
+function readNullableString(value: unknown): string | null {
+  return typeof value === "string" ? value : null;
+}
+
+function readBoolean(value: unknown, fallback = false): boolean {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+function readNumber(value: unknown, fallback = 0): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+function readOptionalNumber(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+function formatFlag(enabled: boolean): string {
+  return enabled ? "enabled" : "disabled";
+}
+
+function formatCount(value: number | null): string {
+  return value == null ? "—" : value.toLocaleString("en-US");
+}
+
+export function formatBytes(bytes: number): string {
+  if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value = bytes;
+  let unitIndex = 0;
+
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex++;
+  }
+
+  const decimals = value >= 10 || unitIndex === 0 ? 0 : 1;
+  return `${value.toFixed(decimals)} ${units[unitIndex]}`;
+}
+
+export function coerceAftStatus(response: Record<string, unknown>): AftStatusSnapshot {
+  const features = asRecord(response.features);
+  const searchIndex = asRecord(response.search_index);
+  const semanticIndex = asRecord(response.semantic_index);
+  const disk = asRecord(response.disk);
+  const symbolCache = asRecord(response.symbol_cache);
+
+  return {
+    version: readString(response.version, "unknown"),
+    project_root: readNullableString(response.project_root),
+    features: {
+      format_on_edit: readBoolean(features.format_on_edit),
+      validate_on_edit: readString(features.validate_on_edit, "off"),
+      restrict_to_project_root: readBoolean(features.restrict_to_project_root),
+      experimental_search_index: readBoolean(features.experimental_search_index),
+      experimental_semantic_search: readBoolean(features.experimental_semantic_search),
+    },
+    search_index: {
+      status: readString(searchIndex.status, "unknown"),
+      files: readOptionalNumber(searchIndex.files),
+      trigrams: readOptionalNumber(searchIndex.trigrams),
+    },
+    semantic_index: {
+      status: readString(semanticIndex.status, "unknown"),
+      entries: readOptionalNumber(semanticIndex.entries),
+      dimension: readOptionalNumber(semanticIndex.dimension),
+    },
+    disk: {
+      storage_dir: readNullableString(disk.storage_dir),
+      trigram_disk_bytes: readNumber(disk.trigram_disk_bytes),
+      semantic_disk_bytes: readNumber(disk.semantic_disk_bytes),
+    },
+    lsp_servers: readNumber(response.lsp_servers),
+    symbol_cache: {
+      local_entries: readNumber(symbolCache.local_entries),
+      warm_entries: readNumber(symbolCache.warm_entries),
+    },
+    storage_dir: readNullableString(response.storage_dir),
+  };
+}
+
+export function formatStatusDialogMessage(status: AftStatusSnapshot): string {
+  const lines = [
+    `AFT version: ${status.version}`,
+    `Project root: ${status.project_root ?? "(not configured)"}`,
+    "",
+    "Enabled features",
+    `- format_on_edit: ${formatFlag(status.features.format_on_edit)}`,
+    `- experimental_search_index: ${formatFlag(status.features.experimental_search_index)}`,
+    `- experimental_semantic_search: ${formatFlag(status.features.experimental_semantic_search)}`,
+    "",
+    "Search index",
+    `- status: ${status.search_index.status}`,
+    `- files: ${formatCount(status.search_index.files)}`,
+    `- trigrams: ${formatCount(status.search_index.trigrams)}`,
+    "",
+    "Semantic index",
+    `- status: ${status.semantic_index.status}`,
+    `- entries: ${formatCount(status.semantic_index.entries)}`,
+  ];
+
+  if (status.semantic_index.dimension != null) {
+    lines.push(`- dimension: ${formatCount(status.semantic_index.dimension)}`);
+  }
+
+  lines.push(
+    "",
+    "Disk usage",
+    `- trigram index: ${formatBytes(status.disk.trigram_disk_bytes)}`,
+    `- semantic index: ${formatBytes(status.disk.semantic_disk_bytes)}`,
+    "",
+    "Runtime",
+    `- LSP servers: ${formatCount(status.lsp_servers)}`,
+    `- symbol cache: ${formatCount(status.symbol_cache.local_entries)} local / ${formatCount(status.symbol_cache.warm_entries)} warm`,
+  );
+
+  if (status.storage_dir ?? status.disk.storage_dir) {
+    lines.push(`- storage dir: ${status.storage_dir ?? status.disk.storage_dir}`);
+  }
+
+  return lines.join("\n");
+}
+
+export function formatStatusMarkdown(status: AftStatusSnapshot): string {
+  const lines = [
+    "## AFT Status",
+    "",
+    `- **Version:** \`${status.version}\``,
+    `- **Project root:** \`${status.project_root ?? "(not configured)"}\``,
+    "",
+    "### Enabled features",
+    `- \`format_on_edit\`: ${formatFlag(status.features.format_on_edit)}`,
+    `- \`experimental_search_index\`: ${formatFlag(status.features.experimental_search_index)}`,
+    `- \`experimental_semantic_search\`: ${formatFlag(status.features.experimental_semantic_search)}`,
+    "",
+    "### Search index",
+    `- **Status:** \`${status.search_index.status}\``,
+    `- **Files:** ${formatCount(status.search_index.files)}`,
+    `- **Trigrams:** ${formatCount(status.search_index.trigrams)}`,
+    "",
+    "### Semantic index",
+    `- **Status:** \`${status.semantic_index.status}\``,
+    `- **Entries:** ${formatCount(status.semantic_index.entries)}`,
+  ];
+
+  if (status.semantic_index.dimension != null) {
+    lines.push(`- **Dimension:** ${formatCount(status.semantic_index.dimension)}`);
+  }
+
+  lines.push(
+    "",
+    "### Disk usage",
+    `- **Trigram index:** ${formatBytes(status.disk.trigram_disk_bytes)}`,
+    `- **Semantic index:** ${formatBytes(status.disk.semantic_disk_bytes)}`,
+    "",
+    "### Runtime",
+    `- **LSP servers:** ${formatCount(status.lsp_servers)}`,
+    `- **Symbol cache:** ${formatCount(status.symbol_cache.local_entries)} local / ${formatCount(status.symbol_cache.warm_entries)} warm`,
+  );
+
+  if (status.storage_dir ?? status.disk.storage_dir) {
+    lines.push(`- **Storage dir:** \`${status.storage_dir ?? status.disk.storage_dir}\``);
+  }
+
+  return lines.join("\n");
+}

package/src/shared/tui-config.ts

@@ -0,0 +1,58 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parse, stringify } from "comment-json";
+import { log } from "../logger.js";
+import { getOpenCodeConfigPaths } from "./opencode-config-dir.js";
+
+const PLUGIN_NAME = "@cortexkit/aft-opencode";
+const PLUGIN_ENTRY = `${PLUGIN_NAME}@latest`;
+
+function resolveTuiConfigPath(): string {
+  const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
+  const jsoncPath = join(configDir, "tui.jsonc");
+  const jsonPath = join(configDir, "tui.json");
+
+  if (existsSync(jsoncPath)) return jsoncPath;
+  if (existsSync(jsonPath)) return jsonPath;
+  return jsonPath;
+}
+
+export function ensureTuiPluginEntry(): boolean {
+  try {
+    const configPath = resolveTuiConfigPath();
+
+    let config: Record<string, unknown> = {};
+    if (existsSync(configPath)) {
+      config = (parse(readFileSync(configPath, "utf-8")) as Record<string, unknown>) ?? {};
+    }
+
+    const plugins = Array.isArray(config.plugin)
+      ? config.plugin.filter((value): value is string => typeof value === "string")
+      : [];
+
+    if (
+      plugins.some(
+        (plugin) =>
+          plugin === PLUGIN_NAME ||
+          plugin.startsWith(`${PLUGIN_NAME}@`) ||
+          plugin.includes("opencode-plugin") ||
+          plugin.includes("aft-opencode"),
+      )
+    ) {
+      return false;
+    }
+
+    plugins.push(PLUGIN_ENTRY);
+    config.plugin = plugins;
+
+    mkdirSync(dirname(configPath), { recursive: true });
+    writeFileSync(configPath, `${stringify(config, null, 2)}\n`);
+    log(`[aft-plugin] added TUI plugin entry to ${configPath}`);
+    return true;
+  } catch (error) {
+    log(
+      `[aft-plugin] failed to update tui.json: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    return false;
+  }
+}

package/src/shared/url-fetch.ts

@@ -0,0 +1,237 @@
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { log, warn } from "../logger.js";
+
+/** 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;
+
+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}`);
+}
+
+/**
+ * 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): 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 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 controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  let response: Response;
+  try {
+    response = await fetch(url, {
+      signal: controller.signal,
+      redirect: "follow",
+      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 ${url}: ${(err as Error).message}`);
+  } finally {
+    clearTimeout(timer);
+  }
+
+  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`);
+  }
+}