@glaicer/supercode-turn-timer 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dmitrii Aronov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# turn-timer
+
+An OpenCode TUI plugin that shows how long the current turn has been running, inline in the prompt footer — right after the built-in `▣ Build · <model>` line:
+
+```text
+▣ Build · Opus 5 (max) ◷ 0:12
+```
+
+## Install
+
+Install with the OpenCode CLI — it detects the TUI target and registers the plugin in `tui.json` for you:
+
+```bash
+opencode plugin @glaicer/supercode-turn-timer --global
+```
+
+- `--global` installs into the global config (`~/.config/opencode`); default is local (`.opencode` in the current project).
+- `--force` replaces an already-installed version.
+- Restart OpenCode after installing.
+
+Manual install also works: add the package to the `plugin` array in `tui.json` (global `~/.config/opencode/tui.json` or local `<project>/.opencode/tui.json`):
+
+```jsonc
+{
+  "plugin": ["@glaicer/supercode-turn-timer"]
+}
+```
+
+> [!IMPORTANT]
+> **The first OpenCode load after installing this plugin may be slow.** That's OpenCode downloading the plugin's packages into its cache. It happens once. Every subsequent start is fast.

package/dist/turn-timer-model.js

@@ -0,0 +1,160 @@
+/**
+ * Turn Timer Model — every state transition and string of the turn timer.
+ *
+ * The timer measures one agent turn: it starts on the first `session.status`
+ * `busy` for a session, freezes on `idle` (interrupt included), and resets on
+ * the next `busy`. `retry` is mid-turn backoff and does not touch the clock.
+ * Records are kept per sessionID so switching sessions in the TUI shows each
+ * session's own timer; events for background sessions never disturb the
+ * visible one.
+ *
+ * Phases: `hidden` (no record for the open session — the TUI process missed
+ * the turn start, so no number is invented), `running` (counting up),
+ * `done` (frozen final elapsed time until the next turn starts).
+ *
+ * All reads of wall time and all scheduling go through the injected clock, so
+ * the whole model is testable without real timers.
+ */
+
+/** Glyph is from Geometric Shapes (same block as the host's ▣), never emoji-presented. */
+export const TURN_TIMER_GLYPH = "◷";
+
+/** Slot order for `session_prompt_right`: below the built-in footer content. */
+export const TURN_TIMER_ORDER = 50;
+
+/** Wall-clock reads and the 1s repaint schedule, injectable for tests. */
+
+/**
+ * Reactive primitives owned by the TUI entrypoint (same pattern as
+ * context-progress-bar): the entry imports these from "solid-js" where the
+ * host rewrites them to its own runtime. This file must not value-import
+ * "solid-js" itself, or an npm-installed copy can miss the host prescan and
+ * freeze the timer on its first paint.
+ */
+
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+
+/** `0:12` under an hour, `1:02:03` from an hour up; never negative. */
+export function formatElapsed(elapsedMs) {
+  const total = Math.max(0, Math.floor(elapsedMs / 1000));
+  const seconds = total % 60;
+  const minutes = Math.floor(total / 60) % 60;
+  const hours = Math.floor(total / 3600);
+  return hours > 0 ? `${hours}:${pad2(minutes)}:${pad2(seconds)}` : `${minutes}:${pad2(seconds)}`;
+}
+export function timerText(elapsedMs) {
+  return `${TURN_TIMER_GLYPH} ${formatElapsed(elapsedMs)}`;
+}
+function statusType(status) {
+  return status?.type;
+}
+
+/**
+ * Turn Timer Model over the live event bus. `session.status` drives the
+ * record map; `session.deleted` drops the record; `server.connected`
+ * reconciles against `api.state.session.status` so a reconnect never leaves a
+ * frozen wrong number (an open record whose session is idle/reply-unknown is
+ * closed or dropped, never silently kept stale).
+ */
+export function createTurnTimerModel(api, sessionId, solid, clock) {
+  const records = new Map();
+  const [version, setVersion] = solid.createSignal(0);
+  const bump = () => setVersion(v => v + 1);
+  const offStatus = api.event.on("session.status", event => {
+    const {
+      sessionID,
+      status
+    } = event.properties;
+    const type = statusType(status);
+    const record = records.get(sessionID);
+    if (type === "busy") {
+      // A new turn starts only from a stopped state; re-broadcast busy keeps
+      // the running clock.
+      if (!record || record.endedAt !== undefined) {
+        records.set(sessionID, {
+          startedAt: clock.now()
+        });
+      }
+      bump();
+      return;
+    }
+    if (type === "idle") {
+      if (record && record.endedAt === undefined) {
+        // Replace, never mutate: the memo compares by reference, so an
+        // in-place endedAt would leave the phase stuck on "running".
+        records.set(sessionID, {
+          startedAt: record.startedAt,
+          endedAt: clock.now()
+        });
+        bump();
+      }
+      return;
+    }
+    // "retry" and anything unknown: the turn is still in flight.
+  });
+  const offDeleted = api.event.on("session.deleted", event => {
+    const properties = event.properties;
+    const deletedID = properties.sessionID ?? properties.info?.id;
+    if (deletedID !== undefined && records.delete(deletedID)) bump();
+  });
+  const offConnected = api.event.on("server.connected", () => {
+    solid.untrack(() => {
+      for (const [sessionID, record] of [...records]) {
+        if (record.endedAt !== undefined) continue;
+        let status;
+        try {
+          status = api.state.session.status(sessionID);
+        } catch {
+          status = undefined;
+        }
+        const type = statusType(status);
+        if (type === "idle") {
+          records.set(sessionID, {
+            startedAt: record.startedAt,
+            endedAt: clock.now()
+          });
+        } else if (type !== "busy" && type !== "retry") {
+          records.delete(sessionID);
+        }
+      }
+      bump();
+    });
+  });
+  solid.onCleanup(() => {
+    offStatus();
+    offDeleted();
+    offConnected();
+  });
+
+  // The memo holds only the record reference; wall time is read live in
+  // display() so a Solid recompute during a signal write can never freeze a
+  // stale elapsed value between repaint ticks.
+  const current = solid.createMemo(() => {
+    version();
+    return records.get(sessionId());
+  });
+  const phase = solid.createMemo(() => {
+    const record = current();
+    if (!record) return "hidden";
+    return record.endedAt === undefined ? "running" : "done";
+  });
+
+  // Repaint once per second while the visible session is running; the effect
+  // keys on phase transitions only, so the interval is created once per turn.
+  solid.createEffect(() => {
+    if (phase() !== "running") return;
+    const handle = clock.setInterval(bump, 1000);
+    solid.onCleanup(() => clock.clearInterval(handle));
+  });
+  return {
+    phase,
+    display: () => {
+      const record = current();
+      if (!record) return "";
+      const elapsedMs = (record.endedAt ?? clock.now()) - record.startedAt;
+      return timerText(elapsedMs);
+    }
+  };
+}

package/dist/turn-timer.js

@@ -0,0 +1,77 @@
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { effect as _$effect } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+/**
+ * supercode.turn-timer — elapsed time of the current agent turn, rendered in
+ * the `session_prompt_right` slot: the host places it right-aligned on the
+ * same line as the built-in "▣ Build · <model>" footer (verified in the
+ * 1.18.30 binary: the slot is passed as the Prompt's `right` prop, and the
+ * Prompt renders `right` in a row box next to the agent/model texts).
+ *
+ * This file is only the View plus slot registration: it starts no clock,
+ * formats nothing and keeps no state — all logic lives in
+ * ./turn-timer-model.ts (the tested seam).
+ *
+ * Phases: running counts up in accent; on idle (turn done or interrupted)
+ * the final elapsed time freezes in muted; before the first observed turn
+ * start of the open session nothing renders — the plugin never invents a
+ * number it did not see.
+ */
+import { createEffect, createMemo, createSignal, onCleanup, Show, untrack } from "solid-js";
+import { TURN_TIMER_ORDER, createTurnTimerModel } from "./turn-timer-model.js";
+
+/**
+ * The host rewrites this file's "solid-js" import to its own runtime. The
+ * model builds all of its signals on these exact primitives (see
+ * SolidRuntime), so the timer stays in the host's reactive graph even when
+ * installed as an npm package under node_modules.
+ */
+const solid = {
+  createSignal,
+  createMemo,
+  createEffect,
+  onCleanup,
+  untrack
+};
+const clock = {
+  now: () => Date.now(),
+  setInterval: (fn, ms) => setInterval(fn, ms),
+  clearInterval: handle => clearInterval(handle)
+};
+function Section(props) {
+  const theme = () => props.api.theme.current;
+  const model = createTurnTimerModel(props.api, () => props.session_id, solid, clock);
+  return _$createComponent(Show, {
+    get when() {
+      return model.phase() !== "hidden";
+    },
+    get children() {
+      var _el$ = _$createElement("text");
+      _$insert(_el$, () => model.display());
+      _$effect(_$p => _$setProp(_el$, "fg", model.phase() === "running" ? theme().accent : theme().textMuted, _$p));
+      return _el$;
+    }
+  });
+}
+const tui = async api => {
+  api.slots.register({
+    order: TURN_TIMER_ORDER,
+    slots: {
+      session_prompt_right(_ctx, props) {
+        return _$createComponent(Section, {
+          api: api,
+          get session_id() {
+            return props.session_id;
+          }
+        });
+      }
+    }
+  });
+};
+const plugin = {
+  id: "supercode.turn-timer",
+  tui
+};
+export default plugin;

package/package.json

@@ -0,0 +1,56 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@glaicer/supercode-turn-timer",
+  "version": "0.1.0",
+  "description": "OpenCode TUI plugin: elapsed-time timer for the current turn, inline in the prompt footer.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Dmitrii Aronov <aronov.mml@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Glaicer/supercode-turn-timer.git"
+  },
+  "homepage": "https://github.com/Glaicer/supercode-turn-timer#readme",
+  "bugs": "https://github.com/Glaicer/supercode-turn-timer/issues",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "tui-plugin",
+    "timer",
+    "turn-timer"
+  ],
+  "exports": {
+    "./tui": "./dist/turn-timer.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "check:package": "node scripts/check-package.mjs",
+    "prepack": "npm run build && npm run check:package",
+    "test": "node --test --conditions browser 'src/**/*.test.ts'",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": ">=1.18.21",
+    "@opentui/core": ">=0.4.5",
+    "@opentui/solid": ">=0.4.5",
+    "solid-js": "1.9.12"
+  },
+  "devDependencies": {
+    "@babel/core": "7.28.0",
+    "@babel/preset-typescript": "7.27.1",
+    "@opencode-ai/sdk": "1.18.21",
+    "@types/node": "24.13.3",
+    "babel-preset-solid": "1.9.12",
+    "typescript": "5.8.2"
+  },
+  "engines": {
+    "node": ">=24",
+    "opencode": ">=1.18.21"
+  }
+}