opencode-overclock 0.3.0 → 0.5.0

package/src/features/tasks.ts

@@ -2,7 +2,10 @@ import { stat } from "node:fs/promises"
 import { tool } from "@opencode-ai/plugin"
 import type { FeatureModule } from "../types.ts"
 import { ensureStateDir, shellQuote, writeJson } from "../lib/state.ts"
+import { taskStore, type TaskMirrorEntry } from "../lib/mirror.ts"
 import { inject, toast } from "../lib/inject.ts"
+import { killProcessTree, NON_INTERACTIVE_ENV, redactSensitiveOutput, sanitizeEnv } from "../lib/exec.ts"
+import { spawnTaskPane, type TmuxPane } from "../lib/tmux.ts"
 
 const z = tool.schema
 
@@ -16,6 +19,22 @@ const PROMPT_PATTERNS = [
   /Overwrite\?/i,
 ]
 
+const INTERACTIVE_COMMAND_PATTERNS = [
+  /^\s*(?:vi|vim|nvim|nano|pico|emacs)\b/i,
+  /^\s*git\s+(?:rebase\s+-i|commit\s+--amend(?!\s+-m))/i,
+  /^\s*git\s+add\s+-p\b/i,
+  /^\s*(?:python|python3|node|irb|ghci|bash|sh|zsh)\s*$/i,
+]
+
+/** Detects if a command is explicitly interactive (e.g. editor, rebase -i, bare REPL). */
+export function detectInteractiveCommand(command: string): string | null {
+  for (const pattern of INTERACTIVE_COMMAND_PATTERNS) {
+    const match = command.match(pattern)
+    if (match) return match[0].trim()
+  }
+  return null
+}
+
 /** Last non-empty line of `tail` looks like an interactive y/n or press-key prompt. */
 export function looksLikePrompt(tail: string): boolean {
   const lastLine = tail.trimEnd().split("\n").pop() ?? ""
@@ -39,14 +58,7 @@ interface TaskEntry extends TaskRecord {
   stallTimer?: ReturnType<typeof setInterval>
   stallNotified: boolean
   startedAt: number
-}
-
-interface TaskMirrorEntry {
-  id: string
-  description: string
-  status: TaskRecord["status"]
-  exitCode: number | null
-  startedAt: number
+  tmuxPane?: TmuxPane
 }
 
 export interface TaskManager {
@@ -95,7 +107,8 @@ function startStallWatchdog(
           lastGrowth = Date.now()
           return
         }
-        if (Date.now() - lastGrowth < thresholdMs || entry.stallNotified) return
+        if (Date.now() - lastGrowth < thresholdMs || entry.stallNotified || entry.status !== "running")
+          return
         const file = Bun.file(entry.logPath)
         const start = Math.max(0, s.size - tailBytes)
         const tail = await file.slice(start).text()
@@ -114,20 +127,55 @@ function startStallWatchdog(
   }, checkIntervalMs)
 }
 
+export async function readLogTail(logPath: string, tailLines = 50): Promise<string> {
+  const file = Bun.file(logPath)
+  if (!(await file.exists())) return "(no output)"
+  const s = await stat(logPath).catch(() => null)
+  if (!s || s.size === 0) return "(no output)"
+
+  const effectiveTail = Math.max(1, tailLines)
+  // Cap read window to last 512KB to prevent memory exhaustion on giant log files
+  const maxBytes = 512 * 1024
+  const start = Math.max(0, s.size - maxBytes)
+  const text = await (start > 0 ? file.slice(start).text() : file.text())
+  const lines = text.trimEnd().split("\n")
+  return lines.slice(-effectiveTail).join("\n")
+}
+
 /** Exported for tests. onExit fires after status/exitCode settled. */
 export function createTaskManager(opts: {
   logDir: string
   /** mirror JSON path, written on every state change (spawn/exit/kill); omit to disable */
   mirrorPath?: string
-  onExit?: (task: TaskRecord) => void
+  onExit?: (task: TaskRecord) => void | Promise<void>
   /** enables the stall watchdog; absent -> no polling at all */
   onStall?: (task: TaskRecord, tail: string) => void
   stallCheckIntervalMs?: number
   stallThresholdMs?: number
   stallTailBytes?: number
+  /** spawn a tmux split pane to tail task logs (only if TMUX is active) */
+  tmux?: boolean
+  sanitizeEnv?: boolean
+  envAllowlist?: string[]
+  maxTasks?: number
 }): TaskManager {
   const tasks = new Map<string, TaskEntry>()
   let counter = 0
+  const maxRetainedTasks = opts.maxTasks ?? 100
+
+  function pruneFinishedTasks(): void {
+    if (tasks.size <= maxRetainedTasks) return
+    const finished: string[] = []
+    for (const [id, entry] of tasks) {
+      if (entry.status !== "running") {
+        finished.push(id)
+      }
+    }
+    const toRemove = tasks.size - maxRetainedTasks
+    for (let i = 0; i < Math.min(toRemove, finished.length); i++) {
+      tasks.delete(finished[i]!)
+    }
+  }
 
   function persistMirror(): void {
     if (!opts.mirrorPath) return
@@ -150,10 +198,38 @@ export function createTaskManager(opts: {
   }): TaskRecord {
     const id = `t${(++counter).toString(36)}-${crypto.randomUUID().slice(0, 6)}`
     const logPath = `${opts.logDir}/${id}.log`
-    // shell-level redirection: no piping code, survives plugin restart losing streams
-    const proc = Bun.spawn(["bash", "-c", `(${input.command}) >> ${shellQuote(logPath)} 2>&1`], {
-      cwd: input.cwd,
-    })
+
+    let proc: Bun.Subprocess
+    try {
+      proc = Bun.spawn(["bash", "-c", `(${input.command}) >> ${shellQuote(logPath)} 2>&1`], {
+        cwd: input.cwd,
+        env: {
+          ...(opts.sanitizeEnv === false ? process.env : sanitizeEnv(process.env, opts.envAllowlist)),
+          ...NON_INTERACTIVE_ENV,
+        },
+      })
+    } catch (e) {
+      console.warn(`[overclock] failed to spawn task ${id}: ${e}`)
+      const failedEntry: TaskEntry = {
+        id,
+        description: input.description,
+        command: input.command,
+        cwd: input.cwd,
+        sessionID: input.sessionID,
+        status: "exited",
+        exitCode: 1,
+        logPath,
+        proc: null as any,
+        stallNotified: false,
+        startedAt: Date.now(),
+      }
+      tasks.set(id, failedEntry)
+      pruneFinishedTasks()
+      persistMirror()
+      opts.onExit?.(strip(failedEntry))
+      return strip(failedEntry)
+    }
+
     const entry: TaskEntry = {
       id,
       description: input.description,
@@ -169,6 +245,13 @@ export function createTaskManager(opts: {
     }
     tasks.set(id, entry)
     persistMirror()
+    let panePromise: Promise<TmuxPane | null> | undefined
+    if (opts.tmux) {
+      panePromise = spawnTaskPane(entry.logPath, entry.description)
+      panePromise.then((pane) => {
+        if (pane) entry.tmuxPane = pane
+      })
+    }
     if (input.timeoutMs) {
       entry.timeoutTimer = setTimeout(() => kill(id), input.timeoutMs)
     }
@@ -181,13 +264,24 @@ export function createTaskManager(opts: {
         opts.onStall,
       )
     }
-    proc.exited.then((code) => {
+    proc.exited.then(async (code) => {
       if (entry.timeoutTimer) clearTimeout(entry.timeoutTimer)
       if (entry.stallTimer) clearInterval(entry.stallTimer)
+      if (panePromise) {
+        const pane = await panePromise
+        pane?.close()
+      } else if (entry.tmuxPane) {
+        void entry.tmuxPane.close()
+      }
       if (entry.status === "running") entry.status = "exited"
       entry.exitCode = code
       persistMirror()
-      opts.onExit?.(strip(entry))
+      try {
+        await opts.onExit?.(strip(entry))
+      } finally {
+        pruneFinishedTasks()
+        persistMirror()
+      }
     })
     return strip(entry)
   }
@@ -196,12 +290,16 @@ export function createTaskManager(opts: {
     const entry = tasks.get(id)
     if (!entry || entry.status !== "running") return false
     entry.status = "killed"
+    pruneFinishedTasks()
     persistMirror()
     if (entry.stallTimer) clearInterval(entry.stallTimer)
     entry.stallTimer = undefined
-    entry.proc.kill("SIGTERM")
-    const hard = setTimeout(() => entry.proc.kill("SIGKILL"), 3000)
-    entry.proc.exited.then(() => clearTimeout(hard))
+    if (entry.tmuxPane) void entry.tmuxPane.close()
+    if (entry.proc) {
+      void killProcessTree(entry.proc, "SIGTERM")
+      const hard = setTimeout(() => void killProcessTree(entry.proc, "SIGKILL"), 3000)
+      entry.proc.exited.then(() => clearTimeout(hard))
+    }
     return true
   }
 
@@ -216,10 +314,7 @@ export function createTaskManager(opts: {
     output: async (id, tailLines = 50) => {
       const e = tasks.get(id)
       if (!e) return `no task ${id}`
-      const file = Bun.file(e.logPath)
-      if (!(await file.exists())) return "(no output)"
-      const lines = (await file.text()).split("\n")
-      return lines.slice(-tailLines - 1).join("\n")
+      return readLogTail(e.logPath, tailLines)
     },
     killAll: () => {
       for (const id of tasks.keys()) kill(id)
@@ -237,17 +332,10 @@ const fmt = (t: TaskRecord) =>
 export const tasks: FeatureModule = {
   name: "tasks",
   tools: ["task_run", "task_status", "task_output", "task_kill"],
-  options: {
-    killOnExit: "boolean",
-    stallDetection: "boolean",
-    stallThresholdMs: "number",
-    stallCheckIntervalMs: "number",
-  },
   defaultEnabled: true,
   requires: ["session.promptAsync", "session.messages"],
   async init(ctx, options, shared) {
     const logDir = await ensureStateDir(ctx.directory, "tasks")
-    const stateDir = await ensureStateDir(ctx.directory)
     const killOnExit = options.killOnExit !== false
     const stallDetection = options.stallDetection !== false
     const stallThresholdMs =
@@ -257,10 +345,15 @@ export const tasks: FeatureModule = {
 
     const manager = createTaskManager({
       logDir,
-      mirrorPath: `${stateDir}/tasks.json`,
+      mirrorPath: taskStore.path(ctx.directory),
+      tmux: options.tmux === true,
+      sanitizeEnv: options.sanitizeEnv !== false,
+      envAllowlist: Array.isArray(options.envAllowlist) ? (options.envAllowlist as string[]) : undefined,
+      maxTasks: typeof options.maxTasks === "number" ? options.maxTasks : 100,
       onExit: async (task) => {
         if (task.status === "killed") return
-        const tail = await manager.output(task.id, 20)
+        const rawTail = await readLogTail(task.logPath, 20)
+        const tail = redactSensitiveOutput(rawTail)
         const ok = task.exitCode === 0
         await toast(
           ctx.client,
@@ -278,12 +371,13 @@ export const tasks: FeatureModule = {
             stallThresholdMs,
             stallCheckIntervalMs,
             onStall: async (task: TaskRecord, tail: string) => {
+              const safeTail = redactSensitiveOutput(tail.trimEnd())
               await toast(ctx.client, `task ${task.id} looks stalled (waiting for input?)`, "warning")
               await inject(
                 ctx.client,
                 task.sessionID,
                 `[background task ${task.id} "${task.description}" appears to be waiting for interactive input]\n` +
-                  `last output:\n${tail.trimEnd()}\n\n` +
+                  `last output:\n${safeTail}\n\n` +
                   `The command is likely blocked on a prompt. Kill it with ${shared.toolName("task_kill")} and re-run non-interactively ` +
                   `(e.g. pipe input like \`echo y | cmd\`, or pass a --yes/--force flag).`,
               )
@@ -293,6 +387,9 @@ export const tasks: FeatureModule = {
     })
 
     return {
+      "shell.env": async (_input, output) => {
+        Object.assign(output.env, NON_INTERACTIVE_ENV)
+      },
       dispose: async () => {
         if (killOnExit) manager.killAll()
       },
@@ -307,6 +404,10 @@ export const tasks: FeatureModule = {
             timeout: z.number().optional().describe("seconds until auto-kill"),
           },
           async execute(args, tctx) {
+            const blocked = detectInteractiveCommand(args.command)
+            if (blocked) {
+              return `Error: Command '${args.command}' appears to require interactive input (${blocked}). Background tasks run non-interactively and will hang on prompts.`
+            }
             const task = manager.run({
               command: args.command,
               description: args.description,

package/src/features/truncator.ts

@@ -0,0 +1,116 @@
+import type { FeatureModule } from "../types.ts"
+
+export const DEFAULT_TRUNCATABLE_TOOLS = ["task_output", "bash", "grep", "glob", "webfetch"]
+
+export const DEFAULT_MAX_CHARS = 40_000
+export const DEFAULT_HEAD_LINES = 10
+export const DEFAULT_TAIL_LINES = 30
+
+export interface TruncateResult {
+  text: string
+  truncated: boolean
+  omittedLines: number
+  omittedChars: number
+}
+
+/**
+ * Smartly truncate output preserving top context and bottom tail.
+ * Enforces strict character and line bounds so oversized lines never overflow context.
+ */
+export function truncateOutput(
+  content: string,
+  maxChars = DEFAULT_MAX_CHARS,
+  headLinesCount = DEFAULT_HEAD_LINES,
+  tailLinesCount = DEFAULT_TAIL_LINES,
+): TruncateResult {
+  const effectiveMax = Math.max(100, maxChars)
+  if (content.length <= effectiveMax) {
+    return { text: content, truncated: false, omittedLines: 0, omittedChars: 0 }
+  }
+
+  const headCount = Math.max(0, headLinesCount)
+  const tailCount = Math.max(0, tailLinesCount)
+  const lines = content.split("\n")
+
+  const maxHeadChars = Math.floor(effectiveMax * 0.3)
+  const maxTailChars = Math.floor(effectiveMax * 0.7)
+
+  if (lines.length <= headCount + tailCount) {
+    // If few lines but very long strings, hard slice
+    const head = content.slice(0, maxHeadChars)
+    const tail = maxTailChars > 0 ? content.slice(-maxTailChars) : ""
+    const omittedChars = Math.max(0, content.length - head.length - tail.length)
+    return {
+      text: `${head}\n\n[... truncated ${omittedChars} characters to stay within context limits ...]\n\n${tail}`,
+      truncated: true,
+      omittedLines: 0,
+      omittedChars,
+    }
+  }
+
+  let head = headCount > 0 ? lines.slice(0, headCount).join("\n") : ""
+  let tail = tailCount > 0 ? lines.slice(-tailCount).join("\n") : ""
+
+  // Guard against giant single lines in head or tail violating maxChars limit
+  if (head.length > maxHeadChars) {
+    head = head.slice(0, maxHeadChars) + "\n... [line truncated]"
+  }
+  if (tail.length > maxTailChars) {
+    tail = "[line truncated] ...\n" + (maxTailChars > 0 ? tail.slice(-maxTailChars) : "")
+  }
+
+  const omittedLines = Math.max(0, lines.length - headCount - tailCount)
+  const omittedChars = Math.max(0, content.length - head.length - tail.length)
+
+  const text = `${head}\n\n[... truncated ${omittedLines} lines (${omittedChars} chars) to stay within context limits ...]\n\n${tail}`
+  return {
+    text,
+    truncated: true,
+    omittedLines,
+    omittedChars,
+  }
+}
+
+export interface TruncatorOptions {
+  maxChars?: number
+  tools?: string[]
+  headLines?: number
+  tailLines?: number
+}
+
+/**
+ * Truncator feature module: guards against sudden context window exhaustion
+ * by trimming high-volume tool outputs while keeping diagnostic head and tail lines.
+ */
+export const truncator: FeatureModule = {
+  name: "truncator",
+  tools: [],
+  defaultEnabled: true,
+  async init(_ctx, options, shared) {
+    const maxChars = typeof options.maxChars === "number" ? options.maxChars : DEFAULT_MAX_CHARS
+    const rawTools = Array.isArray(options.tools)
+      ? (options.tools as string[])
+      : DEFAULT_TRUNCATABLE_TOOLS
+    const targetTools = new Set(
+      rawTools.flatMap((t) => {
+        const lower = t.toLowerCase()
+        const remapped = shared?.toolName ? shared.toolName(t).toLowerCase() : lower
+        return [lower, remapped]
+      }),
+    )
+    const headLines = typeof options.headLines === "number" ? options.headLines : DEFAULT_HEAD_LINES
+    const tailLines = typeof options.tailLines === "number" ? options.tailLines : DEFAULT_TAIL_LINES
+
+    return {
+      "tool.execute.after": async (input, output) => {
+        if (!targetTools.has(input.tool.toLowerCase())) return
+        if (typeof output.output !== "string") return
+
+        const res = truncateOutput(output.output, maxChars, headLines, tailLines)
+        if (res.truncated) {
+          output.output = res.text
+        }
+      },
+    }
+  },
+}

package/src/features/usage.ts

@@ -1,27 +1,9 @@
-import { tool } from "@opencode-ai/plugin"
 import type { FeatureModule } from "../types.ts"
 import { ensureStateDir, readJson, writeJson } from "../lib/state.ts"
+import { usageStore, type DayBucket, type UsageState, type UsageTokens } from "../lib/mirror.ts"
 
-const z = tool.schema
-
-export interface UsageTokens {
-  input: number
-  output: number
-  reasoning: number
-  cacheRead: number
-  cacheWrite: number
-}
-
-export interface DayBucket {
-  cost: number
-  tokens: UsageTokens
-  messages: number
-  seen: string[]
-}
-
-export interface UsageState {
-  days: Record<string, DayBucket>
-}
+// Declared in platform/storage/store.ts so the TUI can inspect usage data without importing this feature module.
+export type { UsageTokens, DayBucket, UsageState } from "../lib/mirror.ts"
 
 export interface SessionUsage {
   sessionID: string
@@ -30,6 +12,8 @@ export interface SessionUsage {
 }
 
 const RETENTION_DAYS = 60
+const MAX_SEEN_PER_DAY = 1000
+const MAX_TRACKED_SESSIONS = 200
 
 function zeroTokens(): UsageTokens {
   return { input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0 }
@@ -91,6 +75,7 @@ export function createUsageTracker(opts: UsageTrackerOpts): UsageTracker {
   }
 
   async function flush(): Promise<void> {
+    pruneOldDays(state, Date.now())
     await writeJson(opts.statePath, state)
   }
 
@@ -99,49 +84,51 @@ export function createUsageTracker(opts: UsageTrackerOpts): UsageTracker {
     pruneOldDays(state, Date.now())
   }
 
+  function extractTokens(t: any): UsageTokens {
+    return {
+      input: t?.input ?? 0,
+      output: t?.output ?? 0,
+      reasoning: t?.reasoning ?? 0,
+      cacheRead: t?.cache?.read ?? 0,
+      cacheWrite: t?.cache?.write ?? 0,
+    }
+  }
+
   function onEvent(event: { type: string; properties?: unknown }): void {
     try {
+      if (event.type === "session.deleted") {
+        const props = event.properties as { sessionID?: string; info?: { id?: string } } | undefined
+        const id = props?.sessionID ?? props?.info?.id
+        if (id) sessions.delete(id)
+        return
+      }
+
       if (event.type !== "message.updated") return
-      const info = (event.properties as { info?: unknown } | undefined)?.info as
-        | {
-            id?: string
-            role?: string
-            sessionID?: string
-            time?: { created?: number; completed?: number }
-            cost?: number
-            tokens?: {
-              input?: number
-              output?: number
-              reasoning?: number
-              cache?: { read?: number; write?: number }
-            }
-          }
-        | undefined
-      if (!info || info.role !== "assistant") return
-      if (!info.time?.completed) return
+      const info = (event.properties as any)?.info
+      if (!info || info.role !== "assistant" || !info.time?.completed) return
       if (typeof info.id !== "string" || typeof info.sessionID !== "string") return
+
       const created = info.time.created ?? info.time.completed
       const day = dayKey(created)
       const bucket = state.days[day] ?? emptyBucket()
       state.days[day] = bucket
       if (bucket.seen.includes(info.id)) return
+
+      if (bucket.seen.length >= MAX_SEEN_PER_DAY) {
+        bucket.seen = bucket.seen.slice(-MAX_SEEN_PER_DAY + 1)
+      }
       bucket.seen.push(info.id)
 
       const cost = info.cost ?? 0
-      const t = info.tokens ?? {}
-      const input = t.input ?? 0
-      const output = t.output ?? 0
-      const reasoning = t.reasoning ?? 0
-      const cacheRead = t.cache?.read ?? 0
-      const cacheWrite = t.cache?.write ?? 0
+      const tok = extractTokens(info.tokens)
 
       bucket.cost += cost
       bucket.messages += 1
-      bucket.tokens.input += input
-      bucket.tokens.output += output
-      bucket.tokens.reasoning += reasoning
-      bucket.tokens.cacheRead += cacheRead
-      bucket.tokens.cacheWrite += cacheWrite
+      bucket.tokens.input += tok.input
+      bucket.tokens.output += tok.output
+      bucket.tokens.reasoning += tok.reasoning
+      bucket.tokens.cacheRead += tok.cacheRead
+      bucket.tokens.cacheWrite += tok.cacheWrite
 
       const sess = sessions.get(info.sessionID) ?? {
         sessionID: info.sessionID,
@@ -149,10 +136,16 @@ export function createUsageTracker(opts: UsageTrackerOpts): UsageTracker {
         tokens: { input: 0, output: 0 },
       }
       sess.cost += cost
-      sess.tokens.input += input
-      sess.tokens.output += output
+      sess.tokens.input += tok.input
+      sess.tokens.output += tok.output
       sessions.set(info.sessionID, sess)
 
+      if (sessions.size > MAX_TRACKED_SESSIONS) {
+        // Evict oldest session to bound memory
+        const oldest = sessions.keys().next().value
+        if (oldest) sessions.delete(oldest)
+      }
+
       scheduleFlush()
     } catch (e) {
       console.warn(`[overclock] usage: event handling failed: ${e}`)
@@ -236,11 +229,11 @@ export function createUsageTracker(opts: UsageTrackerOpts): UsageTracker {
  */
 export const usage: FeatureModule = {
   name: "usage",
-  tools: ["usage_report"],
+  tools: [],
   defaultEnabled: true,
   async init(ctx) {
     const dir = await ensureStateDir(ctx.directory)
-    const tracker = createUsageTracker({ statePath: `${dir}/usage.json` })
+    const tracker = createUsageTracker({ statePath: usageStore.path(ctx.directory) })
     await tracker.load()
 
     return {
@@ -254,18 +247,6 @@ export const usage: FeatureModule = {
           console.warn(`[overclock] usage: event handling failed: ${e}`)
         }
       },
-      tool: {
-        usage_report: tool({
-          description:
-            "Report cost/token usage for the last N days (default 7) plus today's per-session breakdown.",
-          args: {
-            days: z.number().optional().describe("number of days to report, default 7"),
-          },
-          async execute(args) {
-            return tracker.report(args.days ?? 7)
-          },
-        }),
-      },
     }
   },
 }