opencode-annotate 1.2.0

package/dist/plugin.js

@@ -0,0 +1,619 @@
+// src/plugin.ts
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { basename, dirname, join } from "path";
+import { createServer } from "http";
+import { fileURLToPath } from "url";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var PACKAGE_JSON_PATH = join(__dirname2, "..", "package.json");
+var BASE_DIR = getRuntimeBaseDir();
+var LOG_PATH = join(BASE_DIR, "plugin.log");
+var ANNOTATION_DIR = join(BASE_DIR, "annotations");
+var PORT_START = 39240;
+var PORT_END = 39260;
+var LISTEN_HOST = "127.0.0.1";
+var APP_ID = "opencode-chrome-annotation";
+var INSTANCE_SESSION_PREFIX = "plugin:";
+var CLAIM_TTL_MS = 5 * 60 * 1000;
+var cachedVersion = null;
+var processSessionId = `${INSTANCE_SESSION_PREFIX}${Math.random().toString(36).slice(2)}`;
+var pluginClient = null;
+var pluginDirectory = process.cwd();
+var pluginSessionLabel = buildSessionLabel(pluginDirectory);
+var listeningPort = null;
+var httpServer = null;
+var serverStartupStatus = "not-started";
+var serverStartupError = null;
+var bindFailures = [];
+var lastAnnotationStatus = null;
+var activeOpencodeSessionId = null;
+var lastExtensionVersion = null;
+var sessionTitles = new Map;
+var sessionDirectories = new Map;
+var subagentSessionIds = new Set;
+var subagentChecks = new Map;
+var claims = new Map;
+function fallbackSession() {
+  return {
+    id: processSessionId,
+    title: pluginSessionLabel,
+    directory: pluginDirectory,
+    status: "open",
+    updatedAt: 0
+  };
+}
+function getRuntimeBaseDir() {
+  const uid = typeof process.getuid === "function" ? process.getuid() : null;
+  const candidates = [
+    process.env.XDG_RUNTIME_DIR ? join(process.env.XDG_RUNTIME_DIR, "opencode-chrome-annotation") : null,
+    join(tmpdir(), `opencode-chrome-annotation-${uid ?? "user"}`)
+  ];
+  for (const candidate of candidates) {
+    if (!candidate)
+      continue;
+    try {
+      mkdirSync(candidate, { recursive: true, mode: 448 });
+      return candidate;
+    } catch {}
+  }
+  return join(tmpdir(), `opencode-chrome-annotation-${uid ?? "user"}`);
+}
+function getPackageVersion() {
+  if (cachedVersion)
+    return cachedVersion;
+  try {
+    const pkg = JSON.parse(readFileSync(PACKAGE_JSON_PATH, "utf8"));
+    if (typeof pkg?.version === "string") {
+      cachedVersion = pkg.version;
+      return pkg.version;
+    }
+  } catch {}
+  cachedVersion = "unknown";
+  return cachedVersion;
+}
+function logDebug(message) {
+  try {
+    appendFileSync(LOG_PATH, `[${new Date().toISOString()}] ${message}
+`, "utf8");
+  } catch {}
+}
+function buildSessionLabel(directory) {
+  const name = basename(directory || process.cwd());
+  return name ? `OpenCode: ${name}` : "OpenCode";
+}
+function decodeDataUrl(dataUrl) {
+  const match = String(dataUrl).match(/^data:([^;,]+)?;base64,(.+)$/);
+  if (!match)
+    throw new Error("Annotation screenshot must be a base64 data URL");
+  return {
+    mime: match[1] || "application/octet-stream",
+    bytes: Buffer.from(match[2], "base64")
+  };
+}
+function sanitizeFileStem(value) {
+  return String(value || "annotation").toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "annotation";
+}
+function buildAnnotationPrompt(annotation) {
+  const comment = typeof annotation?.comment === "string" ? annotation.comment.trim() : "";
+  const page = annotation?.page || {};
+  const element = annotation?.element || {};
+  const rect = element?.rect || {};
+  const viewport = annotation?.viewport || {};
+  return [
+    "Browser annotation from Chrome",
+    "",
+    "User comment:",
+    comment || "(no comment provided)",
+    "",
+    "Page:",
+    `Title: ${page.title || ""}`,
+    `URL: ${page.url || ""}`,
+    typeof annotation?.tabId === "number" ? `Tab ID: ${annotation.tabId}` : "Tab ID: ",
+    `Viewport: width=${viewport.width ?? ""} height=${viewport.height ?? ""} devicePixelRatio=${viewport.devicePixelRatio ?? ""}`,
+    "",
+    "Selected element:",
+    `Selector: ${element.selector || ""}`,
+    `Tag: ${element.tag || ""}`,
+    `Role: ${element.role || ""}`,
+    `Text: ${element.text || ""}`,
+    `Aria label: ${element.ariaLabel || ""}`,
+    `Rect: x=${rect.x ?? ""} y=${rect.y ?? ""} width=${rect.width ?? ""} height=${rect.height ?? ""}`,
+    "",
+    "Please inspect the screenshot and selected element metadata, then make the appropriate code change."
+  ].join(`
+`);
+}
+function isExplicitFalse(value) {
+  return value === false || value?.data === false;
+}
+function unwrapClientResult(result, action) {
+  if (!result || typeof result !== "object")
+    return result;
+  if ("error" in result && result.error) {
+    const err = result.error;
+    const message = typeof err?.message === "string" && err.message || typeof err?.error === "string" && err.error || typeof err === "string" && err || `OpenCode ${action} failed`;
+    throw new Error(message);
+  }
+  if ("data" in result)
+    return result.data;
+  return result;
+}
+function setLastAnnotationStatus(status) {
+  lastAnnotationStatus = { ...status, time: new Date().toISOString() };
+}
+function applySessionTitle(sessionId, title) {
+  const next = String(title || "").trim();
+  if (!sessionId || !next)
+    return;
+  sessionTitles.set(sessionId, next);
+  if (activeOpencodeSessionId === sessionId) {
+    pluginSessionLabel = next;
+  }
+}
+function parseSessionTitle(response) {
+  const info = response?.data || response;
+  if (!info || typeof info !== "object")
+    return null;
+  if (typeof info.id !== "string" || typeof info.title !== "string")
+    return null;
+  return { id: info.id, title: info.title };
+}
+function rememberClaim(tabId, sessionId, extensionVersion) {
+  const key = Number(tabId);
+  const now = new Date().toISOString();
+  const prior = claims.get(key);
+  const cleanVersion = cleanExtensionVersion(extensionVersion);
+  if (cleanVersion)
+    lastExtensionVersion = cleanVersion;
+  claims.set(key, {
+    sessionId,
+    claimedAt: prior?.claimedAt || now,
+    lastSeenAt: now,
+    extensionVersion: cleanVersion || prior?.extensionVersion
+  });
+}
+function cleanExtensionVersion(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function pruneStaleClaims() {
+  const cutoff = Date.now() - CLAIM_TTL_MS;
+  for (const [tabId, claim] of claims.entries()) {
+    const lastSeen = Date.parse(claim.lastSeenAt);
+    if (!Number.isFinite(lastSeen) || lastSeen < cutoff) {
+      claims.delete(tabId);
+    }
+  }
+}
+async function isSubagentSession(sessionId) {
+  if (subagentSessionIds.has(sessionId))
+    return true;
+  if (subagentChecks.has(sessionId))
+    return subagentChecks.get(sessionId);
+  let isSubagent = false;
+  try {
+    const response = await pluginClient?.session?.get({
+      path: { id: sessionId },
+      query: { directory: pluginDirectory }
+    });
+    const info = response?.data || response;
+    isSubagent = Boolean(info?.parentID);
+  } catch {}
+  if (isSubagent)
+    subagentSessionIds.add(sessionId);
+  subagentChecks.set(sessionId, isSubagent);
+  return isSubagent;
+}
+async function ensureSessionTitle(sessionId) {
+  if (!sessionId || sessionTitles.has(sessionId) || !pluginClient?.session?.get)
+    return;
+  try {
+    const response = await pluginClient.session.get({
+      path: { id: sessionId },
+      query: { directory: pluginDirectory }
+    });
+    const parsed = parseSessionTitle(response);
+    if (parsed)
+      applySessionTitle(parsed.id, parsed.title);
+  } catch {}
+}
+async function listOpenCodeSessions() {
+  if (!pluginClient?.session?.list) {
+    return [fallbackSession()];
+  }
+  try {
+    const rows = [];
+    const seen = new Set;
+    const responses = [];
+    try {
+      responses.push(await pluginClient.session.list({ query: { directory: pluginDirectory } }));
+    } catch {}
+    try {
+      responses.push(await pluginClient.session.list({}));
+    } catch {}
+    for (const response of responses) {
+      const list = Array.isArray(response?.data) ? response.data : Array.isArray(response) ? response : [];
+      for (const item of list) {
+        if (typeof item?.id === "string" && !seen.has(item.id)) {
+          seen.add(item.id);
+          rows.push(item);
+        }
+      }
+    }
+    logDebug(`sessions list dir=${pluginDirectory} rows=${rows.length}`);
+    const knownIds = new Set(rows.map((item) => item.id));
+    const sessions = [];
+    for (const item of rows) {
+      if (typeof item?.id !== "string" || item?.time?.archived)
+        continue;
+      if (item?.parentID && knownIds.has(item.parentID)) {
+        subagentSessionIds.add(item.id);
+        continue;
+      }
+      const title = typeof item?.title === "string" && item.title.trim() ? item.title.trim() : `Session ${item.id.slice(0, 8)}`;
+      applySessionTitle(item.id, title);
+      let directory = typeof item?.directory === "string" ? item.directory : null;
+      if (!directory) {
+        if (!sessionDirectories.has(item.id) && pluginClient?.session?.get) {
+          let resolved = null;
+          try {
+            const detail = await pluginClient.session.get({
+              path: { id: item.id },
+              query: { directory: pluginDirectory }
+            });
+            const info = detail?.data || detail;
+            if (typeof info?.directory === "string")
+              resolved = info.directory;
+          } catch {}
+          sessionDirectories.set(item.id, resolved);
+        }
+        directory = sessionDirectories.get(item.id) || pluginDirectory;
+      } else {
+        sessionDirectories.set(item.id, directory);
+      }
+      const updatedAt = Number(item?.time?.updated ?? item?.time?.created ?? item?.updatedAt ?? item?.createdAt) || 0;
+      sessions.push({ id: item.id, title, directory, status: "open", updatedAt });
+    }
+    if (!sessions.length)
+      return [fallbackSession()];
+    if (activeOpencodeSessionId && !subagentSessionIds.has(activeOpencodeSessionId) && !sessions.some((session) => session.id === activeOpencodeSessionId)) {
+      const activeTitle = sessionTitles.get(activeOpencodeSessionId);
+      if (activeTitle) {
+        sessions.unshift({
+          id: activeOpencodeSessionId,
+          title: activeTitle,
+          directory: sessionDirectories.get(activeOpencodeSessionId) || pluginDirectory,
+          status: "open",
+          updatedAt: Number.MAX_SAFE_INTEGER
+        });
+      }
+    }
+    sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+    return sessions;
+  } catch {
+    return [fallbackSession()];
+  }
+}
+function json(res, statusCode, body, origin) {
+  if (origin)
+    res.setHeader("Access-Control-Allow-Origin", origin);
+  res.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "content-type");
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  res.statusCode = statusCode;
+  res.end(JSON.stringify(body));
+}
+function allowedCorsOrigin(req) {
+  const origin = req.headers?.origin;
+  if (typeof origin !== "string" || !origin)
+    return null;
+  if (/^chrome-extension:\/\//.test(origin) || /^moz-extension:\/\//.test(origin))
+    return origin;
+  return null;
+}
+async function readJsonBody(req) {
+  return await new Promise((resolve, reject) => {
+    let data = "";
+    req.on("data", (chunk) => {
+      data += chunk.toString("utf8");
+      if (data.length > 10 * 1024 * 1024)
+        reject(new Error("Request body too large"));
+    });
+    req.on("end", () => {
+      try {
+        resolve(data ? JSON.parse(data) : {});
+      } catch {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function listClaims() {
+  pruneStaleClaims();
+  return Array.from(claims.entries()).map(([tabId, info]) => ({ tabId, ...info })).sort((a, b) => a.tabId - b.tabId);
+}
+async function queueAnnotationPrompt(sessionId, annotation) {
+  if (typeof sessionId === "string" && sessionId.startsWith(INSTANCE_SESSION_PREFIX)) {
+    setLastAnnotationStatus({ ok: false, sessionId, error: "Tab is linked to a placeholder session, not a real chat" });
+    throw new Error("This tab is linked to a placeholder session, not a real chat. Reconnect and pick a specific chat.");
+  }
+  if (!pluginClient) {
+    setLastAnnotationStatus({ ok: false, sessionId, error: "No OpenCode client is available" });
+    throw new Error("No OpenCode client is available");
+  }
+  setLastAnnotationStatus({
+    ok: null,
+    sessionId,
+    phase: "received",
+    commentLength: typeof annotation?.comment === "string" ? annotation.comment.length : 0
+  });
+  let promptText = buildAnnotationPrompt(annotation);
+  const screenshot = annotation?.screenshot;
+  if (screenshot?.dataUrl) {
+    mkdirSync(ANNOTATION_DIR, { recursive: true });
+    const { mime, bytes } = decodeDataUrl(screenshot.dataUrl);
+    const ext = mime === "image/jpeg" ? "jpg" : mime === "image/webp" ? "webp" : "png";
+    const stem = sanitizeFileStem(annotation?.page?.title || annotation?.element?.tag || "annotation");
+    const filePath = join(ANNOTATION_DIR, `${Date.now()}-${stem}.${ext}`);
+    writeFileSync(filePath, bytes);
+    promptText += `
+
+Screenshot: ${filePath}`;
+  }
+  const promptBody = { parts: [{ type: "text", text: promptText }] };
+  const promptDirectory = sessionDirectories.get(sessionId) || pluginDirectory;
+  if (typeof pluginClient?.session?.promptAsync === "function") {
+    const response = await pluginClient.session.promptAsync({
+      path: { id: sessionId },
+      query: { directory: promptDirectory },
+      body: promptBody
+    });
+    const data = unwrapClientResult(response, "session prompt");
+    if (isExplicitFalse(data))
+      throw new Error("OpenCode rejected session prompt submission");
+    setLastAnnotationStatus({ ok: true, sessionId, transport: "session.promptAsync", response: data ?? null });
+    return;
+  }
+  if (typeof pluginClient?.session?.prompt === "function") {
+    const response = await pluginClient.session.prompt({
+      path: { id: sessionId },
+      query: { directory: promptDirectory },
+      body: promptBody
+    });
+    const data = unwrapClientResult(response, "session prompt");
+    if (isExplicitFalse(data))
+      throw new Error("OpenCode rejected session prompt submission");
+    setLastAnnotationStatus({ ok: true, sessionId, transport: "session.prompt", response: data ?? null });
+    return;
+  }
+  const text = promptText;
+  const appended = await pluginClient.tui.appendPrompt({
+    query: { directory: pluginDirectory },
+    body: { text }
+  });
+  const appendedData = unwrapClientResult(appended, "tui append prompt");
+  if (isExplicitFalse(appendedData))
+    throw new Error("OpenCode rejected appending the annotation prompt");
+  const submitted = await pluginClient.tui.submitPrompt({ query: { directory: pluginDirectory } });
+  const submittedData = unwrapClientResult(submitted, "tui submit prompt");
+  if (isExplicitFalse(submittedData))
+    throw new Error("OpenCode rejected submitting the annotation prompt");
+  setLastAnnotationStatus({ ok: true, sessionId, transport: "tui", response: appendedData ?? null });
+}
+function buildStatus() {
+  return {
+    app: APP_ID,
+    version: getPackageVersion(),
+    runtime: {
+      platform: process.platform,
+      node: process.version,
+      tmpdir: tmpdir(),
+      xdgRuntimeDir: Boolean(process.env.XDG_RUNTIME_DIR),
+      uid: typeof process.getuid === "function" ? process.getuid() : null
+    },
+    instanceId: processSessionId,
+    sessionId: processSessionId,
+    opencodeSessionId: activeOpencodeSessionId,
+    label: pluginSessionLabel,
+    directory: pluginDirectory,
+    runtimeBaseDir: BASE_DIR,
+    annotationDir: ANNOTATION_DIR,
+    logPath: LOG_PATH,
+    server: {
+      status: serverStartupStatus,
+      host: LISTEN_HOST,
+      port: listeningPort,
+      startupError: serverStartupError,
+      bindFailures
+    },
+    port: listeningPort,
+    lastExtensionVersion,
+    claimTtlMs: CLAIM_TTL_MS,
+    claims: listClaims(),
+    lastAnnotation: lastAnnotationStatus
+  };
+}
+async function startServer() {
+  if (listeningPort)
+    return;
+  serverStartupStatus = "starting";
+  serverStartupError = null;
+  bindFailures.length = 0;
+  for (let port = PORT_START;port <= PORT_END; port++) {
+    const server = createServer(async (req, res) => {
+      const origin = allowedCorsOrigin(req) || undefined;
+      if (req.method === "OPTIONS") {
+        json(res, 200, { ok: true }, origin);
+        return;
+      }
+      try {
+        const url = new URL(req.url || "/", `http://${LISTEN_HOST}:${port}`);
+        if (req.method === "GET" && url.pathname === "/status") {
+          json(res, 200, buildStatus(), origin);
+          return;
+        }
+        if (req.method === "GET" && url.pathname === "/sessions") {
+          const sessions = await listOpenCodeSessions();
+          json(res, 200, {
+            sessions
+          }, origin);
+          return;
+        }
+        if (req.method === "POST" && url.pathname === "/claim") {
+          const body = await readJsonBody(req);
+          const tabId = body?.tabId;
+          const sessionId = body?.sessionId;
+          const extensionVersion = body?.extensionVersion;
+          if (!Number.isFinite(tabId))
+            throw new Error("tabId is required");
+          if (typeof sessionId !== "string" || !sessionId)
+            throw new Error("sessionId is required");
+          if (sessionId.startsWith(INSTANCE_SESSION_PREFIX)) {
+            throw new Error("Cannot link to the placeholder session. Restart OpenCode in your project and pick a real chat.");
+          }
+          await ensureSessionTitle(sessionId);
+          rememberClaim(Number(tabId), sessionId, extensionVersion);
+          json(res, 200, { ok: true, sessionId }, origin);
+          return;
+        }
+        if (req.method === "POST" && url.pathname === "/annotation") {
+          const body = await readJsonBody(req);
+          const tabId = body?.tabId;
+          const sessionId = body?.sessionId;
+          const extensionVersion = body?.extensionVersion;
+          const annotation = body?.annotation;
+          if (!Number.isFinite(tabId))
+            throw new Error("tabId is required");
+          if (typeof sessionId !== "string" || !sessionId)
+            throw new Error("sessionId is required");
+          if (!annotation || typeof annotation !== "object")
+            throw new Error("annotation is required");
+          rememberClaim(Number(tabId), sessionId, extensionVersion);
+          await queueAnnotationPrompt(sessionId, { ...annotation, tabId: Number(tabId) });
+          json(res, 200, { ok: true, sessionId }, origin);
+          return;
+        }
+        if (req.method === "POST" && url.pathname === "/unclaim") {
+          const body = await readJsonBody(req);
+          const tabId = body?.tabId;
+          const extensionVersion = body?.extensionVersion;
+          const cleanVersion = cleanExtensionVersion(extensionVersion);
+          if (cleanVersion)
+            lastExtensionVersion = cleanVersion;
+          if (!Number.isFinite(tabId))
+            throw new Error("tabId is required");
+          claims.delete(Number(tabId));
+          json(res, 200, { ok: true }, origin);
+          return;
+        }
+        if (req.method === "POST" && url.pathname === "/session/close") {
+          const body = await readJsonBody(req);
+          const sessionId = body?.sessionId;
+          if (typeof sessionId !== "string" || !sessionId)
+            throw new Error("sessionId is required");
+          if (sessionId.startsWith(INSTANCE_SESSION_PREFIX)) {
+            throw new Error("Cannot close the placeholder session");
+          }
+          if (!/^[A-Za-z0-9:_-]+$/.test(sessionId))
+            throw new Error("Invalid sessionId");
+          if (!pluginClient?.session?.delete)
+            throw new Error("OpenCode client is unavailable");
+          await pluginClient.session.delete({ path: { id: sessionId } });
+          sessionTitles.delete(sessionId);
+          sessionDirectories.delete(sessionId);
+          subagentSessionIds.delete(sessionId);
+          subagentChecks.delete(sessionId);
+          for (const [tabId, claim] of claims) {
+            if (claim.sessionId === sessionId)
+              claims.delete(tabId);
+          }
+          logDebug(`session closed id=${sessionId}`);
+          json(res, 200, { ok: true, sessionId }, origin);
+          return;
+        }
+        json(res, 404, { ok: false, error: "Not found" }, origin);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logDebug(`http error path=${req.url || ""} error=${message}`);
+        json(res, 400, { ok: false, error: message }, origin);
+      }
+    });
+    const started = await new Promise((resolve) => {
+      server.once("error", (error) => {
+        const failure = {
+          port,
+          code: error.code,
+          message: error.message
+        };
+        bindFailures.push(failure);
+        logDebug(`http bind failed port=${port} code=${failure.code || ""} error=${failure.message}`);
+        resolve(false);
+      });
+      server.listen(port, LISTEN_HOST, () => resolve(true));
+    });
+    if (!started)
+      continue;
+    httpServer = server;
+    listeningPort = port;
+    serverStartupStatus = "listening";
+    logDebug(`http server listening port=${port} session=${processSessionId} label=${JSON.stringify(pluginSessionLabel)}`);
+    return;
+  }
+  serverStartupStatus = "failed";
+  serverStartupError = `Could not bind OpenCode annotation server on ${LISTEN_HOST} ports ${PORT_START}-${PORT_END}`;
+  throw new Error(serverStartupError);
+}
+var plugin = async (ctx) => {
+  pluginClient = ctx.client;
+  pluginDirectory = ctx.directory || process.cwd();
+  pluginSessionLabel = buildSessionLabel(ctx.worktree || pluginDirectory);
+  startServer().catch((error) => {
+    serverStartupStatus = "failed";
+    serverStartupError = error instanceof Error ? error.message : String(error);
+    logDebug(`server startup failed error=${serverStartupError}`);
+  });
+  return {
+    event: async ({ event }) => {
+      const info = event?.properties?.info;
+      if (event?.type === "session.created" || event?.type === "session.updated") {
+        if (typeof info?.id === "string" && info?.parentID) {
+          subagentSessionIds.add(info.id);
+        }
+        if (typeof info?.id === "string" && typeof info?.title === "string" && !info?.parentID) {
+          applySessionTitle(info.id, info.title);
+        }
+      }
+      if (event?.type === "session.deleted" && typeof info?.id === "string") {
+        sessionTitles.delete(info.id);
+        if (activeOpencodeSessionId === info.id) {
+          activeOpencodeSessionId = null;
+          pluginSessionLabel = buildSessionLabel(pluginDirectory);
+        }
+      }
+    },
+    "chat.message": async (input) => {
+      if (!input?.sessionID)
+        return;
+      if (await isSubagentSession(input.sessionID))
+        return;
+      activeOpencodeSessionId = input.sessionID;
+      if (sessionTitles.has(input.sessionID)) {
+        pluginSessionLabel = sessionTitles.get(input.sessionID);
+        return;
+      }
+      await ensureSessionTitle(input.sessionID);
+    },
+    tool: {
+      chrome_status: {
+        description: "Report OpenCode Chrome Annotation local server, session, tab claim, and last annotation status.",
+        args: {},
+        execute: async () => JSON.stringify(buildStatus(), null, 2)
+      }
+    }
+  };
+};
+var plugin_default = plugin;
+export {
+  plugin_default as default
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "opencode-annotate",
+  "version": "1.2.0",
+  "description": "Annotate webpages in Chrome and send screenshots + element context to your OpenCode session. Fork of JodusNodus/opencode-chrome-annotation.",
+  "type": "module",
+  "main": "./dist/plugin.js",
+  "exports": {
+    ".": "./dist/plugin.js",
+    "./plugin": "./dist/plugin.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun build src/plugin.ts --target=node --outfile=dist/plugin.js",
+    "build:extension": "node scripts/build-extension.mjs",
+    "typecheck": "tsc --noEmit",
+    "check:extension": "npm run build:extension && node --check extension/background.js && node --check extension/injected/dom.js && node -e \"JSON.parse(require('fs').readFileSync('extension/manifest.json','utf8'))\"",
+    "dev": "bun run build",
+    "dev:setup": "bun run build",
+    "build:zip": "node scripts/build-extension-zip.mjs",
+    "icons:generate": "sips -s format png -z 16 16 icon.svg --out extension/icons/icon16.png && sips -s format png -z 48 48 icon.svg --out extension/icons/icon48.png && sips -s format png -z 128 128 icon.svg --out extension/icons/icon128.png",
+    "prepublishOnly": "bun run build",
+    "publish": "node -e \"if (process.env.npm_command === 'publish') process.exit(0); require('child_process').execSync('npm publish --access public', { stdio: 'inherit' });\""
+  },
+  "keywords": [
+    "opencode",
+    "browser",
+    "annotation",
+    "chrome",
+    "plugin",
+    "localhost"
+  ],
+  "author": "Benjamin Shafii",
+  "license": "GPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eagleeyejack/opencode-chrome-annotation.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jodusnodus/opencode-chrome-annotation/issues"
+  },
+  "homepage": "https://github.com/jodusnodus/opencode-chrome-annotation#readme",
+  "peerDependencies": {
+    "@opencode-ai/plugin": "*"
+  },
+  "devDependencies": {
+    "@types/chrome": "*",
+    "@opencode-ai/plugin": "*",
+    "bun-types": "*",
+    "typescript": "*"
+  }
+}