opencode-total-session-cost 1.0.0

package/.github/workflows/ci.yml

@@ -0,0 +1,27 @@
+name: Continuous Integration
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  typecheck:
+    name: TypeScript Typecheck
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install Dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Run Typecheck
+        run: bun x tsc --noEmit

package/.github/workflows/publish.yml

@@ -0,0 +1,27 @@
+name: Publish to NPM
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    name: Publish Package
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js (for NPM Publish)
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install Dependencies
+        run: npm ci
+
+      - name: Publish Package
+        run: npm publish --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -0,0 +1,30 @@
+# Opencode Total Session Cost Tracker 💰
+
+A real-time, lightweight plugin for [Opencode](https://opencode.im) that tracks and displays the **actual cumulative cost** of your active session, including all background tasks, sub-agents, and child sessions.
+
+## Why this plugin?
+By default, Opencode only displays the cost of your active main session. However, any background tasks or specialized sub-agents (like `explore`, `coder`, or custom test executors) invoked during your conversation run in their own child sub-sessions, keeping their costs hidden.
+
+Without tracking these sub-sessions, you might see a main session cost of a few cents, while the background agents have spent significantly more.
+
+**This plugin solves that.** It automatically aggregates the costs of your main session and all its nested child tasks, displaying your **real, total spending** in real-time directly inside the main session.
+
+## Features
+- **Sidebar-Independent**: The cost indicator stays visible even when the Opencode sidebar is closed.
+- **Recursive Sub-Agent Tracking**: Automatically detects and sums up the costs of all child tasks spawned during your session.
+- **Detailed Cost Breakdown**: Offers a `/total_cost` slash command to show a detailed popup separating your active session cost from child sub-agent costs.
+
+## Installation
+Once published, you can install it globally with:
+```bash
+opencode plugin opencode-total-session-cost -g
+```
+
+## How it works
+The plugin runs inside Opencode's TUI framework, recursively fetching session data:
+1. It reads the core cost of your active session.
+2. It recursively queries all child sub-sessions spawned by sub-agents.
+3. It displays the combined sum dynamically in the TUI.
+
+## License
+MIT

package/index.ts

@@ -0,0 +1,14 @@
+import type { Plugin, PluginModule } from "@opencode-ai/plugin";
+
+export const id = "opencode-cost-bar";
+
+export const server: Plugin = async (ctx) => {
+  return {}; // No-op backend hooks
+};
+
+const pluginModule: PluginModule = {
+  id,
+  server
+};
+
+export default pluginModule;

package/opencode.jsonc

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    "./tui.tsx"
+  ]
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "opencode-total-session-cost",
+  "version": "1.0.0",
+  "description": "Real-time cumulative cost tracker for Opencode sessions, aggregating costs from parent sessions, archived messages, and all child sub-agent tasks.",
+  "type": "module",
+  "main": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./tui": "./tui.tsx"
+  },
+  "keywords": [
+    "opencode-plugin",
+    "opencode",
+    "tui",
+    "cost",
+    "token",
+    "subagent",
+    "cumulative-cost"
+  ],
+  "author": "crazybyte",
+  "license": "MIT",
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.18.30",
+    "@opencode-ai/sdk": "^1.18.30"
+  },
+  "peerDependencies": {
+    "@opentui/core": ">=0.1.97",
+    "@opentui/solid": ">=0.1.97",
+    "solid-js": "^1.9.12"
+  },
+  "devDependencies": {
+    "typescript": "^7.0.2",
+    "solid-js": "^1.9.12",
+    "@types/node": "^26.5.1"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "jsx": "preserve",
+    "jsxImportSource": "@opentui/solid",
+    "strict": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["./index.ts", "./tui.tsx"]
+}

package/tui.tsx

@@ -0,0 +1,138 @@
+import type { TuiPlugin, TuiPluginModule } from "@opencode-ai/plugin/tui";
+import { createSignal, onCleanup } from "solid-js";
+
+export const id = "opencode-cost-bar";
+
+export const SessionCostPlugin: TuiPlugin = async (api) => {
+  // Register TUI slots with reactive signals defined inside the renderers
+  api.slots?.register({
+    slots: {
+      // session_prompt_right: Persistent cost tracker in the prompt header right panel next to active model info
+      session_prompt_right: (ctx: any, props: any) => {
+        const [total, setTotal] = createSignal<number>(0);
+
+        const calculateCost = async (sessionID: string): Promise<number> => {
+          let totalCost = 0;
+
+          const sessionObj = api.state.session.get(sessionID);
+          if (sessionObj && typeof sessionObj.cost === "number") {
+            totalCost += sessionObj.cost;
+          }
+
+          try {
+            const childrenRes = await api.client.session.children({ sessionID });
+            if (childrenRes.data) {
+              for (const child of childrenRes.data) {
+                totalCost += await calculateCost(child.id);
+              }
+            }
+          } catch (err) {}
+
+          return totalCost;
+        };
+
+        const update = async () => {
+          const sessionID = props?.session_id;
+          if (sessionID) {
+            const res = await calculateCost(sessionID);
+            setTotal(res);
+          } else {
+            setTotal(0);
+          }
+        };
+
+        const unsubMsgUpdated = api.event.on("message.updated", update);
+        const unsubMsgRemoved = api.event.on("message.removed", update);
+        const interval = setInterval(update, 3000);
+
+        onCleanup(() => {
+          unsubMsgUpdated();
+          unsubMsgRemoved();
+          clearInterval(interval);
+        });
+
+        // Trigger update immediately
+        update();
+
+        return (
+          <text fg="gray">
+            {" "}[ ${total().toFixed(2)} ]
+          </text>
+        );
+      }
+    }
+  });
+
+  // Register slash command /total_cost (and alias /costs)
+  api.command?.register(() => [
+    {
+      title: "Total Session Cost",
+      value: "total_cost",
+      description: "Display total cost breakdown of current session and child sessions",
+      category: "Cost Tracking",
+      slash: {
+        name: "total_cost",
+        aliases: ["costs"]
+      },
+      onSelect: async () => {
+        const currentSessionID = api.route.current && api.route.current.name === "session" && typeof api.route.current.params?.sessionID === "string"
+          ? api.route.current.params.sessionID
+          : null;
+
+        if (!currentSessionID) {
+          api.ui.toast({
+            title: "No Active Session",
+            message: "Please open a session to check costs.",
+            variant: "warning",
+            duration: 4000
+          });
+          return;
+        }
+
+        let parentCost = 0;
+        let childrenCost = 0;
+
+        const calculateCostRecursive = async (sessionID: string): Promise<void> => {
+          const sessionObj = api.state.session.get(sessionID);
+          if (sessionObj && typeof sessionObj.cost === "number") {
+            if (sessionID === currentSessionID) {
+              parentCost += sessionObj.cost;
+            } else {
+              childrenCost += sessionObj.cost;
+            }
+          }
+
+          try {
+            const childrenRes = await api.client.session.children({ sessionID });
+            if (childrenRes.data) {
+              for (const child of childrenRes.data) {
+                await calculateCostRecursive(child.id);
+              }
+            }
+          } catch (err) {}
+        };
+
+        await calculateCostRecursive(currentSessionID);
+        const total = parentCost + childrenCost;
+
+        api.ui.toast({
+          title: "Session Costs Breakdown",
+          message: `Active: $${parentCost.toFixed(2)} | Children: $${childrenCost.toFixed(2)} | Total: $${total.toFixed(2)}`,
+          variant: "success",
+          duration: 6000
+        });
+      }
+    }
+  ]);
+};
+
+// Export named constant for loaders looking for `export const tui = ...`
+export const tui = SessionCostPlugin;
+
+// Export default module configuration
+const pluginModule: TuiPluginModule = {
+  id,
+  tui: SessionCostPlugin
+};
+
+export default pluginModule;