@anyforge/control 0.12.0 → 0.13.0

package/dist/opencode-plugin.js

@@ -0,0 +1,398 @@
+// src/opencodePlugin/plugin.ts
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// src/opencodePlugin/exporter.ts
+var SCOPE = { name: "anyforge-opencode-plugin" };
+var MAX_BUFFERED_LOGS = 2e3;
+var LOGS_PER_EXPORT = 1e3;
+var TelemetryExporter = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  logs = [];
+  usage = /* @__PURE__ */ new Map();
+  stopped = false;
+  sending = null;
+  addLogs(records) {
+    if (this.stopped || records.length === 0) return;
+    this.logs.push(...records);
+    const max = this.options.maxBufferedLogs ?? MAX_BUFFERED_LOGS;
+    if (this.logs.length > max) this.logs.splice(0, this.logs.length - max);
+  }
+  addUsage(readings) {
+    if (this.stopped) return;
+    for (const r of readings) {
+      const sum = this.usage.get(r.model) ?? { model: r.model, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, costUsd: 0 };
+      sum.input += r.input;
+      sum.output += r.output;
+      sum.cacheRead += r.cacheRead;
+      sum.cacheWrite += r.cacheWrite;
+      sum.costUsd += r.costUsd;
+      this.usage.set(r.model, sum);
+    }
+  }
+  /** Has a key refusal stopped this exporter? */
+  get disabled() {
+    return this.stopped;
+  }
+  /** Send what is buffered. Never throws; concurrent calls share one send. */
+  flush(nowMs = Date.now()) {
+    if (!this.sending) this.sending = this.send(nowMs).finally(() => {
+      this.sending = null;
+    });
+    return this.sending;
+  }
+  async send(nowMs) {
+    if (this.stopped) return;
+    if (this.usage.size > 0) {
+      const usage = [...this.usage.values()];
+      this.usage = /* @__PURE__ */ new Map();
+      const status = await this.post("/api/otel/v1/metrics", metricsBody(this.options.resource, usage, nowMs));
+      if (!ok(status) && !this.stopped) this.addUsage(usage);
+    }
+    while (this.logs.length > 0 && !this.stopped) {
+      const batch = this.logs.slice(0, LOGS_PER_EXPORT);
+      const status = await this.post("/api/otel/v1/logs", logsBody(this.options.resource, batch));
+      if (!ok(status)) return;
+      this.logs.splice(0, batch.length);
+    }
+  }
+  async post(path, body) {
+    try {
+      const res = await this.options.fetch(`${this.options.endpoint}${path}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${this.options.apiKey}` },
+        body: JSON.stringify(body)
+      });
+      if (res.status === 401 || res.status === 403) {
+        this.stopped = true;
+        this.logs = [];
+        this.usage = /* @__PURE__ */ new Map();
+      }
+      return res.status;
+    } catch {
+      return null;
+    }
+  }
+};
+function ok(status) {
+  return status !== null && status >= 200 && status < 300;
+}
+function logsBody(resource, records) {
+  return { resourceLogs: [{ resource: { attributes: resource }, scopeLogs: [{ scope: SCOPE, logRecords: records }] }] };
+}
+function metricsBody(resource, usage, nowMs) {
+  const time = `${Math.floor(nowMs)}000000`;
+  const model = (m) => ({ key: "model", value: { stringValue: m } });
+  const tokenPoints = usage.flatMap((u) => [
+    ["input", u.input],
+    ["output", u.output],
+    ["cacheRead", u.cacheRead],
+    ["cacheCreation", u.cacheWrite]
+  ].filter(([, n]) => n > 0).map(([type, n]) => ({
+    attributes: [{ key: "type", value: { stringValue: type } }, model(u.model)],
+    asInt: String(Math.round(n)),
+    timeUnixNano: time
+  })));
+  const costPoints = usage.filter((u) => u.costUsd > 0).map((u) => ({ attributes: [model(u.model)], asDouble: u.costUsd, timeUnixNano: time }));
+  const sum = (dataPoints) => ({ aggregationTemporality: 1, isMonotonic: true, dataPoints });
+  return {
+    resourceMetrics: [{
+      resource: { attributes: resource },
+      scopeMetrics: [{
+        scope: SCOPE,
+        metrics: [
+          ...tokenPoints.length ? [{ name: "opencode.token.usage", unit: "tokens", sum: sum(tokenPoints) }] : [],
+          ...costPoints.length ? [{ name: "opencode.cost.usage", unit: "USD", sum: sum(costPoints) }] : []
+        ]
+      }]
+    }]
+  };
+}
+
+// src/opencodePlugin/translate.ts
+var EMPTY = { logs: [], usage: [] };
+var MAX_REMEMBERED = 5e3;
+var Remembered = class {
+  map = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.map.get(key);
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  set(key, value) {
+    this.map.delete(key);
+    this.map.set(key, value);
+    if (this.map.size > MAX_REMEMBERED) {
+      const oldest = this.map.keys().next().value;
+      if (oldest !== void 0) this.map.delete(oldest);
+    }
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function attr(key, value) {
+  if (typeof value === "boolean") return { key, value: { boolValue: value } };
+  if (typeof value === "number") return Number.isInteger(value) ? { key, value: { intValue: String(value) } } : { key, value: { doubleValue: value } };
+  return { key, value: { stringValue: value } };
+}
+function sanitize(name) {
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+var TOOL_NAME = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,99}$/;
+var OpencodeTelemetry = class {
+  constructor(options) {
+    this.options = options;
+    this.mcpPrefixes = options.mcpServers.map((server) => ({ server, prefix: `${sanitize(server)}_` })).sort((a, b) => b.prefix.length - a.prefix.length);
+  }
+  options;
+  mcpPrefixes;
+  models = new Remembered();
+  callTools = new Remembered();
+  permissionTools = new Remembered();
+  reported = new Remembered();
+  proxiedProviders = /* @__PURE__ */ new Set();
+  /** `chat.message`: the member sent a prompt. Its text is never read. */
+  prompt(nowMs) {
+    return { logs: [this.record("user_prompt", nowMs, [])], usage: [] };
+  }
+  /**
+   * `chat.params`: the provider and the base URL this call goes to. A provider
+   * pointed at the AnyForge proxy is remembered, and its calls send no tokens.
+   */
+  provider(providerID, baseURL) {
+    const id = str(providerID);
+    const url = str(baseURL);
+    if (!id || !url || !this.options.anyforgeHost) return;
+    let host;
+    try {
+      host = new URL(url).host;
+    } catch {
+      return;
+    }
+    if (host === this.options.anyforgeHost) this.proxiedProviders.add(id);
+    else this.proxiedProviders.delete(id);
+  }
+  /** One OpenCode bus event (the plugin's `event` hook). */
+  event(event, nowMs) {
+    if (!isRecord(event) || !isRecord(event.properties)) return EMPTY;
+    const props = event.properties;
+    switch (event.type) {
+      case "message.updated":
+        return this.message(props.info, nowMs);
+      case "message.part.updated":
+        return this.part(props.part, nowMs);
+      case "permission.updated":
+        this.notePermission(str(props.id), str(props.callID), str(props.type));
+        return EMPTY;
+      case "permission.asked":
+        this.notePermission(str(props.id), isRecord(props.tool) ? str(props.tool.callID) : void 0, str(props.permission));
+        return EMPTY;
+      case "permission.replied":
+        return this.decision(str(props.requestID) ?? str(props.permissionID), str(props.reply) ?? str(props.response), nowMs);
+      default:
+        return EMPTY;
+    }
+  }
+  message(info, nowMs) {
+    if (!isRecord(info) || info.role !== "assistant") return EMPTY;
+    const id = str(info.id);
+    const modelID = str(info.modelID);
+    const providerID = str(info.providerID);
+    if (!id) return EMPTY;
+    if (modelID && providerID) this.models.set(id, { modelID, providerID });
+    const error = isRecord(info.error) ? info.error : null;
+    if (!error || error.name === "MessageAbortedError" || this.reported.has(`error:${id}`)) return EMPTY;
+    this.reported.set(`error:${id}`, true);
+    return { logs: [this.record("api_error", nowMs, modelID ? [attr("model", modelID)] : [])], usage: [] };
+  }
+  part(part, nowMs) {
+    if (!isRecord(part)) return EMPTY;
+    const id = str(part.id);
+    if (!id) return EMPTY;
+    if (part.type === "step-finish") return this.step(part, id, nowMs);
+    if (part.type === "tool") return this.tool(part, id, nowMs);
+    return EMPTY;
+  }
+  /** One finished model call: an `api_request`, and its tokens unless the proxy metered them. */
+  step(part, id, nowMs) {
+    if (this.reported.has(`step:${id}`)) return EMPTY;
+    this.reported.set(`step:${id}`, true);
+    const model = this.models.get(str(part.messageID) ?? "");
+    const logs = [this.record("api_request", nowMs, model ? [attr("model", model.modelID)] : [])];
+    if (model && this.proxiedProviders.has(model.providerID)) return { logs, usage: [] };
+    const tokens = isRecord(part.tokens) ? part.tokens : {};
+    const cache = isRecord(tokens.cache) ? tokens.cache : {};
+    const reading = {
+      model: model?.modelID ?? "unknown",
+      input: num(tokens.input),
+      // Reasoning tokens are billed as output.
+      output: num(tokens.output) + num(tokens.reasoning),
+      cacheRead: num(cache.read),
+      cacheWrite: num(cache.write),
+      costUsd: num(part.cost)
+    };
+    const any = reading.input + reading.output + reading.cacheRead + reading.cacheWrite + reading.costUsd > 0;
+    return { logs, usage: any ? [reading] : [] };
+  }
+  tool(part, id, nowMs) {
+    const tool = str(part.tool);
+    const state = isRecord(part.state) ? part.state : null;
+    if (!tool || !state) return EMPTY;
+    const callID = str(part.callID);
+    if (callID) this.callTools.set(callID, tool);
+    if (state.status !== "completed" && state.status !== "error") return EMPTY;
+    if (this.reported.has(`tool:${id}`)) return EMPTY;
+    this.reported.set(`tool:${id}`, true);
+    const time = isRecord(state.time) ? state.time : {};
+    const duration = num(time.end) - num(time.start);
+    const attributes = [
+      ...this.toolAttributes(tool),
+      attr("success", state.status === "completed"),
+      ...duration > 0 && duration < 864e5 ? [attr("duration_ms", Math.round(duration))] : []
+    ];
+    const logs = [this.record("tool_result", nowMs, attributes)];
+    if (tool === "skill") logs.push(this.record("skill_activated", nowMs, [attr("skill.name", this.skillName(state.input))]));
+    return { logs, usage: [] };
+  }
+  notePermission(id, callID, permission) {
+    if (!id) return;
+    const tool = (callID && this.callTools.get(callID)) ?? permission;
+    if (tool) this.permissionTools.set(id, tool);
+  }
+  /** A person answered a permission prompt. Rules that allow or deny on their own send no event. */
+  decision(id, reply, nowMs) {
+    if (!id || !reply || this.reported.has(`decision:${id}`)) return EMPTY;
+    const outcome = reply === "once" ? { decision: "accept", source: "user_temporary" } : reply === "always" ? { decision: "accept", source: "user_permanent" } : reply === "reject" ? { decision: "reject", source: "user_reject" } : null;
+    if (!outcome) return EMPTY;
+    this.reported.set(`decision:${id}`, true);
+    const tool = this.permissionTools.get(id);
+    return {
+      logs: [this.record("tool_decision", nowMs, [
+        ...tool ? this.toolAttributes(tool) : [],
+        attr("decision", outcome.decision),
+        attr("source", outcome.source)
+      ])],
+      usage: []
+    };
+  }
+  /** `tool_name` and `tool_source`, in the form Claude Code uses for an MCP tool. */
+  toolAttributes(tool) {
+    const mcp = this.mcpPrefixes.find((m) => tool.startsWith(m.prefix) && tool.length > m.prefix.length);
+    if (mcp) {
+      const name = this.options.sendNames ? `mcp__${mcp.server}__${tool.slice(mcp.prefix.length)}` : "mcp_tool";
+      return [attr("tool_name", TOOL_NAME.test(name) ? name : "mcp_tool"), attr("tool_source", "mcp")];
+    }
+    return TOOL_NAME.test(tool) ? [attr("tool_name", tool), attr("tool_source", "builtin")] : [attr("tool_source", "builtin")];
+  }
+  skillName(input) {
+    const name = isRecord(input) ? str(input.name) : void 0;
+    return this.options.sendNames && name && TOOL_NAME.test(name) ? name : "custom_skill";
+  }
+  record(event, nowMs, attributes) {
+    const nano = `${Math.floor(nowMs)}000000`;
+    return {
+      timeUnixNano: nano,
+      observedTimeUnixNano: nano,
+      body: { stringValue: `opencode.${event}` },
+      attributes: [attr("event.name", event), attr("event.timestamp", new Date(nowMs).toISOString()), ...attributes]
+    };
+  }
+};
+
+// src/opencodePlugin/plugin.ts
+var FLUSH_INTERVAL_MS = 1e4;
+async function readJson(path) {
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function mcpServerNames(input) {
+  try {
+    const res = await input.client?.config?.get?.();
+    const config = res && typeof res === "object" && "data" in res ? res.data : res;
+    const mcp = config?.mcp;
+    if (!mcp || typeof mcp !== "object") return [];
+    const entries = mcp;
+    const servers = entries.servers && typeof entries.servers === "object" ? Object.keys(entries.servers) : [];
+    const legacy = Object.keys(entries).filter((k) => k !== "servers" && k !== "timeout" && typeof entries[k] === "object");
+    return [.../* @__PURE__ */ new Set([...servers, ...legacy])];
+  } catch {
+    return [];
+  }
+}
+var AnyforgeTelemetry = async (input) => {
+  const anyforgeDir = join(homedir(), ".anyforge");
+  const creds = await readJson(join(anyforgeDir, "credentials"));
+  const apiKey = typeof creds?.apiKey === "string" ? creds.apiKey : null;
+  const endpoint = typeof creds?.endpoint === "string" ? creds.endpoint.replace(/\/+$/, "") : null;
+  if (!apiKey || !endpoint) return {};
+  let anyforgeHost = null;
+  try {
+    anyforgeHost = new URL(endpoint).host;
+  } catch {
+    return {};
+  }
+  const settings = await readJson(join(anyforgeDir, "opencode-telemetry.json"));
+  const telemetry = new OpencodeTelemetry({
+    sendNames: settings?.sendNames === true,
+    mcpServers: await mcpServerNames(input),
+    anyforgeHost
+  });
+  const exporter = new TelemetryExporter({
+    endpoint,
+    apiKey,
+    fetch: (async (url, init) => ({ status: (await fetch(url, init)).status })),
+    resource: [{ key: "service.name", value: { stringValue: "opencode" } }]
+  });
+  const timer = setInterval(() => {
+    void exporter.flush();
+  }, FLUSH_INTERVAL_MS);
+  timer.unref?.();
+  const take = (t) => {
+    exporter.addLogs(t.logs);
+    exporter.addUsage(t.usage);
+  };
+  return {
+    "chat.message": async () => {
+      try {
+        take(telemetry.prompt(Date.now()));
+      } catch {
+      }
+    },
+    "chat.params": async (params) => {
+      try {
+        telemetry.provider(params?.provider?.info?.id, params?.provider?.options?.baseURL);
+      } catch {
+      }
+    },
+    event: async ({ event }) => {
+      try {
+        take(telemetry.event(event, Date.now()));
+        if (event?.type === "session.idle") void exporter.flush();
+      } catch {
+      }
+    },
+    dispose: async () => {
+      clearInterval(timer);
+      await exporter.flush();
+    }
+  };
+};
+export {
+  AnyforgeTelemetry
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anyforge/control",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "AnyForge CLI — hosted Oracle conversations, a governed LLM proxy, and a scriptable client for approvals, crews, work items and workflows.",
   "license": "Apache-2.0",
   "homepage": "https://anyforge.ai",
@@ -23,7 +23,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "esbuild src/cli.ts --bundle --minify --platform=node --format=esm --outfile=dist/cli.js --packages=external && chmod +x dist/cli.js",
+    "build": "esbuild src/cli.ts --bundle --minify --platform=node --format=esm --outfile=dist/cli.js --packages=external && chmod +x dist/cli.js && esbuild src/opencodePlugin/plugin.ts --bundle --platform=node --format=esm --outfile=dist/opencode-plugin.js",
     "type-check": "tsc --noEmit",
     "test": "npm run build && node scripts/test.mjs",
     "dev": "tsx src/cli.ts",