rtrt-agent 0.1.7 → 0.2.0

package/tui/v2/native-runtime.mjs

@@ -0,0 +1,81 @@
+import { spawn } from "node:child_process"
+import { isAbsolute } from "node:path"
+import { createStatuslineController, runStatusline } from "../rtrt-statusline-core.mjs"
+
+/** @typedef {import("@opencode/plugin/tui").Plugin.Context} Context */
+/** @typedef {import("@opencode/plugin/tui/context").SlotMap["prompt.footer.status"]} FooterInput */
+
+/** @type {readonly import("@opencode/client").OpenCodeEvent["type"][]} */
+export const NATIVE_REFRESH_EVENTS = Object.freeze([
+  "session.created", "session.deleted", "session.renamed", "session.moved",
+  "session.model.selected", "session.status", "session.idle",
+  "session.step.ended", "session.step.failed",
+  "session.usage.updated",
+  "session.compaction.ended", "session.compaction.failed",
+  "model.updated", "provider.updated",
+])
+
+/**
+ * @param {Context} ctx
+ * @param {{readonly sessionID: () => string, readonly refresh: () => void, readonly dispose: () => void}} entry
+ * @param {(input: FooterInput) => import("@opentui/solid").JSX.Element} render
+ */
+export function registerNativeStatusline(ctx, entry, render) {
+  /** @type {Array<() => void>} */
+  const disposers = []
+  let disposed = false
+  const cleanup = () => {
+    if (disposed) return
+    disposed = true
+    /** @type {unknown[]} */
+    const errors = []
+    for (const dispose of [entry.dispose, ...disposers.reverse()]) {
+      try { dispose() } catch (error) { errors.push(error) }
+    }
+    if (errors.length) throw new AggregateError(errors, "Native statusline cleanup failed")
+  }
+  try {
+    for (const name of NATIVE_REFRESH_EVENTS) {
+      disposers.push(ctx.data.on(name, (event) => {
+        if (disposed) return
+        if ("sessionID" in event.data && event.data.sessionID !== entry.sessionID()) return
+        entry.refresh()
+      }))
+    }
+    disposers.push(ctx.ui.slot({ append: "prompt.footer.status", render }))
+    return cleanup
+  } catch (error) {
+    try { cleanup() } catch (cleanupError) {
+      throw new AggregateError([error, cleanupError], "Native statusline registration failed")
+    }
+    throw error
+  }
+}
+
+/**
+ * The existing controller serializes refreshes and owns subprocess aborts.
+ * The runner keeps its 1.5s total deadline, 64KiB cap and shell:false argv.
+ * An explicit bin must be absolute and never falls back after failure.
+ * When omitted, the optional CLI uses RTRT_BIN then PATH's rtrt; if neither
+ * works, the shared view shows unavailable rather than inventing CLI data.
+ * @param {Readonly<Record<string, unknown>>} options
+ * @param {(state: import("../rtrt-statusline-core.mjs").StatuslineState) => void} onState
+ * @param {typeof spawn} [spawnImpl]
+ */
+export function createNativeController(options, onState, spawnImpl = spawn) {
+  const explicit = Object.hasOwn(options, "bin")
+  const bin = typeof options["bin"] === "string" ? options["bin"] : undefined
+  /** @type {(binary: string, args: readonly string[], settings: import("node:child_process").SpawnOptions) => import("node:child_process").ChildProcess | undefined} */
+  const spawnCandidate = (binary, args, settings) => {
+    // Keep the shared legacy runner unchanged, but deny its fallback candidates.
+    if (explicit && binary !== bin) return undefined
+    return spawnImpl(binary, args, settings)
+  }
+  return createStatuslineController({
+    load: (context, signal) => {
+      if (explicit && (bin === undefined || !isAbsolute(bin))) return undefined
+      return runStatusline({ ...context, bin, signal, spawnImpl: spawnCandidate })
+    },
+    onState,
+  })
+}

package/tui/v2/native-state.mjs

@@ -0,0 +1,66 @@
+import { deriveSessionEconomics } from "../rtrt-statusline-core.mjs"
+
+/** @typedef {import("@opencode/plugin/tui").Plugin.Context} Context */
+
+/** @param {never} value @returns {never} */
+function assertNever(value) {
+  throw new TypeError(`Unsupported native route: ${String(value)}`)
+}
+
+/**
+ * @param {Context} ctx
+ * @param {string} [slotSessionID]
+ */
+export function activeSessionID(ctx, slotSessionID) {
+  if (slotSessionID !== undefined) return slotSessionID
+  const route = ctx.ui.router.current()
+  switch (route.type) {
+    case "session": return route.sessionID
+    case "home":
+    case "plugin": return ""
+    default: return assertNever(route)
+  }
+}
+
+/**
+ * Translate only documented 2.0.20 values; never use aggregate session tokens
+ * as context usage, message costs as session spend, or pricing as quota.
+ * @param {Context} ctx
+ * @param {string} sessionID
+ * @param {ReturnType<Context["ui"]["model"]["current"]>} [selected]
+ * @returns {{ readonly cwd: string, readonly economics: import("../rtrt-statusline-core.mjs").StatuslineEconomics }}
+ */
+export function nativeSnapshot(ctx, sessionID, selected = ctx.ui.model.current()) {
+  const session = sessionID ? ctx.data.session.get(sessionID) : undefined
+  const location = session?.location ?? ctx.location ?? ctx.data.location.default()
+  const models = ctx.data.location.model.list(location) ?? []
+  const providers = Array.from(new Set(models.map((model) => model.providerID)), (id) => ({
+    id,
+    models: Object.fromEntries(models.filter((model) => model.providerID === id).map((model) => [model.id, model])),
+  }))
+  const model = selected ? { id: selected.modelID, providerID: selected.providerID } : session?.model
+  const messages = session ? ctx.data.session.message.list(sessionID) : []
+  const economics = deriveSessionEconomics({
+    session: {
+      ...(session ? { cost: session.cost } : {}),
+      ...(model ? { model } : {}),
+    },
+    messages: messages.filter((message) => message.type === "assistant").map((message) => ({
+      role: "assistant",
+      providerID: message.model.providerID,
+      modelID: message.model.id,
+      time: message.time,
+      ...(message.tokens ? { tokens: message.tokens } : {}),
+      ...(message.error ? { error: message.error } : {}),
+    })),
+    providers,
+    status: { type: session && ctx.data.session.status(sessionID) === "running" ? "busy" : "idle" },
+  })
+  return {
+    cwd: location.directory,
+    economics: {
+      ...economics,
+      status: session ? economics.status : { text: "UNKNOWN", tone: "muted" },
+    },
+  }
+}

package/tui/v2/rtrt-statusline.tsx

@@ -0,0 +1,116 @@
+/** @jsxImportSource @opentui/solid */
+import type { Plugin } from "@opencode/plugin/tui"
+import type { SlotMap } from "@opencode/plugin/tui/context"
+import type { BoxRenderable } from "@opentui/core"
+import { useTerminalDimensions } from "@opentui/solid"
+import { createEffect, createMemo, createSignal, For, onMount, untrack } from "solid-js"
+import {
+  createStatuslineViewModel,
+  initialStatuslineState,
+  type StatuslineState,
+  type StatuslineViewPart,
+} from "../rtrt-statusline-core.mjs"
+import { activeSessionID, nativeSnapshot } from "./native-state.mjs"
+import { createNativeController, registerNativeStatusline } from "./native-runtime.mjs"
+
+// Preserve the legacy footer's two-cell gutters, inherited terminal typography,
+// truncation and responsive view model. All colors come from the native theme.
+const GUTTER = 2
+
+function partColor(theme: Plugin.Context["theme"], part: StatuslineViewPart) {
+  switch (part.role) {
+    case "separator": return theme.border.base
+    case "label": return theme.text.muted
+    case "badge":
+    case "value": return {
+      accent: theme.hue.accent[600],
+      good: theme.text.feedback.success.base,
+      warn: theme.text.feedback.warning.base,
+      bad: theme.text.feedback.error.base,
+      muted: theme.text.muted,
+    }[part.tone]
+    default: {
+      const exhaustive: never = part.role
+      return exhaustive
+    }
+  }
+}
+
+type Entry = {
+  readonly state: () => StatuslineState
+  readonly revision: () => number
+  readonly controller: ReturnType<typeof createNativeController>
+}
+
+function NativeLine(props: {
+  readonly ctx: Plugin.Context
+  readonly input: SlotMap["prompt.footer.status"]
+  readonly entry: Entry
+}) {
+  const dimensions = useTerminalDimensions()
+  const [measuredWidth, setMeasuredWidth] = createSignal<number>()
+  const width = createMemo(() => Math.max(1, (measuredWidth() ?? dimensions().width) - GUTTER * 2))
+  const sessionID = () => activeSessionID(props.ctx, props.input.sessionID)
+  const snapshot = createMemo(() => {
+    props.entry.revision()
+    const session = sessionID()
+    const selected = props.ctx.ui.model.current()
+    // Stream deltas never subscribe the footer to every token.
+    return untrack(() => nativeSnapshot(props.ctx, session, selected))
+  })
+  const view = createMemo(() => createStatuslineViewModel(props.entry.state(), {
+    width: width(), economics: snapshot().economics,
+  }))
+  createEffect(() => {
+    props.entry.controller.setContext({
+      cwd: snapshot().cwd,
+      session: sessionID(),
+      width: width(),
+      model: snapshot().economics.modelRef ?? "",
+    })
+  })
+  onMount(() => props.entry.controller.start())
+
+  return (
+    <box
+      width="100%"
+      height={view().rows.length}
+      flexDirection="column"
+      flexShrink={0}
+      paddingLeft={GUTTER}
+      paddingRight={GUTTER}
+      overflow="hidden"
+      onSizeChange={function (this: BoxRenderable) { setMeasuredWidth(this.width) }}
+    >
+      <For each={view().rows}>
+        {(row) => (
+          <text fg={props.ctx.theme.text.muted} wrapMode="none" truncate>
+            <For each={row.parts}>
+              {(part) => <span style={{ fg: partColor(props.ctx.theme, part) }}>{part.text}</span>}
+            </For>
+          </text>
+        )}
+      </For>
+    </box>
+  )
+}
+
+export default {
+  id: "rtrt-statusline",
+  setup(ctx) {
+    if (ctx.options["enabled"] === false) return
+    const [state, setState] = createSignal(initialStatuslineState())
+    const [revision, setRevision] = createSignal(0)
+    const refreshEconomics = () => { setRevision((value) => value + 1) }
+    const controller = createNativeController(ctx.options, (next) => {
+      setState(next)
+      refreshEconomics()
+    })
+    const entry: Entry = { state, revision, controller }
+    return registerNativeStatusline(ctx, {
+      sessionID: () => controller.getContext().session,
+      refresh: () => { refreshEconomics(); controller.request() },
+      dispose: controller.dispose,
+    }, (input) => <NativeLine ctx={ctx} input={input} entry={entry} />)
+  },
+} satisfies Plugin.Definition

package/v2/permissions.js

@@ -0,0 +1,119 @@
+import { constants } from "node:fs"
+import { lstat, open } from "node:fs/promises"
+import { homedir } from "node:os"
+import path from "node:path"
+
+const SESSION_ID = /^[A-Za-z0-9_-]{1,256}$/
+const OWNER = "rtrt-opencode-task-agents"
+const MANAGER = "rtrt-manager"
+const STATE_LIMIT = 65_536
+const configuredPath = (value) => typeof value === "string" && value.length > 0 && !value.includes("\0")
+
+function boundedState(value, depth = 8, count = { value: 0 }) {
+  count.value++
+  if (count.value > 512 || depth < 0) return false
+  if (!value || typeof value !== "object") return true
+  const items = Object.values(value)
+  if (items.length > 128) return false
+  return items.every((item) => boundedState(item, depth - 1, count))
+}
+
+function secureStateFile(stat, uid) {
+  return stat.isFile() && !stat.isSymbolicLink() && stat.uid === uid &&
+    stat.nlink === 1n && (stat.mode & 0o777n) === 0o600n && stat.size <= BigInt(STATE_LIMIT)
+}
+
+function sameFile(left, right) {
+  return ["dev", "ino", "uid", "mode", "nlink", "size", "mtimeNs", "ctimeNs"]
+    .every((field) => left[field] === right[field])
+}
+
+async function secureAncestors(file, uid, statPath = lstat) {
+  let directory = path.dirname(file)
+  while (true) {
+    const stat = await statPath(directory, { bigint: true })
+    if (!stat.isDirectory() || stat.isSymbolicLink() ||
+      (stat.uid !== uid && stat.uid !== 0n) || (stat.mode & 0o022n) !== 0n) return false
+    const parent = path.dirname(directory)
+    if (parent === directory) return true
+    directory = parent
+  }
+}
+
+export function managedAgentStatePath(env = process.env) {
+  const home = configuredPath(env.HOME) ? env.HOME : homedir()
+  const root = configuredPath(env.OPENCODE_CONFIG_DIR)
+    ? path.resolve(env.OPENCODE_CONFIG_DIR)
+    : configuredPath(env.XDG_CONFIG_HOME)
+      ? path.resolve(env.XDG_CONFIG_HOME, "opencode")
+      : path.resolve(home, ".config", "opencode")
+  return path.join(root, "agents", ".rtrt-managed-state.json")
+}
+
+export async function loadAgents(file, io = { lstat, open }) {
+  let handle
+  let result
+  try {
+    const currentUser = process.getuid?.()
+    if (currentUser === undefined || typeof file !== "string" || !path.isAbsolute(file) || file.includes("\0")) return undefined
+    const uid = BigInt(currentUser)
+    if (!(await secureAncestors(file, uid, io.lstat))) return undefined
+    const stat = await io.lstat(file, { bigint: true })
+    if (!secureStateFile(stat, uid)) return undefined
+    handle = await io.open(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0))
+    const opened = await handle.stat({ bigint: true })
+    if (!secureStateFile(opened, uid) || !sameFile(stat, opened)) return undefined
+    const raw = await handle.readFile("utf8")
+    if (Buffer.byteLength(raw) > STATE_LIMIT) return undefined
+    const after = await handle.stat({ bigint: true })
+    const finalPath = await io.lstat(file, { bigint: true })
+    if (!sameFile(opened, after) || !sameFile(opened, finalPath) ||
+      !(await secureAncestors(file, uid, io.lstat))) return undefined
+    const state = JSON.parse(raw)
+    if (!state || typeof state !== "object" || Array.isArray(state) || !boundedState(state)) return undefined
+    if (state.owner !== OWNER || state.version !== 1 || !Array.isArray(state.agents)) return undefined
+    if (state.agents.length < 1 || state.agents.length > 128 || !state.agents.every((id) =>
+      typeof id === "string" && SESSION_ID.test(id))) return undefined
+    const agents = new Set(state.agents)
+    result = agents.size === state.agents.length && agents.has(MANAGER) ? agents : undefined
+  } catch {
+    // State is an authorization boundary; unreadable or malformed state fails closed.
+    return undefined
+  } finally {
+    if (handle) {
+      try { await handle.close() } catch { result = undefined }
+    }
+  }
+  return result
+}
+
+export async function createPermissionEvaluator(ctx, statePath = managedAgentStatePath(), active = () => true) {
+  const managed = await loadAgents(statePath)
+  const project = ctx.location.project
+  const directory = ctx.location.directory
+  return async (request) => {
+    if (
+      !active() || !managed || request.effect !== "ask" || request.action !== "shell" ||
+      request.resources?.length !== 1 || request.resources[0] !== "pwd" ||
+      !SESSION_ID.test(request.sessionID ?? "")
+    ) return
+    try {
+      const session = await ctx.session.get({ sessionID: request.sessionID })
+      if (
+        session?.id !== request.sessionID || !managed.has(session.agent) ||
+        session.agent === MANAGER || request.agent && request.agent !== session.agent ||
+        session.projectID !== project.id || session.location?.directory !== directory ||
+        !SESSION_ID.test(session.parentID ?? "")
+      ) return
+      const parent = await ctx.session.get({ sessionID: session.parentID })
+      if (
+        parent?.id !== session.parentID || parent.agent !== MANAGER ||
+        parent.projectID !== project.id || parent.location?.directory !== directory
+      ) return
+      if (active() && request.effect === "ask") request.effect = "allow"
+    } catch {
+      // Unknown session or unavailable host API must preserve the host's decision.
+      return
+    }
+  }
+}