@pragma-sh/opencode-plugin 0.1.0-alpha.0

package/dist/pragma-plugin.mjs

@@ -0,0 +1,586 @@
+// ../plugin/dist/shared/chunk-k5kqv14t.js
+var PLUGIN_API_VERSION = "0.0.0";
+
+// ../plugin/dist/shared/chunk-0rpz2gg0.js
+function defineAgent(input) {
+  return input;
+}
+function definePlugin(input) {
+  return { ...input, __apiVersion: PLUGIN_API_VERSION };
+}
+function defineUsageLimitProvider(input) {
+  return input;
+}
+
+// ../watcher-kit/src/index.ts
+var DEFAULT_APPROVE_KEYS = "\r";
+var RIGHT_ARROW = "\x1B[C";
+var DOWN_ARROW = "\x1B[B";
+var DEFAULT_DENY_KEYS = `${RIGHT_ARROW}${RIGHT_ARROW}\r`;
+var DEFAULT_SUBMIT_KEYS = "\r";
+var BRACKETED_PASTE_START = "\x1B[200~";
+var BRACKETED_PASTE_END = "\x1B[201~";
+var QUESTION_REJECT_KEYS = "\x1B";
+var QUESTION_DIGIT_MAX = 9;
+var QUESTION_PROMPT_MOUNT_DELAY_MS = 150;
+var QUESTION_OTHER_INPUT_DELAY_MS = 150;
+var QUESTION_NEXT_PROMPT_DELAY_MS = 500;
+var ANSWER_SEPARATOR = "\x1F";
+var RESUBSCRIBE_DELAY_MS = 500;
+var DEFAULT_INTERJECT_SUBMIT_DELAY_MS = 200;
+function createTuiWatcher(options) {
+  const {
+    agent,
+    handleDecisions,
+    handleQuestionAnswers = handleDecisions,
+    interjectSubmitDelayMs = DEFAULT_INTERJECT_SUBMIT_DELAY_MS,
+    interjectMode = "bracketed",
+    interjectSubmitKeys,
+    questionSelectMode = "digit",
+    questionOtherMode = "navigate-enter",
+    questionDismissKeys = QUESTION_REJECT_KEYS,
+    questionFinalizeKeys = ""
+  } = options;
+  return {
+    agent,
+    async watch(ctx) {
+      const watcherContext = ctx;
+      const runtime = {
+        keys: resolveKeys(watcherContext.config, interjectSubmitKeys),
+        handleDecisions,
+        handleQuestionAnswers,
+        interjectSubmitDelayMs,
+        interjectMode,
+        questionSelectMode,
+        questionOtherMode,
+        questionDismissKeys,
+        questionFinalizeKeys,
+        seenRequestIds: new Set,
+        questionsByRequestId: new Map,
+        outstandingCommandRequestId: null
+      };
+      let failures = 0;
+      while (!ctx.signal.aborted) {
+        try {
+          await consumeControlEvents(watcherContext, runtime);
+          failures = 0;
+        } catch (error) {
+          failures += 1;
+          reportStreamFailure(agent, failures, error);
+        }
+        if (ctx.signal.aborted) {
+          return;
+        }
+        await delay(RESUBSCRIBE_DELAY_MS, ctx.signal);
+      }
+    }
+  };
+}
+function reportStreamFailure(agent, consecutive, error) {
+  if (consecutive !== 1 && consecutive % STREAM_FAILURE_LOG_EVERY !== 0) {
+    return;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn(JSON.stringify({ type: "watcher.streamError", agent, consecutive, error: message }));
+}
+var STREAM_FAILURE_LOG_EVERY = 240;
+function resolveKeys(config, interjectSubmitKeys) {
+  const c = config ?? {};
+  return {
+    approveKeys: c.approveKeys ?? DEFAULT_APPROVE_KEYS,
+    denyKeys: c.denyKeys ?? DEFAULT_DENY_KEYS,
+    submitKeys: c.submitKeys ?? interjectSubmitKeys ?? DEFAULT_SUBMIT_KEYS
+  };
+}
+async function consumeControlEvents(ctx, runtime) {
+  const connection = await ctx.sdk.agents.connect({
+    agent: ctx.agentId,
+    tabId: ctx.session.tabId,
+    worktreeId: ctx.session.worktreeId,
+    signal: ctx.signal
+  });
+  for await (const event of connection) {
+    if (ctx.signal.aborted) {
+      return;
+    }
+    await handleControlEvent(ctx, runtime, event);
+  }
+}
+async function handleControlEvent(ctx, runtime, event) {
+  if (event.type === "agent") {
+    if (runtime.handleQuestionAnswers)
+      rememberQuestion(runtime.questionsByRequestId, event);
+    if (runtime.handleDecisions)
+      rememberCommandAttention(runtime, event);
+    return;
+  }
+  if (runtime.handleDecisions && await handleDecision(ctx, runtime, event)) {
+    return;
+  }
+  if (runtime.handleQuestionAnswers && await handleAnswer(ctx, runtime, event)) {
+    return;
+  }
+  if (event.type === "agentInput") {
+    await handleInterjection(ctx, runtime.keys.submitKeys, runtime.interjectSubmitDelayMs, runtime.interjectMode, event.input.text);
+  }
+}
+async function handleDecision(ctx, runtime, event) {
+  if (event.type !== "agentDecision")
+    return false;
+  if (runtime.seenRequestIds.has(event.decision.requestId))
+    return true;
+  runtime.seenRequestIds.add(event.decision.requestId);
+  if (runtime.outstandingCommandRequestId !== null && runtime.outstandingCommandRequestId !== event.decision.requestId) {
+    return true;
+  }
+  runtime.outstandingCommandRequestId = null;
+  await writeKeys(ctx, event.decision.approved ? runtime.keys.approveKeys : runtime.keys.denyKeys);
+  return true;
+}
+async function handleAnswer(ctx, runtime, event) {
+  if (event.type !== "agentAnswer")
+    return false;
+  const { answer } = event;
+  const cached = runtime.questionsByRequestId.get(answer.requestId);
+  if (!cached)
+    return true;
+  if (runtime.seenRequestIds.has(answer.requestId))
+    return true;
+  runtime.seenRequestIds.add(answer.requestId);
+  runtime.questionsByRequestId.delete(answer.requestId);
+  await delay(QUESTION_PROMPT_MOUNT_DELAY_MS, ctx.signal);
+  if (ctx.signal.aborted)
+    return true;
+  const reply = answer.answer?.trim() ?? null;
+  if (cached.questions.length > 1) {
+    if (!answer.dismissed && reply) {
+      await writeMultipleQuestionAnswers(ctx, runtime, cached.questions, reply);
+    } else if (answer.dismissed || !reply) {
+      await writeKeys(ctx, runtime.questionDismissKeys);
+    }
+    return true;
+  }
+  const single = cached.questions[0] ?? { question: "", options: [] };
+  await writeQuestionAnswer(ctx, runtime, single, reply, answer.dismissed);
+  if (!answer.dismissed && reply)
+    await finalizeQuestionAnswers(ctx, runtime);
+  return true;
+}
+async function writeQuestionAnswer(ctx, runtime, question, reply, dismissed) {
+  if (dismissed || !reply) {
+    await writeKeys(ctx, runtime.questionDismissKeys);
+    return;
+  }
+  if (!dismissed && reply && !question.options.includes(reply)) {
+    await writeFreeTextAnswer(ctx, question.options.length, reply, runtime.questionSelectMode, runtime.questionOtherMode);
+    return;
+  }
+  const strokes = questionAnswerKeys({
+    dismissed,
+    reply,
+    options: question.options,
+    selectMode: runtime.questionSelectMode
+  });
+  if (strokes)
+    await writeKeys(ctx, strokes);
+}
+async function writeFreeTextAnswer(ctx, optionCount, reply, selectMode, otherMode) {
+  await writeKeys(ctx, openOtherEditorKeys(optionCount, selectMode, otherMode));
+  await delay(QUESTION_OTHER_INPUT_DELAY_MS, ctx.signal);
+  if (!ctx.signal.aborted)
+    await writeKeys(ctx, `${reply}\r`);
+}
+async function writeMultipleQuestionAnswers(ctx, runtime, questions, combined) {
+  const replies = combined.split(ANSWER_SEPARATOR).map((reply) => reply.trim());
+  for (const [index, question] of questions.entries()) {
+    const reply = replies[index];
+    if (!reply || ctx.signal.aborted)
+      return;
+    await writeQuestionAnswer(ctx, runtime, question, reply, false);
+    if (index < questions.length - 1) {
+      await delay(QUESTION_NEXT_PROMPT_DELAY_MS, ctx.signal);
+    }
+  }
+  await finalizeQuestionAnswers(ctx, runtime);
+}
+async function finalizeQuestionAnswers(ctx, runtime) {
+  if (!runtime.questionFinalizeKeys || ctx.signal.aborted)
+    return;
+  await delay(QUESTION_NEXT_PROMPT_DELAY_MS, ctx.signal);
+  if (!ctx.signal.aborted)
+    await writeKeys(ctx, runtime.questionFinalizeKeys);
+}
+async function handleInterjection(ctx, submitKeys, submitDelayMs, mode, text) {
+  const input = mode === "plain" ? text : `${BRACKETED_PASTE_START}${text}${BRACKETED_PASTE_END}`;
+  await writeKeys(ctx, input);
+  if (!submitKeys) {
+    return;
+  }
+  await delay(submitDelayMs, ctx.signal);
+  if (!ctx.signal.aborted)
+    await writeKeys(ctx, submitKeys);
+}
+function rememberCommandAttention(runtime, event) {
+  if (event.status === "attention" && event.attentionKind === "command" && typeof event.requestId === "string" && event.requestId.length > 0) {
+    runtime.outstandingCommandRequestId = event.requestId;
+    return;
+  }
+  if (event.status !== "attention") {
+    runtime.outstandingCommandRequestId = null;
+  }
+}
+function rememberQuestion(cache, event) {
+  if (event.status === "attention" && event.attentionKind === "question" && typeof event.requestId === "string" && event.requestId.length > 0) {
+    const entries = (event.questions ?? []).flatMap(questionEntry);
+    if (entries.length > 0) {
+      cache.set(event.requestId, { questions: entries });
+      return;
+    }
+    const options = (event.options ?? []).map((option) => option.label).filter((option) => option.trim() !== "");
+    cache.set(event.requestId, {
+      questions: [{ question: event.question ?? "", options }]
+    });
+  }
+}
+function questionEntry(value) {
+  if (typeof value !== "object" || value === null || !("question" in value)) {
+    return [];
+  }
+  const record = value;
+  if (typeof record.question !== "string" || !record.question.trim()) {
+    return [];
+  }
+  const options = Array.isArray(record.options) ? record.options.filter((option) => Boolean(option) && typeof option === "object").map((option) => option.label).filter((label) => typeof label === "string" && label.trim() !== "") : [];
+  return [{ question: record.question, options }];
+}
+function questionAnswerKeys(input) {
+  if (input.dismissed || input.reply === null) {
+    return QUESTION_REJECT_KEYS;
+  }
+  const reply = input.reply.trim();
+  if (!reply) {
+    return QUESTION_REJECT_KEYS;
+  }
+  const options = input.options;
+  const selectMode = input.selectMode ?? "digit";
+  const matchIndex = options.findIndex((option) => option === reply);
+  if (matchIndex >= 0) {
+    return selectOptionKeys(matchIndex, options.length, selectMode);
+  }
+  return `${openOtherEditorKeys(options.length, selectMode, "navigate-enter")}${reply}\r`;
+}
+function openOtherEditorKeys(optionCount, selectMode, otherMode) {
+  if (otherMode === "shortcut-z")
+    return "z";
+  const navigate = DOWN_ARROW.repeat(optionCount);
+  return selectMode === "arrow-space" || otherMode === "navigate" ? navigate : `${navigate}\r`;
+}
+function selectOptionKeys(index, optionCount, selectMode) {
+  if (selectMode === "arrow-space") {
+    return `${DOWN_ARROW.repeat(index)} \r`;
+  }
+  const total = optionCount + 1;
+  if (index < QUESTION_DIGIT_MAX && index < total) {
+    return String(index + 1);
+  }
+  return `${DOWN_ARROW.repeat(index)}\r`;
+}
+async function writeKeys(ctx, data) {
+  try {
+    await ctx.sendKeys(data);
+  } catch {}
+}
+function delay(ms, signal) {
+  if (signal.aborted) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    const finish = () => resolve();
+    const timer = setTimeout(finish, ms);
+    signal.addEventListener("abort", () => {
+      clearTimeout(timer);
+      finish();
+    }, { once: true });
+  });
+}
+
+// src/cwd.ts
+function pluginCwd(ctx) {
+  return ctx.project?.path ?? "/tmp";
+}
+
+// src/usage-limits.ts
+var FIVE_HOURS_MS = 5 * 60 * 60 * 1000;
+var GO_LIMITS = {
+  rolling: 12,
+  weekly: 30,
+  monthly: 60
+};
+var USAGE_QUERY = `
+WITH bounds AS (
+  SELECT
+    CAST(strftime('%s', 'now') AS INTEGER) * 1000 AS observed_at,
+    CAST(strftime('%s', datetime('now', 'start of day', printf('-%d days', (CAST(strftime('%w', 'now') AS INTEGER) + 6) % 7))) AS INTEGER) * 1000 AS week_start,
+    CAST(strftime('%s', 'now', 'start of month') AS INTEGER) * 1000 AS month_start,
+    CAST(strftime('%s', 'now', 'start of month', '+1 month') AS INTEGER) * 1000 AS month_end
+), usage AS (
+  SELECT
+    bounds.*,
+    COALESCE(SUM(CASE WHEN time_created >= observed_at - ${FIVE_HOURS_MS} THEN CAST(json_extract(data, '$.cost') AS REAL) ELSE 0 END), 0) AS rolling_used,
+    MIN(CASE WHEN time_created >= observed_at - ${FIVE_HOURS_MS} THEN time_created END) AS rolling_start,
+    COALESCE(SUM(CASE WHEN time_created >= week_start THEN CAST(json_extract(data, '$.cost') AS REAL) ELSE 0 END), 0) AS weekly_used,
+    COALESCE(SUM(CASE WHEN time_created >= month_start THEN CAST(json_extract(data, '$.cost') AS REAL) ELSE 0 END), 0) AS monthly_used,
+    COUNT(message.id) AS message_count
+  FROM bounds
+  LEFT JOIN message ON json_extract(data, '$.role') = 'assistant'
+    AND json_extract(data, '$.providerID') = 'opencode-go'
+)
+SELECT
+  observed_at AS observedAt,
+  rolling_used AS rollingUsed,
+  CASE WHEN rolling_start IS NULL THEN NULL ELSE rolling_start + ${FIVE_HOURS_MS} END AS rollingResetsAt,
+  weekly_used AS weeklyUsed,
+  week_start + ${7 * 24 * 60 * 60 * 1000} AS weeklyResetsAt,
+  monthly_used AS monthlyUsed,
+  month_end AS monthlyResetsAt,
+  message_count AS messageCount
+FROM usage
+`.trim();
+function usageCommand() {
+  return globalThis.process?.platform === "win32" ? `if (-not (Get-Command opencode -ErrorAction SilentlyContinue)) { exit 20 }; opencode db ${powershellQuote(USAGE_QUERY)} --format json` : "command -v opencode >/dev/null 2>&1 || exit 20; " + `opencode db ${shellQuote(USAGE_QUERY)} --format json`;
+}
+async function loadOpenCodeGoUsageLimits(ctx) {
+  const [result] = await ctx.sdk.exec.run({
+    cwd: pluginCwd(ctx),
+    commands: [usageCommand()]
+  });
+  if (result?.status === 20) {
+    return {
+      status: "unavailable",
+      reason: "not-configured",
+      message: "Install OpenCode to load OpenCode Go usage limits."
+    };
+  }
+  if (!result || result.status !== 0) {
+    throw new Error(result?.stderr.trim() || "OpenCode Go usage query failed");
+  }
+  return parseOpenCodeGoUsage(result.stdout);
+}
+function parseOpenCodeGoUsage(stdout) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    throw new Error("OpenCode Go usage query returned invalid JSON");
+  }
+  const row = Array.isArray(parsed) ? parsed[0] : null;
+  if (!isRecord(row)) {
+    throw new Error("OpenCode Go usage query returned no aggregate row");
+  }
+  const messageCount = finiteNumber(row.messageCount);
+  if (messageCount === null) {
+    throw new Error("OpenCode Go usage query returned a malformed message count");
+  }
+  if (messageCount === 0) {
+    return {
+      status: "unavailable",
+      reason: "unsupported",
+      message: "No device-local OpenCode Go usage was found."
+    };
+  }
+  const observedAt = requiredNumber(row.observedAt, "observation time");
+  const limits = [
+    usageLimit("rolling", "5-hour limit", row.rollingUsed, GO_LIMITS.rolling, row.rollingResetsAt, observedAt),
+    usageLimit("weekly", "Weekly limit", row.weeklyUsed, GO_LIMITS.weekly, row.weeklyResetsAt, observedAt),
+    usageLimit("monthly", "Monthly limit", row.monthlyUsed, GO_LIMITS.monthly, row.monthlyResetsAt, observedAt)
+  ];
+  return { status: "ready", observedAt, limits };
+}
+function usageLimit(id, title, usedValue, limit, resetsAtValue, observedAt) {
+  const used = requiredNumber(usedValue, `${title} usage`);
+  const resetsAt = finiteNumber(resetsAtValue);
+  return {
+    id,
+    title,
+    used: Math.max(0, used),
+    limit,
+    ...resetsAt === null ? {} : { resetsInMs: Math.max(0, resetsAt - observedAt) }
+  };
+}
+function requiredNumber(value, field) {
+  const number = finiteNumber(value);
+  if (number === null) {
+    throw new Error(`OpenCode Go usage query returned malformed ${field}`);
+  }
+  return number;
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function powershellQuote(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+
+// src/pragma-plugin.ts
+var ansiEscapePattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*[A-Za-z]`, "g");
+var opencodeAgentPlugin = definePlugin({
+  name: "OpenCode",
+  description: "Launch OpenCode from Pragma.",
+  watchers: [
+    createTuiWatcher({
+      agent: "opencode",
+      handleDecisions: true,
+      questionFinalizeKeys: "\r"
+    })
+  ],
+  usageLimits: [
+    defineUsageLimitProvider({
+      id: "opencode-go",
+      title: "OpenCode Go",
+      dashboardUrl: "https://opencode.ai/auth",
+      iconPath: "assets/opencode.svg",
+      primaryLimitId: "rolling",
+      load: loadOpenCodeGoUsageLimits
+    })
+  ],
+  agents: [
+    defineAgent({
+      id: "opencode",
+      name: "OpenCode",
+      icon: () => null,
+      iconPath: "assets/opencode.svg",
+      launch: { command: ["opencode"] },
+      prefillDelayMs: 6000,
+      models: async (ctx) => parseOpenCodeModels(await execFirst(ctx, "opencode models --json 2>/dev/null || opencode models --verbose 2>/dev/null || opencode models 2>/dev/null")),
+      permissionModes: [],
+      args: {
+        model: (modelId) => ["--model", modelId],
+        reasoning: () => [],
+        permissionMode: () => []
+      }
+    })
+  ]
+});
+var pragma_plugin_default = opencodeAgentPlugin;
+async function execFirst(ctx, command) {
+  const [result] = await ctx.sdk.exec.run({ cwd: pluginCwd(ctx), commands: [command] });
+  return result?.stdout ?? "";
+}
+function parseOpenCodeModels(output) {
+  const jsonModels = parseJsonModels(output);
+  if (jsonModels.length > 0) {
+    return jsonModels;
+  }
+  return output.replaceAll(ansiEscapePattern, "").split(`
+`).map((line) => line.trim().replace(/^│|│$/g, "").trim()).flatMap(modelFromLine);
+}
+function modelFromLine(line) {
+  if (isModelTableDecoration(line))
+    return [];
+  const model = parseModelLine(line);
+  return model ? [model] : [];
+}
+function parseModelLine(line) {
+  const [id, name] = modelColumns(line);
+  if (!id)
+    return null;
+  if (!name)
+    return null;
+  if (/\s/.test(id))
+    return null;
+  return { id, name: withProvider(id, name) };
+}
+function modelColumns(line) {
+  if (!line.includes(" - "))
+    return splitWhitespaceModel(line);
+  const [id, name] = line.split(" - ", 2);
+  return [id, name];
+}
+function isModelTableDecoration(line) {
+  return !line || /^(model|provider|tip|usage)/i.test(line) || /^[─━│┃┌┐└┘├┤┬┴┼\-+]+$/.test(line);
+}
+function parseJsonModels(output) {
+  try {
+    const parsed = JSON.parse(output);
+    const models = [];
+    walk(parsed, models);
+    return uniqueModels(models);
+  } catch {
+    return [];
+  }
+}
+function walk(value, models) {
+  if (Array.isArray(value)) {
+    for (const child of value)
+      walk(child, models);
+    return;
+  }
+  if (!isRecord2(value)) {
+    return;
+  }
+  const model = modelFromRecord(value);
+  if (model) {
+    models.push(model);
+  }
+  for (const child of Object.values(value))
+    walk(child, models);
+}
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object";
+}
+function modelFromRecord(record) {
+  const id = firstString(record.id, record.model);
+  const name = modelName(record, id);
+  if (!id || !name || !hasModelMetadata(record)) {
+    return null;
+  }
+  return { id, name: withProvider(id, name, stringValue(record.provider)) };
+}
+function firstString(...values) {
+  for (const value of values) {
+    const string = stringValue(value);
+    if (string)
+      return string;
+  }
+  return;
+}
+function modelName(record, id) {
+  return stringValue(record.name) ?? stringValue(record.displayName) ?? stringValue(record.label) ?? id;
+}
+function hasModelMetadata(record) {
+  return Boolean(record.provider || record.cost || record.limits || record.modalities);
+}
+function uniqueModels(models) {
+  const seen = new Set;
+  return models.filter((model) => {
+    if (seen.has(model.id))
+      return false;
+    seen.add(model.id);
+    return true;
+  });
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function splitWhitespaceModel(line) {
+  const parts = line.split(/\s+/);
+  const id = parts[0];
+  return id?.includes("/") ? [id, parts.slice(1).join(" ") || displayName(id)] : [undefined, undefined];
+}
+function displayName(id) {
+  return id.split("/").at(-1)?.replaceAll(/[-_]/g, " ") ?? id;
+}
+function withProvider(id, name, provider = id.includes("/") ? id.split("/", 1)[0] : "") {
+  return provider && !name.endsWith(`(${provider})`) ? `${name} (${provider})` : name;
+}
+export {
+  parseOpenCodeModels,
+  opencodeAgentPlugin,
+  pragma_plugin_default as default
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@pragma-sh/opencode-plugin",
+  "version": "0.1.0-alpha.0",
+  "description": "opencode plugin that reports agent status to Pragma automatically.",
+  "license": "AGPL-3.0-only",
+  "files": [
+    "assets",
+    "dist",
+    "pragma-plugin.json",
+    "scripts"
+  ],
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bun build src/index.ts src/pragma-plugin.ts --outdir dist --format esm --target node --packages bundle && mv dist/index.js dist/index.mjs && mv dist/pragma-plugin.js dist/pragma-plugin.mjs",
+    "prepack": "bun run build",
+    "typecheck": "tsc -p tsconfig.typecheck.json --noEmit",
+    "test": "bun --bun vitest run",
+    "lint": "oxlint ."
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.17.8",
+    "@pragma/plugin": "workspace:*",
+    "@pragma/sdk": "workspace:*",
+    "@pragma/watcher-kit": "workspace:*",
+    "@types/node": "^24.12.3",
+    "bunup": "^0.16.32",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8"
+  },
+  "pragma": {
+    "pluginId": "pragma.opencode",
+    "main": "./dist/pragma-plugin.mjs"
+  }
+}

package/pragma-plugin.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://raw.githubusercontent.com/pragma-sh/pragma/main/packages/plugin-registry/pragma-plugin.schema.json",
+  "name": "OpenCode",
+  "description": "Launch OpenCode in Pragma with streaming status, approvals, questions, and usage limits.",
+  "categories": ["agent-plugin"],
+  "images": [
+    {
+      "url": "https://raw.githubusercontent.com/pragma-sh/pragma/main/packages/opencode-plugin/assets/opencode.svg",
+      "alt": "OpenCode logo"
+    }
+  ],
+  "install": { "command": "node", "args": ["scripts/install.mjs"] },
+  "agentBinary": "opencode"
+}

package/scripts/install.mjs

@@ -0,0 +1,23 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+const configPath =
+  process.env.OPENCODE_CONFIG ?? join(homedir(), ".config", "opencode", "opencode.json");
+let config = {};
+try {
+  config = JSON.parse(await readFile(configPath, "utf8"));
+} catch (error) {
+  if (error?.code !== "ENOENT") {
+    throw new Error(
+      `${configPath} must be valid JSON before Pragma can install its OpenCode plugin`,
+      { cause: error },
+    );
+  }
+}
+const plugins = Array.isArray(config.plugin) ? config.plugin : [];
+if (!plugins.includes("@pragma-sh/opencode-plugin")) plugins.push("@pragma-sh/opencode-plugin");
+await mkdir(dirname(configPath), { recursive: true });
+await writeFile(configPath, `${JSON.stringify({ ...config, plugin: plugins }, null, 2)}\n`, {
+  mode: 0o600,
+});