@opencode-cockpit/trust 0.0.0-stage → 0.8.0

package/dist/tui/journal.js

@@ -0,0 +1,80 @@
+/**
+ * The ledger file, read and appended without ever blocking the interface thread.
+ *
+ * Every read and every append goes through one chain, so this window's writes and reads never
+ * overlap each other (the lesson of Review's trace: unserialised appends dropped lines). Other
+ * windows append to the same file between our reads; `read` takes whatever whole lines arrived since
+ * the last one and leaves a line still being written for next time.
+ */
+
+import { appendFile, mkdir, open } from "node:fs/promises";
+import { parseLines, serialize } from "../core/ledger.js";
+export function createJournal(paths) {
+  let offset = 0;
+  let chain = Promise.resolve();
+  let made = false;
+  const decoder = new TextDecoder();
+  const queue = task => {
+    const run = chain.then(task, task);
+    chain = run.catch(() => {});
+    return run;
+  };
+  const read = async () => {
+    let handle;
+    try {
+      handle = await open(paths.events, "r");
+    } catch (error) {
+      if (error.code === "ENOENT") return {
+        events: [],
+        reset: false
+      };
+      throw error;
+    }
+    try {
+      const {
+        size
+      } = await handle.stat();
+      /** Smaller than what we read: someone replaced the file. Start again from its first line. */
+      const reset = size < offset;
+      if (reset) offset = 0;
+      if (size === offset) return {
+        events: [],
+        reset
+      };
+      const buffer = new Uint8Array(size - offset);
+      const {
+        bytesRead
+      } = await handle.read(buffer, 0, buffer.length, offset);
+      const bytes = buffer.subarray(0, bytesRead);
+      const end = bytes.lastIndexOf(10); // the last newline: what follows is still being written
+      if (end < 0) return {
+        events: [],
+        reset
+      };
+      const {
+        events
+      } = parseLines(decoder.decode(bytes.subarray(0, end + 1)));
+      offset += end + 1;
+      return {
+        events,
+        reset
+      };
+    } finally {
+      await handle.close();
+    }
+  };
+  return {
+    read: () => queue(read),
+    append: events => queue(async () => {
+      if (events.length === 0) return;
+      if (!made) {
+        await mkdir(paths.dir, {
+          recursive: true
+        });
+        made = true;
+      }
+      /** One write for the batch: whole lines, appended, never interleaved with another window's. */
+      await appendFile(paths.events, events.map(serialize).join(""));
+    })
+  };
+}

package/dist/tui/render.js

@@ -0,0 +1,85 @@
+/**
+ * The only place that knows what a tone looks like: every colour from the user's OpenCode theme,
+ * through the host (so OpenCode 2's tokens arrive under the same names — client/host `themeFromV2`).
+ */
+
+import { TINTS } from "../core/view/rows.js";
+const opaque = colour => colour !== undefined && colour.a > 0;
+
+/** What the dialog is drawn on: the panel colour, or the background when a theme leaves the panel clear. */
+const surface = theme => opaque(theme.backgroundPanel) ? theme.backgroundPanel : opaque(theme.background) ? theme.background : undefined;
+export function toneColour(theme, tone) {
+  switch (tone) {
+    case "muted":
+      return theme.textMuted;
+    case "accent":
+      return theme.accent;
+    case "info":
+      return theme.info;
+    case "tool":
+      return theme.primary;
+    case "success":
+      return theme.success;
+    case "error":
+      return theme.error;
+    case "warning":
+      return theme.warning;
+    case "border":
+      return theme.border;
+    /** Text cut out of a solid accent: the surface's own colour, or the text's when there is none. */
+    case "ink":
+      return surface(theme) ?? theme.text;
+    default:
+      return theme.text;
+  }
+}
+const mixed = new WeakMap();
+
+/**
+ * `tone` faded into `behind`, `amount` of the way from it: a tint that follows the theme. Built from
+ * the colour's own class, as Review's soften does, so nothing of OpenTUI is imported.
+ */
+function mix(tone, behind, amount) {
+  const byBack = mixed.get(tone) ?? new WeakMap();
+  mixed.set(tone, byBack);
+  const byAmount = byBack.get(behind) ?? new Map();
+  byBack.set(behind, byAmount);
+  const known = byAmount.get(amount);
+  if (known) return known;
+  const Colour = tone.constructor;
+  if (typeof Colour.clone !== "function" || typeof behind.r !== "number") return undefined;
+  const out = Colour.clone(behind);
+  out.r = behind.r + (tone.r - behind.r) * amount;
+  out.g = behind.g + (tone.g - behind.g) * amount;
+  out.b = behind.b + (tone.b - behind.b) * amount;
+  byAmount.set(amount, out);
+  return out;
+}
+
+/**
+ * What sits behind a run. The row-wide surfaces and the buttons are the theme's raised element; a
+ * focused button is the accent; a chip or a badge is its tone's tint, and — on a theme whose dialog
+ * has no colour to tint — no fill at all: the word keeps its tone and still says what it is.
+ */
+export function fillColour(theme, fill) {
+  switch (fill) {
+    case "selected":
+    case "panel":
+    case "button":
+      return theme.backgroundElement;
+    case "buttonOn":
+      return theme.accent;
+    case "chip":
+    case "ok":
+    case "warn":
+    case "err":
+      {
+        const behind = surface(theme);
+        if (!behind) return undefined;
+        const tint = TINTS[fill];
+        return mix(toneColour(theme, tint.tone), behind, tint.amount);
+      }
+    default:
+      return undefined;
+  }
+}

package/dist/tui/source.js

@@ -0,0 +1,112 @@
+/**
+ * Trust's reach into a specific OpenCode: its events, its reply, its config and its pending list.
+ * The only file past `Host` — through `api.v1` / `api.v2`, as Subagents' source does — and every call
+ * was measured or read from the version's own client (docs/opencode/permissions.md):
+ *
+ * | | OpenCode 1 | OpenCode 2 |
+ * | --- | --- | --- |
+ * | events | `api.event.on(type)` | `ctx.data.listen` |
+ * | answer | `client.permission.reply({ requestID, reply })` | `client.permission.reply({ sessionID, requestID, decision })` |
+ * | config | `client.config.get()` — merged | `client.config.get({ location })` — documents, lowest first |
+ * | pending | `client.permission.list()` | not read (see `pending` below) |
+ *
+ * What it hears becomes `Seen` through the pure adapters in `core/adapt/`.
+ */
+
+import { commandOf, obj, str } from "../core/adapt/seen.js";
+import { fromV1Event, fromV1Pending, V1_EVENTS } from "../core/adapt/v1.js";
+import { fromV2Event } from "../core/adapt/v2.js";
+
+// biome-ignore lint/suspicious/noExplicitAny: the host's objects, reached by measured shapes only
+
+/** A client result: the plugin's client hands back `{ data }`, some calls the data itself. */
+const unwrap = result => {
+  const value = obj(result);
+  if (value.error) throw new Error(str(obj(value.error).message) ?? JSON.stringify(value.error));
+  return "data" in value ? value.data : result;
+};
+export function createSource(api, log, emit) {
+  const offs = [];
+  const guard = fn => {
+    try {
+      fn();
+    } catch (error) {
+      log.error("event failed", {
+        error
+      });
+    }
+  };
+  if (api.v1) {
+    const v1 = api.v1;
+    for (const type of V1_EVENTS) {
+      const off = v1.event.on(type, event => guard(() => emit(fromV1Event(event))));
+      if (typeof off === "function") offs.push(off);
+    }
+    return {
+      async approve(request) {
+        unwrap(await v1.client.permission.reply({
+          requestID: request.id,
+          reply: "once"
+        }));
+      },
+      async config() {
+        return unwrap(await v1.client.config.get());
+      },
+      async pending() {
+        return fromV1Pending(unwrap(await v1.client.permission.list()));
+      },
+      call(request) {
+        if (!request.messageID || !request.call) return undefined;
+        const parts = v1.state.part?.(request.messageID) ?? [];
+        const part = parts.find(each => each?.callID === request.call);
+        return part ? commandOf(obj(obj(part.state).input)) : undefined;
+      },
+      agent(sessionID, messageID) {
+        const messages = v1.state.session?.messages?.(sessionID) ?? [];
+        const info = message => obj(message?.info ?? message);
+        const own = messageID ? messages.find(message => info(message).id === messageID) : undefined;
+        const found = [own, ...[...messages].reverse()].find(message => message && str(info(message).agent));
+        return found ? str(info(found).agent) : undefined;
+      },
+      dispose: () => {
+        for (const off of offs.splice(0)) off();
+      }
+    };
+  }
+  const v2 = api.v2;
+  const location = () => ({
+    directory: api.state.path.directory
+  });
+  const off = v2.data.listen(event => guard(() => emit(fromV2Event(event))));
+  if (typeof off === "function") offs.push(off);
+  return {
+    async approve(request) {
+      unwrap(await v2.client.permission.reply({
+        sessionID: request.sessionID,
+        requestID: request.id,
+        decision: "once"
+      }));
+    },
+    async config() {
+      return unwrap(await v2.client.config.get({
+        location: location()
+      }));
+    },
+    /**
+     * Not read on OpenCode 2. Its `permission.request.list({ location })` exists, but a real 2.0.18 run
+     * listed nothing for a request that was on screen, and an empty list read as "all answered" would
+     * forget the person's pending request — whose approval would then not count. Replies arrive as
+     * events; that is enough.
+     */
+    async pending() {
+      return undefined;
+    },
+    call: () => undefined,
+    agent(sessionID) {
+      return str(obj(v2.data.session?.get?.(sessionID)).agent);
+    },
+    dispose: () => {
+      for (const each of offs.splice(0)) each();
+    }
+  };
+}

package/dist/tui/view/dialog.js

@@ -0,0 +1,43 @@
+import { insert as _$insert } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+/** @jsxImportSource @opentui/solid */
+// biome-ignore-all lint/a11y/noStaticElementInteractions: these are terminal boxes, not DOM elements
+
+import { Rows } from "./rows.js";
+/**
+ * Trust's dialog in the host's: rows from `core/view/` — the activity or the ledger — and the keys and
+ * clicks that act on them. Clicks are read on release: on press, anything a click opens is up in time
+ * to catch the release and take it for its own (Review's overlay learned this).
+ */
+export function Dialog(props) {
+  props.api.keymap.useLayer(props.keys);
+  let rows;
+  return (() => {
+    var _el$ = _$createElement("box");
+    _$setProp(_el$, "onMouse", event => {
+      const scroll = event.scroll;
+      if (!scroll) return;
+      event.stopPropagation();
+      props.onScroll(scroll.direction === "up" ? -3 : 3);
+    });
+    _$setProp(_el$, "onMouseUp", event => {
+      if (!rows) return;
+      event.stopPropagation();
+      props.onClick(event.x - rows.x, event.y - rows.y);
+    });
+    _$insert(_el$, _$createComponent(Rows, {
+      get api() {
+        return props.api;
+      },
+      get rows() {
+        return props.rows;
+      },
+      onReady: box => {
+        rows = box;
+      }
+    }));
+    return _el$;
+  })();
+}

package/dist/tui/view/rows.js

@@ -0,0 +1,69 @@
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { use as _$use } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+/** @jsxImportSource @opentui/solid */
+
+import { For } from "solid-js";
+import { fillColour, toneColour } from "../render.js";
+/**
+ * Rows of runs, one `<text>` per row — the drawing both the sidebar block and the ledger dialog use.
+ *
+ * Shell's and Subagents' pattern, proven live on both OpenCodes: a signal read by `<For>` redraws,
+ * where anything decided once in a slot's tree never would (docs/opencode/gotchas.md, "Slots").
+ * The shape never changes; only the list of rows does.
+ */
+export function Rows(props) {
+  const theme = () => props.api.theme.current;
+  return (() => {
+    var _el$ = _$createElement("box");
+    _$use(box => props.onReady?.(box), _el$);
+    _$setProp(_el$, "flexDirection", "column");
+    _$insert(_el$, _$createComponent(For, {
+      get each() {
+        return props.rows();
+      },
+      children: row => (() => {
+        var _el$2 = _$createElement("text");
+        _$setProp(_el$2, "wrapMode", "none");
+        _$setProp(_el$2, "flexShrink", 0);
+        _$insert(_el$2, _$createComponent(For, {
+          each: row,
+          children: run => {
+            const fill = fillColour(theme(), run.fill);
+            const style = {
+              fg: toneColour(theme(), run.tone),
+              ...(fill ? {
+                bg: fill
+              } : {})
+            };
+            return run.bold ? (() => {
+              var _el$3 = _$createElement("span"),
+                _el$4 = _$createElement("b");
+              _$insertNode(_el$3, _el$4);
+              _$setProp(_el$3, "style", style);
+              _$insert(_el$4, () => run.text);
+              return _el$3;
+            })() : run.faint ? (() => {
+              var _el$5 = _$createElement("span"),
+                _el$6 = _$createElement("i");
+              _$insertNode(_el$5, _el$6);
+              _$setProp(_el$5, "style", style);
+              _$insert(_el$6, () => run.text);
+              return _el$5;
+            })() : (() => {
+              var _el$7 = _$createElement("span");
+              _$setProp(_el$7, "style", style);
+              _$insert(_el$7, () => run.text);
+              return _el$7;
+            })();
+          }
+        }));
+        return _el$2;
+      })()
+    }));
+    return _el$;
+  })();
+}

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "@opencode-cockpit/trust",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.8.0",
+  "description": "Permissions that learn: approve the same command enough times and it approves itself, visibly",
+  "type": "module",
+  "license": "MIT",
+  "author": "Codestz",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Codestz/opencode-cockpit.git",
+    "directory": "packages/trust"
+  },
+  "homepage": "https://github.com/Codestz/opencode-cockpit#readme",
+  "bugs": {
+    "url": "https://github.com/Codestz/opencode-cockpit/issues"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "permissions",
+    "trust",
+    "tui",
+    "terminal"
+  ],
+  "exports": {
+    "./tui": {
+      "types": "./types/tui/index.d.ts",
+      "default": "./dist/tui/index.js"
+    },
+    "./core": {
+      "types": "./types/core/index.d.ts",
+      "default": "./dist/core/index.js"
+    }
+  },
+  "engines": {
+    "opencode": ">=1.18.0",
+    "bun": ">=1.3.5"
+  },
+  "files": [
+    "tui.js",
+    "dist",
+    "types",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@opencode-cockpit/client": "0.8.0",
+    "@opencode-ai/plugin": "1.18.31"
+  },
+  "devDependencies": {
+    "@opentui/core": "0.4.5",
+    "@opentui/keymap": "0.4.5",
+    "@opentui/solid": "0.4.5",
+    "solid-js": "1.9.12"
+  },
+  "bin": {
+    "opencode-trust": "./dist/cli/preview.js",
+    "trust": "./dist/cli/preview.js"
+  }
+}

package/tui.js

@@ -0,0 +1,6 @@
+/**
+ * OpenCode 2 finds a plugin configured by *path* by the files at its root — `<package>/tui`,
+ * `<package>/server` — rather than through `exports` (docs/opencode/v2.md). A package installed by
+ * name resolves through `exports` as before; this file is only the door for the path case.
+ */
+export { default } from "./dist/tui/index.js"

package/types/cli/preview.d.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun
+/**
+ * The see-it loop: the sidebar block and both Trust screens — the activity `/trust` opens on and the
+ * ledger behind `l` — drawn in this terminal from sample worlds, with no OpenCode running. The same
+ * rows OpenCode draws; only the colours come from a fixed palette (OpenCode's default theme) instead
+ * of the user's.
+ *
+ *   bunx @opencode-cockpit/trust preview                    every sample, both screens
+ *   bunx @opencode-cockpit/trust preview --sample busy      one of them
+ *   bunx @opencode-cockpit/trust preview --view activity    only the screen /trust opens on
+ *   bunx @opencode-cockpit/trust preview --view ledger      only the ledger (the explorer and its card)
+ *   bunx @opencode-cockpit/trust preview --columns 80       the dialog at another width
+ *   bunx @opencode-cockpit/trust preview --rows 20          the dialog in a short window
+ *   bunx @opencode-cockpit/trust preview --width 30         the sidebar at another width
+ *   bunx @opencode-cockpit/trust preview --keys             the key lists (`?`) too
+ *   bunx @opencode-cockpit/trust preview --html > a.html    the same, as a page, to judge colour in a browser
+ *
+ * The ledger is drawn more than once a sample: as it opens, then with the cursor on a trusted command
+ * in its open family, on a family you widened, on one still counting, on a dangerous command, on
+ * OpenCode's own "always", and with `tab` into the card's buttons.
+ */
+export {};

package/types/core/adapt/seen.d.ts

@@ -0,0 +1,46 @@
+/**
+ * What Trust takes from the host's events, whichever OpenCode sent them. `v1.ts` and `v2.ts` turn
+ * their version's events into these, and nothing past them knows which version it is.
+ */
+import type { Reply } from "../engine.ts";
+import type { Request } from "../keys.ts";
+export type Seen = {
+    type: "asked";
+    request: Request;
+} | {
+    type: "replied";
+    sessionID: string;
+    requestID: string;
+    reply: Reply;
+}
+/**
+ * A tool call's arguments. A bash request's patterns lose the line's `cd`s (OpenCode leaves `cd`
+ * out of them), so the command line Trust judges is the call's own `command`, kept from here.
+ */
+ | {
+    type: "call";
+    sessionID: string;
+    call: string;
+    messageID?: string;
+    input: Record<string, unknown>;
+}
+/** The agent a session runs as: part of every key, and not on the request itself. */
+ | {
+    type: "agent";
+    sessionID: string;
+    agent: string;
+}
+/** OpenCode's config changed: the rules have to be read again. */
+ | {
+    type: "config";
+};
+export type Json = Record<string, unknown>;
+export declare const obj: (value: unknown) => Json;
+export declare const str: (value: unknown) => string | undefined;
+export declare const strings: (value: unknown) => string[];
+export declare const isReply: (value: unknown) => value is Reply;
+/** The command line and working directory from a shell call's arguments (v1 `workdir`, v2 `cwd`). */
+export declare function commandOf(input: Json | undefined): {
+    line?: string;
+    workdir?: string;
+};

package/types/core/adapt/v1.d.ts

@@ -0,0 +1,18 @@
+/**
+ * OpenCode 1's events, as what Trust takes from them.
+ *
+ * `api.event.on(type)` hands over `{ type, properties }`. Shapes measured on 1.18.32
+ * (docs/opencode/permissions.md, and Subagents' recorded run for the message events):
+ *
+ *   permission.asked    { id, sessionID, permission: "bash", patterns, always, metadata,
+ *                         tool: { messageID, callID } }
+ *   permission.replied  { sessionID, requestID, reply: "once" | "always" | "reject" }
+ *   message.part.updated  { part: { type: "tool", callID, sessionID, messageID, state: { input } } }
+ *   message.updated     { info: { sessionID, agent } }
+ *   session.created/updated { info: { id, agent } }   — a subagent's session names its agent
+ */
+import { type Seen } from "./seen.ts";
+export declare const V1_EVENTS: readonly ["permission.asked", "permission.replied", "message.part.updated", "message.updated", "session.created", "session.updated"];
+export declare function fromV1Event(raw: unknown): Seen[];
+/** A pending request as `client.permission.list()` returns it: the same shape as the event. */
+export declare function fromV1Pending(list: unknown): Seen[];

package/types/core/adapt/v2.d.ts

@@ -0,0 +1,20 @@
+/**
+ * OpenCode 2's events, as what Trust takes from them.
+ *
+ * `ctx.data.listen` hands over `{ name, details: { data } }`. Shapes measured on 2.0.18
+ * (docs/opencode/permissions.md) and read from its own schema (`Permission.Request`):
+ *
+ *   permission.asked    { id, sessionID, action: "shell", resources, save, metadata, message,
+ *                         source: { type: "tool", messageID, id } }
+ *   permission.replied  { sessionID, requestID, reply }
+ *   session.tool.called { sessionID, assistantMessageID, id, input }   — a shell call's `command`, `cwd`
+ *   session.created     { sessionID, agent }
+ *   session.agent.selected { sessionID, agent }
+ *   config.updated      {}
+ *
+ * The request carries no agent (v2's schema has none), so it comes from the session's events.
+ */
+import { type Seen } from "./seen.ts";
+export declare function fromV2Event(raw: unknown): Seen[];
+/** A pending request from a list, in the same shape as the event's data. */
+export declare function fromV2Pending(list: unknown): Seen[];

package/types/core/config.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Trust's settings, through the same merge every bay uses (docs/building/a-new-bay.md):
+ *
+ *   ~/.config/opencode-cockpit/config.json  →  <project>/.cockpit.json  →  plugin-entry options
+ *
+ * Only the `trust` section of a file is read. A file without one says nothing about Trust — reading
+ * the whole file as Trust's settings is the trap that page warns about. An unreadable or invalid file
+ * is ignored rather than fatal: a typo in a config should never cost you the interface.
+ *
+ * This is Cockpit's config, not OpenCode's. What OpenCode allows, denies and asks about is read from
+ * OpenCode itself (`rules.ts`), and never written by Trust.
+ */
+export interface TrustConfig {
+    /** Off switch for this bay, wherever it is written. The bundle also has `features.trust: false`. */
+    enabled?: boolean;
+    /** Approvals in a row, by you, before Trust answers for you. Default 3. */
+    threshold?: number;
+    /** What a dangerous command costs on top (`rm`, `git push`, `--force`…). Default 5: eight in all. */
+    dangerExtra?: number;
+    /** Days a trusted command may go unused before it has to be earned again. Default 30; 0 never. */
+    expireDays?: number;
+    /**
+     * Whether Trust draws a block in the sidebar. Default false: the sidebar already carries the
+     * statusline, subagents and shells, and Trust works the same without it — `/trust` opens the
+     * ledger, and the palette's "Show or hide Trust in the sidebar" brings the block back for the session.
+     */
+    sidebar?: boolean;
+    /** Answers by Trust listed in the sidebar. Default 3. */
+    sidebarRows?: number;
+    /** Where the block sits among sidebar blocks; lower draws first. */
+    sidebarOrder?: number;
+    keybinds?: Record<string, string>;
+}
+export interface TrustSettings {
+    enabled: boolean;
+    threshold: number;
+    dangerExtra: number;
+    expireDays: number;
+    sidebar: boolean;
+    sidebarRows: number;
+}
+export declare const DEFAULTS: TrustSettings;
+export declare const CONFIG_FILE = "config.json";
+export declare const PROJECT_FILE = ".cockpit.json";
+export declare function globalConfigPath(env?: Record<string, string | undefined>): string;
+/** The `trust` section of a config file. */
+export declare function trustSection(raw: unknown): TrustConfig;
+/**
+ * Plugin-entry options: a whole cockpit config (`{ trust: {...} }`) or Trust's own keys, because the
+ * bundle hands each bay its own section and a standalone entry carries them directly.
+ */
+export declare function asTrustConfig(input: unknown): TrustConfig;
+export declare function mergeTrust(base: TrustConfig, over: TrustConfig): TrustConfig;
+/** Reads and merges every source, without blocking the interface thread. */
+export declare function loadTrustConfig(directory: string, options?: unknown, env?: Record<string, string | undefined>): Promise<TrustConfig>;
+/** Settings with every gap filled and every number made sensible: a threshold of 0 would trust anything. */
+export declare function resolveSettings(config: TrustConfig): TrustSettings;