feat(ci): add release workflow and clean up plugin packaging

- Add .github/workflows/release.yml — publishes to npm on v* tag push
- Remove root index.ts re-export; point package.json main/module at src/index.ts
- Add files field to package.json to limit published content to src/
- Add version 0.0.1 to package.json
- Rename OPENCODE_OTLP_HEADERS and OPENCODE_RESOURCE_ATTRIBUTES from bare OTEL_* names; loadConfig copies them to the standard OTEL_* vars before SDK init
- Remove parseHeaders from otel.ts (SDK now reads OTEL_EXPORTER_OTLP_HEADERS natively)
- Update tests and docs to reflect all changes

Author: dialupdisaster

.github/workflows/release.yml

@@ -0,0 +1,37 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  release:
+    name: Publish to npm
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          registry-url: "https://registry.npmjs.org"
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Typecheck
+        run: bun run typecheck
+
+      - name: Test
+        run: bun test
+
+      - name: Publish to npm
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

AGENTS.md

@@ -10,11 +10,7 @@ Always run after making changes:
 bun run typecheck
 ```
 
-There is no separate build step needed for local development. For publishing:
-
-```bash
-bun run build
-```
+There is no build step. TypeScript source files are published directly and loaded natively by Bun.
 
 ## Testing
 
@@ -48,7 +44,7 @@ src/
 - **`setBoundedMap`** — always use this instead of `Map.set` for `pendingToolSpans` and `pendingPermissions` to prevent unbounded growth.
 - **Single source of truth for tokens/cost** — token and cost counters are incremented only in `message.updated` (`src/handlers/message.ts`), never in `step-finish`.
 - **Shutdown** — OTel providers are flushed via `SIGTERM`/`SIGINT`/`beforeExit`. Do not use `process.on("exit")` for async flushing.
-- **All env vars are `OPENCODE_` prefixed** — `OPENCODE_ENABLE_TELEMETRY`, `OPENCODE_OTLP_ENDPOINT`, `OPENCODE_OTLP_METRICS_INTERVAL`, `OPENCODE_OTLP_LOGS_INTERVAL`, `OPENCODE_METRIC_PREFIX`. Never use bare `OTEL_*` names for plugin config.
+- **All env vars are `OPENCODE_` prefixed** — `OPENCODE_ENABLE_TELEMETRY`, `OPENCODE_OTLP_ENDPOINT`, `OPENCODE_OTLP_METRICS_INTERVAL`, `OPENCODE_OTLP_LOGS_INTERVAL`, `OPENCODE_METRIC_PREFIX`, `OPENCODE_OTLP_HEADERS`, `OPENCODE_RESOURCE_ATTRIBUTES`. Never use bare `OTEL_*` names for plugin config. `loadConfig` copies `OPENCODE_OTLP_HEADERS` → `OTEL_EXPORTER_OTLP_HEADERS` and `OPENCODE_RESOURCE_ATTRIBUTES` → `OTEL_RESOURCE_ATTRIBUTES` before the SDK initializes.
 - **`OPENCODE_ENABLE_TELEMETRY`** — all OTel instrumentation is gated on this env var. The plugin always loads regardless; only telemetry is disabled when unset.
 - **`OPENCODE_METRIC_PREFIX`** — defaults to `opencode.`; set to `claude_code.` for Claude Code dashboard compatibility.
 

CONTRIBUTING.md

@@ -20,7 +20,7 @@ Point your local opencode config at the repo so changes are picked up immediatel
 ```json
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugin": ["/path/to/opencode-plugin-otel/index.ts"]
+  "plugin": ["/path/to/opencode-plugin-otel/src/index.ts"]
 }
 ```
 
@@ -32,7 +32,6 @@ opencode loads TypeScript natively via Bun, so there is no build step required d
 |---------|-------------|
 | `bun run typecheck` | Type-check all sources without emitting |
 | `bun test` | Run the test suite |
-| `bun run build` | Compile to `dist/` for publishing |
 
 ## Project structure
 

README.md

@@ -45,7 +45,7 @@ Or point directly at a local checkout for development:
 ```json
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugin": ["/path/to/opencode-plugin-otel/index.ts"]
+  "plugin": ["/path/to/opencode-plugin-otel/src/index.ts"]
 }
 ```
 
@@ -60,6 +60,8 @@ All configuration is via environment variables. Set them in your shell profile (
 | `OPENCODE_OTLP_METRICS_INTERVAL` | `60000` | Metrics export interval in milliseconds |
 | `OPENCODE_OTLP_LOGS_INTERVAL` | `5000` | Logs export interval in milliseconds |
 | `OPENCODE_METRIC_PREFIX` | `opencode.` | Prefix for all metric names (e.g. set to `claude_code.` for Claude Code dashboard compatibility) |
+| `OPENCODE_OTLP_HEADERS` | _(unset)_ | Comma-separated `key=value` headers added to all OTLP exports (e.g. for auth tokens) |
+| `OPENCODE_RESOURCE_ATTRIBUTES` | _(unset)_ | Comma-separated `key=value` pairs merged into the OTel resource |
 
 ### Quick start
 

index.ts

@@ -1,14 +1,16 @@
 {
   "name": "opencode-plugin-otel",
-  "module": "index.ts",
+  "version": "0.0.1",
+  "module": "src/index.ts",
+  "main": "src/index.ts",
   "type": "module",
+  "files": [
+    "src/"
+  ],
   "devDependencies": {
     "@types/bun": "latest"
   },
   "scripts": {
-    "release:patch": "npm version patch && npm publish",
-    "release:minor": "npm version minor && npm publish",
-    "release:major": "npm version major && npm publish",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {

package.json

@@ -6,6 +6,8 @@ export type PluginConfig = {
   metricsInterval: number
   logsInterval: number
   metricPrefix: string
+  otlpHeaders: string | undefined
+  resourceAttributes: string | undefined
 }
 
 export function parseEnvInt(key: string, fallback: number): number {
@@ -16,12 +18,20 @@ export function parseEnvInt(key: string, fallback: number): number {
 }
 
 export function loadConfig(): PluginConfig {
+  const otlpHeaders = process.env["OPENCODE_OTLP_HEADERS"]
+  const resourceAttributes = process.env["OPENCODE_RESOURCE_ATTRIBUTES"]
+
+  if (otlpHeaders) process.env["OTEL_EXPORTER_OTLP_HEADERS"] = otlpHeaders
+  if (resourceAttributes) process.env["OTEL_RESOURCE_ATTRIBUTES"] = resourceAttributes
+
   return {
     enabled: !!process.env["OPENCODE_ENABLE_TELEMETRY"],
     endpoint: process.env["OPENCODE_OTLP_ENDPOINT"] ?? "http://localhost:4317",
     metricsInterval: parseEnvInt("OPENCODE_OTLP_METRICS_INTERVAL", 60000),
     logsInterval: parseEnvInt("OPENCODE_OTLP_LOGS_INTERVAL", 5000),
     metricPrefix: process.env["OPENCODE_METRIC_PREFIX"] ?? "opencode.",
+    otlpHeaders,
+    resourceAttributes,
   }
 }
 

src/config.ts

@@ -9,20 +9,6 @@ import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions"
 import { ATTR_HOST_ARCH } from "@opentelemetry/semantic-conventions/incubating"
 import type { Instruments } from "./types.ts"
 
-export function parseHeaders(raw: string | undefined): Record<string, string> {
-  if (!raw) return {}
-  const result: Record<string, string> = {}
-  for (const pair of raw.split(",")) {
-    const idx = pair.indexOf("=")
-    if (idx > 0) {
-      const key = pair.slice(0, idx).trim()
-      const val = pair.slice(idx + 1).trim()
-      if (key) result[key] = val
-    }
-  }
-  return result
-}
-
 export function buildResource(version: string) {
   const attrs: Record<string, string> = {
     [ATTR_SERVICE_NAME]: "opencode",
@@ -55,14 +41,13 @@ export function setupOtel(
   logsInterval: number,
   version: string,
 ): OtelProviders {
-  const headers = parseHeaders(process.env["OTEL_EXPORTER_OTLP_HEADERS"])
   const resource = buildResource(version)
 
   const meterProvider = new MeterProvider({
     resource,
     readers: [
       new PeriodicExportingMetricReader({
-        exporter: new OTLPMetricExporter({ url: endpoint, headers }),
+        exporter: new OTLPMetricExporter({ url: endpoint }),
         exportIntervalMillis: metricsInterval,
       }),
     ],
@@ -72,7 +57,7 @@ export function setupOtel(
   const loggerProvider = new LoggerProvider({
     resource,
     processors: [
-      new BatchLogRecordProcessor(new OTLPLogExporter({ url: endpoint, headers }), {
+      new BatchLogRecordProcessor(new OTLPLogExporter({ url: endpoint }), {
         scheduledDelayMillis: logsInterval,
       }),
     ],

src/otel.ts

@@ -38,9 +38,13 @@ describe("parseEnvInt", () => {
 describe("loadConfig", () => {
   const vars = [
     "OPENCODE_ENABLE_TELEMETRY",
-    "OTEL_EXPORTER_OTLP_ENDPOINT",
-    "OTEL_METRIC_EXPORT_INTERVAL",
-    "OTEL_LOGS_EXPORT_INTERVAL",
+    "OPENCODE_OTLP_ENDPOINT",
+    "OPENCODE_OTLP_METRICS_INTERVAL",
+    "OPENCODE_OTLP_LOGS_INTERVAL",
+    "OPENCODE_OTLP_HEADERS",
+    "OPENCODE_RESOURCE_ATTRIBUTES",
+    "OTEL_EXPORTER_OTLP_HEADERS",
+    "OTEL_RESOURCE_ATTRIBUTES",
   ]
   beforeEach(() => vars.forEach((k) => delete process.env[k]))
   afterEach(() => vars.forEach((k) => delete process.env[k]))
@@ -59,25 +63,43 @@ describe("loadConfig", () => {
   })
 
   test("reads custom endpoint", () => {
-    process.env["OTEL_EXPORTER_OTLP_ENDPOINT"] = "http://collector:4317"
+    process.env["OPENCODE_OTLP_ENDPOINT"] = "http://collector:4317"
     expect(loadConfig().endpoint).toBe("http://collector:4317")
   })
 
   test("reads custom intervals", () => {
-    process.env["OTEL_METRIC_EXPORT_INTERVAL"] = "30000"
-    process.env["OTEL_LOGS_EXPORT_INTERVAL"] = "2000"
+    process.env["OPENCODE_OTLP_METRICS_INTERVAL"] = "30000"
+    process.env["OPENCODE_OTLP_LOGS_INTERVAL"] = "2000"
     const cfg = loadConfig()
     expect(cfg.metricsInterval).toBe(30000)
     expect(cfg.logsInterval).toBe(2000)
   })
 
   test("falls back to defaults for invalid interval values", () => {
-    process.env["OTEL_METRIC_EXPORT_INTERVAL"] = "notanumber"
-    process.env["OTEL_LOGS_EXPORT_INTERVAL"] = "0"
+    process.env["OPENCODE_OTLP_METRICS_INTERVAL"] = "notanumber"
+    process.env["OPENCODE_OTLP_LOGS_INTERVAL"] = "0"
     const cfg = loadConfig()
     expect(cfg.metricsInterval).toBe(60000)
     expect(cfg.logsInterval).toBe(5000)
   })
+
+  test("copies OPENCODE_OTLP_HEADERS to OTEL_EXPORTER_OTLP_HEADERS", () => {
+    process.env["OPENCODE_OTLP_HEADERS"] = "api-key=abc123"
+    loadConfig()
+    expect(process.env["OTEL_EXPORTER_OTLP_HEADERS"]).toBe("api-key=abc123")
+  })
+
+  test("copies OPENCODE_RESOURCE_ATTRIBUTES to OTEL_RESOURCE_ATTRIBUTES", () => {
+    process.env["OPENCODE_RESOURCE_ATTRIBUTES"] = "team=platform,env=prod"
+    loadConfig()
+    expect(process.env["OTEL_RESOURCE_ATTRIBUTES"]).toBe("team=platform,env=prod")
+  })
+
+  test("does not set OTEL_EXPORTER_OTLP_HEADERS when OPENCODE_OTLP_HEADERS is unset", () => {
+    delete process.env["OPENCODE_OTLP_HEADERS"]
+    loadConfig()
+    expect(process.env["OTEL_EXPORTER_OTLP_HEADERS"]).toBeUndefined()
+  })
 })
 
 describe("resolveLogLevel", () => {

tests/config.test.ts

@@ -1,38 +1,5 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test"
-import { parseHeaders, buildResource } from "../src/otel.ts"
-
-describe("parseHeaders", () => {
-  test("returns empty object for undefined", () => {
-    expect(parseHeaders(undefined)).toEqual({})
-  })
-
-  test("returns empty object for empty string", () => {
-    expect(parseHeaders("")).toEqual({})
-  })
-
-  test("parses a single key=value pair", () => {
-    expect(parseHeaders("api-key=abc123")).toEqual({ "api-key": "abc123" })
-  })
-
-  test("parses multiple comma-separated pairs", () => {
-    expect(parseHeaders("api-key=abc,x-tenant=foo")).toEqual({
-      "api-key": "abc",
-      "x-tenant": "foo",
-    })
-  })
-
-  test("trims whitespace around keys and values", () => {
-    expect(parseHeaders(" api-key = abc123 ")).toEqual({ "api-key": "abc123" })
-  })
-
-  test("ignores pairs with no = sign", () => {
-    expect(parseHeaders("no-equals,api-key=abc")).toEqual({ "api-key": "abc" })
-  })
-
-  test("handles values containing = signs", () => {
-    expect(parseHeaders("token=abc=def")).toEqual({ token: "abc=def" })
-  })
-})
+import { describe, test, expect, afterEach } from "bun:test"
+import { buildResource } from "../src/otel.ts"
 
 describe("buildResource", () => {
   const originalEnv = process.env["OTEL_RESOURCE_ATTRIBUTES"]