opencode-q 1.1.0

package/dist/plugin.js

@@ -0,0 +1,724 @@
+// @bun
+// src/plugin.ts
+import { randomUUID } from "crypto";
+import { existsSync as existsSync4 } from "fs";
+import { dirname, join as join5 } from "path";
+import { fileURLToPath } from "url";
+import { homedir as homedir2 } from "os";
+
+// src/storage.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync, readdirSync } from "fs";
+import { join as join2 } from "path";
+
+// src/constants.ts
+import { homedir } from "os";
+import { join, resolve, parse } from "path";
+var STORAGE_DIR = ".opencode";
+var QUEUE_PREFIX = "queue-";
+var QUEUE_EXT = ".json";
+var ID_LENGTH = 8;
+var ID_CHARSET = "0123456789abcdef";
+var DEFAULT_PORT = 4321;
+var HEALTH_SIGNATURE = "opencode-q";
+var POLL_PENDING_MS = 750;
+var HEARTBEAT_MS = 1e4;
+var LIVENESS_TIMEOUT_MS = 30000;
+var REELECTION_MS = 5000;
+function globalDir() {
+  return process.env.OPENCODE_Q_HOME || join(homedir(), ".config", "opencode", "opencode-q");
+}
+var PENDING_TIMEOUT_MS = 20000;
+var STALE_CLEANUP_MS = 300000;
+var SWEEP_MS = 2000;
+function instancesDir() {
+  return join(globalDir(), "instances");
+}
+function legacyProjectsDir() {
+  return join(globalDir(), "projects");
+}
+function isExcludedBaseDir(baseDir) {
+  const r = resolve(baseDir);
+  return r === resolve(homedir()) || r === parse(r).root;
+}
+
+// src/storage.ts
+function queueFile(baseDir, sessionId) {
+  return join2(baseDir, STORAGE_DIR, `${QUEUE_PREFIX}${sessionId}${QUEUE_EXT}`);
+}
+function generateId() {
+  let id = "";
+  for (let i = 0;i < ID_LENGTH; i++)
+    id += ID_CHARSET[Math.floor(Math.random() * ID_CHARSET.length)];
+  return id;
+}
+function emptyData() {
+  return { items: [], updatedAt: new Date().toISOString() };
+}
+function loadQueue(baseDir, sessionId) {
+  const file = queueFile(baseDir, sessionId);
+  if (!existsSync(file))
+    return emptyData();
+  try {
+    const data = JSON.parse(readFileSync(file, "utf-8"));
+    if (!Array.isArray(data.items))
+      data.items = [];
+    for (const item of data.items)
+      if (!item.status)
+        item.status = "queued";
+    return data;
+  } catch {
+    renameSync(file, file + ".bak");
+    return emptyData();
+  }
+}
+function saveQueue(baseDir, sessionId, data) {
+  const dir = join2(baseDir, STORAGE_DIR);
+  if (!existsSync(dir))
+    mkdirSync(dir, { recursive: true });
+  const now = new Date;
+  if (now.toISOString() === data.updatedAt)
+    now.setTime(now.getTime() + 1);
+  data.updatedAt = now.toISOString();
+  const file = queueFile(baseDir, sessionId);
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
+  renameSync(tmp, file);
+}
+function hasQueue(baseDir, sessionId) {
+  return existsSync(queueFile(baseDir, sessionId));
+}
+function addItem(baseDir, sessionId, text) {
+  if (!text.trim())
+    throw new Error("\uD504\uB86C\uD504\uD2B8\uB97C \uC785\uB825\uD574\uC8FC\uC138\uC694");
+  const data = loadQueue(baseDir, sessionId);
+  const item = { id: generateId(), text, createdAt: new Date().toISOString(), status: "queued" };
+  data.items.push(item);
+  saveQueue(baseDir, sessionId, data);
+  return item;
+}
+function removeItem(baseDir, sessionId, id) {
+  const data = loadQueue(baseDir, sessionId);
+  const idx = data.items.findIndex((i) => i.id === id);
+  if (idx === -1)
+    return false;
+  data.items.splice(idx, 1);
+  saveQueue(baseDir, sessionId, data);
+  return true;
+}
+function updateItem(baseDir, sessionId, id, text) {
+  if (!text.trim())
+    throw new Error("\uD504\uB86C\uD504\uD2B8\uB97C \uC785\uB825\uD574\uC8FC\uC138\uC694");
+  const data = loadQueue(baseDir, sessionId);
+  const item = data.items.find((i) => i.id === id);
+  if (!item)
+    return null;
+  item.text = text;
+  saveQueue(baseDir, sessionId, data);
+  return item;
+}
+function reorderItems(baseDir, sessionId, from, to) {
+  const data = loadQueue(baseDir, sessionId);
+  if (from < 0 || from >= data.items.length || to < 0 || to >= data.items.length) {
+    throw new Error("\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uC704\uCE58\uC785\uB2C8\uB2E4");
+  }
+  const [moved] = data.items.splice(from, 1);
+  data.items.splice(to, 0, moved);
+  saveQueue(baseDir, sessionId, data);
+  return data.items;
+}
+function setStatus(baseDir, sessionId, id, status, extra) {
+  const data = loadQueue(baseDir, sessionId);
+  const item = data.items.find((i) => i.id === id);
+  if (!item)
+    return null;
+  item.status = status;
+  if (extra?.sentAt)
+    item.sentAt = extra.sentAt;
+  if (extra?.completedAt)
+    item.completedAt = extra.completedAt;
+  if (extra?.error !== undefined)
+    item.error = extra.error;
+  saveQueue(baseDir, sessionId, data);
+  return item;
+}
+function sendItem(baseDir, sessionId, id) {
+  const data = loadQueue(baseDir, sessionId);
+  if (data.items.some((i) => (i.status === "pending" || i.status === "sent") && i.id !== id))
+    return null;
+  const item = data.items.find((i) => i.id === id);
+  if (!item)
+    return null;
+  item.status = "pending";
+  item.pendingAt = new Date().toISOString();
+  saveQueue(baseDir, sessionId, data);
+  return item;
+}
+function firstPending(baseDir, sessionId) {
+  return loadQueue(baseDir, sessionId).items.find((i) => i.status === "pending");
+}
+function sentItem(baseDir, sessionId) {
+  return loadQueue(baseDir, sessionId).items.find((i) => i.status === "sent");
+}
+function migrateLegacyDefault(baseDir, realSessionId) {
+  if (realSessionId === "default")
+    return false;
+  if (!hasQueue(baseDir, "default"))
+    return false;
+  if (hasQueue(baseDir, realSessionId))
+    return false;
+  const data = loadQueue(baseDir, "default");
+  for (const item of data.items) {
+    if (!item.status)
+      item.status = "queued";
+  }
+  saveQueue(baseDir, realSessionId, data);
+  renameSync(queueFile(baseDir, "default"), queueFile(baseDir, "default") + ".migrated");
+  return true;
+}
+var LIVE_STATUSES = new Set(["queued", "pending", "sent", "failed"]);
+function isLiveStatus(status) {
+  return LIVE_STATUSES.has(status);
+}
+function hasLiveItems(baseDir, sessionId) {
+  return loadQueue(baseDir, sessionId).items.some((i) => isLiveStatus(i.status));
+}
+function failTimedOutPending(baseDir, sessionId, timeoutMs, now = Date.now()) {
+  const data = loadQueue(baseDir, sessionId);
+  let changed = false;
+  for (const item of data.items) {
+    if (item.status !== "pending")
+      continue;
+    const t = item.pendingAt ? Date.parse(item.pendingAt) : NaN;
+    if (Number.isFinite(t) && now - t > timeoutMs) {
+      item.status = "failed";
+      item.error = "\uC18C\uC720 \uC778\uC2A4\uD134\uC2A4\uAC00 \uC751\uB2F5\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4";
+      changed = true;
+    }
+  }
+  if (changed)
+    saveQueue(baseDir, sessionId, data);
+  return changed;
+}
+function failAllInFlight(baseDir, sessionId, reason) {
+  const data = loadQueue(baseDir, sessionId);
+  let changed = false;
+  for (const item of data.items) {
+    if (item.status === "pending" || item.status === "sent") {
+      item.status = "failed";
+      item.error = reason;
+      changed = true;
+    }
+  }
+  if (changed)
+    saveQueue(baseDir, sessionId, data);
+  return changed;
+}
+
+// src/executor.ts
+function createExecutor(deps) {
+  const { baseDir, prompt } = deps;
+  const sessionStatus = new Map;
+  let timer = null;
+  function noteSession(sessionId, status) {
+    sessionStatus.set(sessionId, status);
+  }
+  async function dispatchFor(sessionId) {
+    if (sentItem(baseDir, sessionId))
+      return;
+    if (sessionStatus.get(sessionId) !== "idle")
+      return;
+    const pending = firstPending(baseDir, sessionId);
+    if (!pending)
+      return;
+    setStatus(baseDir, sessionId, pending.id, "sent", { sentAt: new Date().toISOString() });
+    try {
+      await prompt(sessionId, pending.text);
+    } catch (err) {
+      if (sentItem(baseDir, sessionId)?.status === "sent") {
+        setStatus(baseDir, sessionId, pending.id, "failed", { error: String(err?.message ?? err) });
+      }
+    }
+  }
+  async function tick() {
+    for (const sid of sessionStatus.keys())
+      await dispatchFor(sid);
+  }
+  function onIdle(sessionId) {
+    sessionStatus.set(sessionId, "idle");
+    const inflight = sentItem(baseDir, sessionId);
+    if (inflight)
+      setStatus(baseDir, sessionId, inflight.id, "done", { completedAt: new Date().toISOString() });
+  }
+  function onError(sessionId, message) {
+    const inflight = sentItem(baseDir, sessionId);
+    if (inflight)
+      setStatus(baseDir, sessionId, inflight.id, "failed", { error: message });
+  }
+  function start() {
+    if (!timer)
+      timer = setInterval(() => {
+        tick();
+      }, POLL_PENDING_MS);
+  }
+  function stop() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+  return { noteSession, tick, onIdle, onError, start, stop };
+}
+
+// src/registry.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2, readdirSync as readdirSync2, renameSync as renameSync2, rmSync } from "fs";
+import { join as join3 } from "path";
+function fileFor(instanceId) {
+  return join3(instancesDir(), `${instanceId}.json`);
+}
+function writeProjectRecord(rec) {
+  const dir = instancesDir();
+  mkdirSync2(dir, { recursive: true });
+  const file = fileFor(rec.instanceId);
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync2(tmp, JSON.stringify(rec), "utf-8");
+  renameSync2(tmp, file);
+}
+function touchHeartbeat(baseDir, sessions, instanceId) {
+  writeProjectRecord({ baseDir, sessions, heartbeat: new Date().toISOString(), instanceId });
+}
+function readAllProjects() {
+  const dir = instancesDir();
+  if (!existsSync2(dir))
+    return [];
+  const records = [];
+  for (const f of readdirSync2(dir)) {
+    if (!f.endsWith(".json"))
+      continue;
+    try {
+      records.push(JSON.parse(readFileSync2(join3(dir, f), "utf-8")));
+    } catch {}
+  }
+  return records;
+}
+function isOnline(rec, now = Date.now()) {
+  const t = Date.parse(rec.heartbeat);
+  return Number.isFinite(t) && now - t <= LIVENESS_TIMEOUT_MS;
+}
+function groupByBaseDir(records, now = Date.now()) {
+  const byDir = new Map;
+  for (const rec of records) {
+    let g = byDir.get(rec.baseDir);
+    if (!g) {
+      g = { baseDir: rec.baseDir, online: false, sessions: [] };
+      byDir.set(rec.baseDir, g);
+    }
+    if (isOnline(rec, now))
+      g.online = true;
+    for (const s of rec.sessions) {
+      const existing = g.sessions.find((x) => x.sessionId === s.sessionId);
+      if (!existing) {
+        g.sessions.push(s);
+        continue;
+      }
+      if ((Date.parse(s.updatedAt ?? "") || 0) >= (Date.parse(existing.updatedAt ?? "") || 0)) {
+        g.sessions[g.sessions.indexOf(existing)] = s;
+      }
+    }
+  }
+  return [...byDir.values()];
+}
+function removeInstanceRecord(instanceId) {
+  const file = fileFor(instanceId);
+  if (existsSync2(file))
+    rmSync(file, { force: true });
+}
+function markInstanceOffline(instanceId) {
+  const file = fileFor(instanceId);
+  if (!existsSync2(file))
+    return;
+  try {
+    const rec = JSON.parse(readFileSync2(file, "utf-8"));
+    rec.heartbeat = new Date(0).toISOString();
+    writeProjectRecord(rec);
+  } catch {}
+}
+function cleanupLegacyProjectsDir() {
+  const dir = legacyProjectsDir();
+  if (existsSync2(dir))
+    rmSync(dir, { recursive: true, force: true });
+}
+
+// src/server.ts
+import * as http from "http";
+import * as net from "net";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join4, extname, resolve as resolve2, sep } from "path";
+var VERSION = "1.1.0";
+var MIME = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon"
+};
+function send(res, status, body) {
+  const data = JSON.stringify(body);
+  res.writeHead(status, { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data) });
+  res.end(data);
+}
+function readBody(req) {
+  return new Promise((resolve3, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString();
+      if (!raw.trim())
+        return resolve3({});
+      try {
+        resolve3(JSON.parse(raw));
+      } catch {
+        reject(new Error("Invalid JSON"));
+      }
+    });
+  });
+}
+function buildState() {
+  const now = Date.now();
+  const groups = groupByBaseDir(readAllProjects(), now);
+  const projects = groups.map((g) => ({
+    baseDir: g.baseDir,
+    online: g.online,
+    sessions: g.sessions.map((s) => ({
+      sessionId: s.sessionId,
+      status: s.status,
+      title: s.title ?? "",
+      createdAt: s.createdAt ?? "",
+      updatedAt: s.updatedAt ?? "",
+      items: loadQueue(g.baseDir, s.sessionId).items
+    }))
+  })).filter((p) => p.online || p.sessions.some((s) => s.items.some((i) => isLiveStatus(i.status))));
+  return { projects };
+}
+function runSweep(now = Date.now()) {
+  cleanupLegacyProjectsDir();
+  const records = readAllProjects();
+  const groups = groupByBaseDir(records, now);
+  for (const g of groups) {
+    for (const s of g.sessions) {
+      if (g.online)
+        failTimedOutPending(g.baseDir, s.sessionId, PENDING_TIMEOUT_MS, now);
+      else
+        failAllInFlight(g.baseDir, s.sessionId, "\uC778\uC2A4\uD134\uC2A4\uAC00 \uC624\uD504\uB77C\uC778\uC785\uB2C8\uB2E4");
+    }
+  }
+  for (const rec of records) {
+    if (isOnline(rec, now))
+      continue;
+    const age = now - Date.parse(rec.heartbeat);
+    if (age <= STALE_CLEANUP_MS)
+      continue;
+    const anyLive = rec.sessions.some((s) => hasLiveItems(rec.baseDir, s.sessionId));
+    if (!anyLive)
+      removeInstanceRecord(rec.instanceId);
+  }
+}
+function createRequestHandler(opts) {
+  const { webDir } = opts;
+  function serveStatic(urlPath, res) {
+    if (!webDir)
+      return false;
+    const safe = urlPath === "/" ? "index.html" : urlPath.replace(/^\/+/, "");
+    const resolved = resolve2(webDir, safe);
+    if (!resolved.startsWith(resolve2(webDir) + sep) && resolved !== resolve2(webDir))
+      return false;
+    let file = resolved;
+    if (!existsSync3(file))
+      file = join4(webDir, "index.html");
+    if (!existsSync3(file))
+      return false;
+    const data = readFileSync3(file);
+    res.writeHead(200, { "Content-Type": MIME[extname(file)] || "application/octet-stream", "Content-Length": data.length });
+    res.end(data);
+    return true;
+  }
+  return async function handler(req, res) {
+    try {
+      const url = new URL(req.url || "/", "http://localhost");
+      const p = url.pathname;
+      if (p === "/health" && req.method === "GET")
+        return send(res, 200, { app: HEALTH_SIGNATURE, version: VERSION });
+      if (p === "/api/state" && req.method === "GET")
+        return send(res, 200, buildState());
+      let m = p.match(/^\/api\/projects\/([^/]+)\/sessions\/([^/]+)\/items\/([^/]+)\/(send|resend)$/);
+      if (m && req.method === "POST") {
+        const [, b, s, id] = m;
+        const baseDir = decodeURIComponent(b), sid = decodeURIComponent(s);
+        const group = groupByBaseDir(readAllProjects()).find((g) => g.baseDir === baseDir);
+        if (!group || !group.online)
+          return send(res, 409, { error: "\uC778\uC2A4\uD134\uC2A4\uAC00 \uC624\uD504\uB77C\uC778\uC785\uB2C8\uB2E4" });
+        const item = sendItem(baseDir, sid, id);
+        if (!item)
+          return send(res, 409, { error: "\uC774\uBBF8 \uC804\uC1A1 \uC911\uC778 \uD56D\uBAA9\uC774 \uC788\uC2B5\uB2C8\uB2E4" });
+        return send(res, 200, { item });
+      }
+      m = p.match(/^\/api\/projects\/([^/]+)\/sessions\/([^/]+)\/items\/([^/]+)$/);
+      if (m) {
+        const [, b, s, id] = m;
+        const baseDir = decodeURIComponent(b), sid = decodeURIComponent(s);
+        if (req.method === "DELETE") {
+          const ok = removeItem(baseDir, sid, id);
+          return send(res, ok ? 200 : 404, ok ? { removed: true } : { error: "not found" });
+        }
+        if (req.method === "PATCH") {
+          try {
+            const body = await readBody(req);
+            const item = updateItem(baseDir, sid, id, body.text);
+            return item ? send(res, 200, { item }) : send(res, 404, { error: "not found" });
+          } catch (e) {
+            return send(res, 400, { error: e.message });
+          }
+        }
+      }
+      m = p.match(/^\/api\/projects\/([^/]+)\/sessions\/([^/]+)\/reorder$/);
+      if (m && req.method === "PATCH") {
+        const [, b, s] = m;
+        try {
+          const body = await readBody(req);
+          const items = reorderItems(decodeURIComponent(b), decodeURIComponent(s), body.from, body.to);
+          return send(res, 200, { items });
+        } catch (e) {
+          return send(res, 400, { error: e.message });
+        }
+      }
+      m = p.match(/^\/api\/projects\/([^/]+)\/sessions\/([^/]+)\/items$/);
+      if (m && req.method === "POST") {
+        const [, b, s] = m;
+        try {
+          const body = await readBody(req);
+          return send(res, 201, { item: addItem(decodeURIComponent(b), decodeURIComponent(s), body.text) });
+        } catch (e) {
+          return send(res, 400, { error: e.message });
+        }
+      }
+      if (serveStatic(p, res))
+        return;
+      return send(res, 404, { error: "Not found" });
+    } catch (err) {
+      if (!res.headersSent)
+        send(res, 500, { error: "Internal server error" });
+    }
+  };
+}
+function isPortInUse(port, host = "127.0.0.1") {
+  return new Promise((resolve3) => {
+    const sock = new net.Socket;
+    sock.once("connect", () => {
+      sock.destroy();
+      resolve3(true);
+    });
+    sock.once("error", () => {
+      sock.destroy();
+      resolve3(false);
+    });
+    sock.connect(port, host);
+  });
+}
+async function tryListen(port, handler) {
+  if (await isPortInUse(port))
+    return null;
+  return new Promise((resolve3) => {
+    const server = http.createServer(handler);
+    server.once("error", () => resolve3(null));
+    server.listen(port, "127.0.0.1", () => resolve3(server));
+  });
+}
+async function isOpencodeQHost(port) {
+  try {
+    const r = await fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(2000) });
+    if (!r.ok)
+      return false;
+    const j = await r.json();
+    return j?.app === HEALTH_SIGNATURE;
+  } catch {
+    return false;
+  }
+}
+
+// src/plugin.ts
+function createPluginRuntime(deps) {
+  const { baseDir, instanceId, executor } = deps;
+  const registerable = deps.registerable !== false;
+  const sessions = new Map;
+  function persist() {
+    if (!registerable)
+      return;
+    touchHeartbeat(baseDir, [...sessions.values()], instanceId);
+  }
+  function seeSession(sid, meta) {
+    if (!registerable)
+      return;
+    const existing = sessions.get(sid);
+    if (!existing) {
+      sessions.set(sid, {
+        sessionId: sid,
+        status: "idle",
+        title: meta?.title ?? "",
+        createdAt: meta?.createdAt ?? new Date().toISOString(),
+        updatedAt: meta?.updatedAt ?? new Date().toISOString()
+      });
+      migrateLegacyDefault(baseDir, sid);
+    } else if (meta) {
+      sessions.set(sid, {
+        ...existing,
+        title: meta.title ?? existing.title,
+        createdAt: meta.createdAt ?? existing.createdAt,
+        updatedAt: meta.updatedAt ?? existing.updatedAt
+      });
+    }
+    executor.noteSession(sid, sessions.get(sid).status);
+  }
+  function setSessionStatus(sid, status) {
+    const s = sessions.get(sid);
+    if (s)
+      sessions.set(sid, { ...s, status });
+  }
+  return {
+    persist,
+    seeSession,
+    event: async ({ event }) => {
+      if (event?.type === "server.instance.disposed") {
+        if (!registerable)
+          return;
+        if (event.properties?.directory === baseDir)
+          markInstanceOffline(instanceId);
+        return;
+      }
+      const info = event?.properties?.info;
+      if (info?.parentID)
+        return;
+      const sid = event?.properties?.sessionID ?? info?.id;
+      if (!sid)
+        return;
+      const meta = info ? {
+        title: info.title ?? "",
+        createdAt: info.time?.created != null ? new Date(info.time.created).toISOString() : undefined,
+        updatedAt: info.time?.updated != null ? new Date(info.time.updated).toISOString() : undefined
+      } : undefined;
+      seeSession(sid, meta);
+      if (event.type === "session.status") {
+        const busy = event.properties?.status?.type === "busy";
+        setSessionStatus(sid, busy ? "busy" : "idle");
+        executor.noteSession(sid, busy ? "busy" : "idle");
+        persist();
+        return;
+      }
+      if (event.type === "session.idle") {
+        setSessionStatus(sid, "idle");
+        executor.noteSession(sid, "idle");
+        executor.onIdle(sid);
+        persist();
+        return;
+      }
+      if (event.type === "session.error") {
+        const err = event.properties?.error;
+        setSessionStatus(sid, "error");
+        executor.onError(sid, err ? err.name || JSON.stringify(err) : "session error");
+        persist();
+        return;
+      }
+      persist();
+    }
+  };
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function discoverSessions(client, seeSession, noteBusy, opts = {}) {
+  const attempts = opts.attempts ?? 3;
+  const delayMs = opts.delayMs ?? 500;
+  for (let i = 0;i < attempts; i++) {
+    try {
+      const [list, status] = await Promise.all([
+        client.session.list().then((r) => r.data ?? []),
+        client.session.status().then((r) => r.data ?? {})
+      ]);
+      for (const s of list) {
+        if (!s.id || s.parentID)
+          continue;
+        seeSession(s.id, {
+          title: s.title ?? "",
+          createdAt: s.time?.created != null ? new Date(s.time.created).toISOString() : undefined,
+          updatedAt: s.time?.updated != null ? new Date(s.time.updated).toISOString() : undefined
+        });
+        if (status[s.id]?.type === "busy")
+          noteBusy(s.id);
+      }
+      return true;
+    } catch (e) {
+      opts.log?.(`discoverSessions attempt ${i + 1} failed: ${String(e)}`);
+      if (i < attempts - 1)
+        await sleep(delayMs);
+    }
+  }
+  return false;
+}
+function resolveWebDir() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join5(homedir2(), ".config", "opencode", "plugins", "web"),
+    join5(here, "web"),
+    join5(here, "..", "..", "web", "dist"),
+    join5(process.cwd(), "web", "dist")
+  ];
+  for (const dir of candidates)
+    if (existsSync4(join5(dir, "index.html")))
+      return dir;
+  return;
+}
+var OpenCodeQ = async ({ client, directory }) => {
+  const baseDir = directory;
+  const instanceId = randomUUID();
+  const registerable = !isExcludedBaseDir(baseDir);
+  const executor = createExecutor({
+    baseDir,
+    prompt: async (sessionId, text) => {
+      await client.session.promptAsync({ path: { id: sessionId }, body: { parts: [{ type: "text", text }] } });
+    }
+  });
+  if (registerable)
+    executor.start();
+  const runtime = createPluginRuntime({ baseDir, instanceId, executor, registerable });
+  if (registerable) {
+    discoverSessions(client, (id, meta) => runtime.seeSession(id, meta), (id) => executor.noteSession(id, "busy")).then((ok) => {
+      if (ok)
+        runtime.persist();
+    });
+    runtime.persist();
+    setInterval(() => runtime.persist(), HEARTBEAT_MS);
+  }
+  const handler = createRequestHandler({ webDir: resolveWebDir() });
+  let server = await tryListen(DEFAULT_PORT, handler);
+  setInterval(async () => {
+    if (server)
+      return;
+    if (await isPortInUse(DEFAULT_PORT)) {
+      if (await isOpencodeQHost(DEFAULT_PORT))
+        return;
+      return;
+    }
+    server = await tryListen(DEFAULT_PORT, handler);
+  }, REELECTION_MS);
+  setInterval(() => {
+    if (server) {
+      try {
+        runSweep();
+      } catch {}
+    }
+  }, SWEEP_MS);
+  return runtime;
+};
+export {
+  discoverSessions,
+  createPluginRuntime,
+  OpenCodeQ
+};