@cortexkit/aft-opencode 0.12.1 → 0.13.0

package/src/shared/rpc-client.ts

@@ -0,0 +1,123 @@
+import { readFileSync } from "node:fs";
+import { rpcPortFilePath } from "./rpc-utils";
+
+const MAX_RETRIES = 10;
+const RETRY_DELAY_MS = 500;
+const REQUEST_TIMEOUT_MS = 5000;
+
+export class AftRpcClient {
+  private port: number | null = null;
+  private portFilePath: string;
+  private healthChecked = false;
+
+  constructor(storageDir: string, directory: string) {
+    this.portFilePath = rpcPortFilePath(storageDir, directory);
+  }
+
+  /** Call an RPC method. Retries port resolution if the server isn't ready yet. */
+  async call<T = Record<string, unknown>>(
+    method: string,
+    params: Record<string, unknown> = {},
+  ): Promise<T> {
+    const port = await this.resolvePort();
+    if (!port) {
+      throw new Error("AFT RPC server not available");
+    }
+
+    const response = await this.fetchWithTimeout(`http://127.0.0.1:${port}/rpc/${method}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`RPC ${method} failed (${response.status}): ${text}`);
+    }
+
+    return (await response.json()) as T;
+  }
+
+  /** Check if the RPC server is reachable. */
+  async isAvailable(): Promise<boolean> {
+    try {
+      const port = await this.resolvePort();
+      return port !== null;
+    } catch {
+      return false;
+    }
+  }
+
+  private async resolvePort(): Promise<number | null> {
+    if (this.port && this.healthChecked) {
+      return this.port;
+    }
+
+    if (this.port) {
+      const alive = await this.healthCheck(this.port);
+      if (alive) {
+        this.healthChecked = true;
+        return this.port;
+      }
+      this.port = null;
+      this.healthChecked = false;
+    }
+
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      const port = this.readPortFile();
+      if (port) {
+        const alive = await this.healthCheck(port);
+        if (alive) {
+          this.port = port;
+          this.healthChecked = true;
+          return port;
+        }
+      }
+
+      if (attempt < MAX_RETRIES - 1) {
+        await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+      }
+    }
+
+    return null;
+  }
+
+  private readPortFile(): number | null {
+    try {
+      const content = readFileSync(this.portFilePath, "utf-8").trim();
+      const port = Number.parseInt(content, 10);
+      if (Number.isNaN(port) || port <= 0 || port > 65535) {
+        return null;
+      }
+      return port;
+    } catch {
+      return null;
+    }
+  }
+
+  private async healthCheck(port: number): Promise<boolean> {
+    try {
+      const response = await this.fetchWithTimeout(`http://127.0.0.1:${port}/health`, {
+        method: "GET",
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  private async fetchWithTimeout(url: string, options: RequestInit): Promise<Response> {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+      return await fetch(url, { ...options, signal: controller.signal });
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+
+  reset(): void {
+    this.port = null;
+    this.healthChecked = false;
+  }
+}

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";
+import { rpcPortFilePath } from "./rpc-utils";
+
+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,266 @@
+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;
+    backend?: string | null;
+    model?: string | null;
+    stage?: string | null;
+    files?: number | null;
+    entries_done?: number | null;
+    entries_total?: number | null;
+    entries: number | null;
+    dimension: number | null;
+    error?: string | 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 semanticConfig = {
+    ...asRecord(response.semantic),
+    ...asRecord((response as { semantic_config?: unknown }).semantic_config),
+  };
+  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"),
+      backend: readNullableString(semanticIndex.backend ?? semanticConfig.backend),
+      model: readNullableString(semanticIndex.model ?? semanticConfig.model),
+      stage: readNullableString(semanticIndex.stage),
+      files: readOptionalNumber(semanticIndex.files),
+      entries_done: readOptionalNumber(semanticIndex.entries_done),
+      entries_total: readOptionalNumber(semanticIndex.entries_total),
+      entries: readOptionalNumber(semanticIndex.entries),
+      dimension: readOptionalNumber(semanticIndex.dimension),
+      error: readNullableString(semanticIndex.error),
+    },
+    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.backend) {
+    lines.push(`- backend: ${status.semantic_index.backend}`);
+  }
+  if (status.semantic_index.model) {
+    lines.push(`- model: ${status.semantic_index.model}`);
+  }
+
+  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}`);
+  }
+
+  if (status.semantic_index.stage) {
+    lines.push("", "Semantic stage", status.semantic_index.stage);
+  }
+  if (status.semantic_index.files != null) {
+    lines.push(`- semantic files: ${formatCount(status.semantic_index.files)}`);
+  }
+  if (status.semantic_index.entries_done != null || status.semantic_index.entries_total != null) {
+    lines.push(
+      `- semantic progress: ${formatCount(status.semantic_index.entries_done ?? null)} / ${formatCount(status.semantic_index.entries_total ?? null)}`,
+    );
+  }
+  if (status.semantic_index.error) {
+    lines.push("", "Semantic error", status.semantic_index.error);
+  }
+
+  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.backend) {
+    lines.push(`- **Backend:** ${status.semantic_index.backend}`);
+  }
+  if (status.semantic_index.model) {
+    lines.push(`- **Model:** ${status.semantic_index.model}`);
+  }
+
+  if (status.semantic_index.dimension != null) {
+    lines.push(`- **Dimension:** ${formatCount(status.semantic_index.dimension)}`);
+  }
+  if (status.semantic_index.stage) {
+    lines.push(`- **Stage:** ${status.semantic_index.stage}`);
+  }
+  if (status.semantic_index.files != null) {
+    lines.push(`- **Files:** ${formatCount(status.semantic_index.files)}`);
+  }
+  if (status.semantic_index.entries_done != null || status.semantic_index.entries_total != null) {
+    lines.push(
+      `- **Progress:** ${formatCount(status.semantic_index.entries_done ?? null)} / ${formatCount(status.semantic_index.entries_total ?? null)}`,
+    );
+  }
+
+  if (status.semantic_index.error) {
+    lines.push(`- **Error:** ${status.semantic_index.error}`);
+  }
+
+  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";
+import { getOpenCodeConfigPaths } from "./opencode-config-dir";
+
+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;
+  }
+}