opencode-overclock 0.2.2 → 0.4.0

package/src/features/sched.ts

@@ -1,7 +1,9 @@
 import { tool } from "@opencode-ai/plugin"
 import { Cron } from "croner"
-import type { FeatureModule } from "../types.ts"
+import type { FeatureModule, SchedOptions } from "../types.ts"
+import type { BusyTracker } from "../core/types.ts"
 import { ensureStateDir, readJson, writeJson } from "../lib/state.ts"
+import { scheduleStore, type ScheduleEntry } from "../lib/mirror.ts"
 import { inject, toast } from "../lib/inject.ts"
 
 const z = tool.schema
@@ -18,94 +20,157 @@ export function parseSpec(spec: string): Spec {
   return { kind: "cron", expr: spec }
 }
 
-interface Schedule {
-  id: string
-  spec: string
-  prompt: string
-  target: "current" | "new-session"
-  sessionID: string // creator; inject target when target=current
-  createdAt: string
+export type Schedule = ScheduleEntry
+
+export interface ScheduleManager {
+  readonly schedules: Map<string, ScheduleEntry>
+  create(input: {
+    spec: string
+    prompt: string
+    target: "current" | "new-session"
+    sessionID: string
+  }): Promise<{ schedule: ScheduleEntry; next: string }>
+  list(): Array<{ schedule: ScheduleEntry; next: string }>
+  delete(id: string): Promise<boolean>
+  arm(s: ScheduleEntry): void
+  disarm(id: string): void
+  nextRun(s: ScheduleEntry): string
+  dispose(): void
+}
+
+export interface ScheduleManagerDeps {
+  storePath: string
+  client: any
+  busy?: BusyTracker
+  skipIfBusy?: boolean
 }
 
 /**
- * Scheduled runs: cron exprs or plain intervals ("5m"). interval + current session = /loop.
- * Persisted, rearmed on startup.
+ * Encapsulated schedule manager handling timer registration, persistence,
+ * and dispatching prompt injections.
  */
-export const sched: FeatureModule = {
-  name: "sched",
-  tools: ["schedule_create", "schedule_list", "schedule_delete"],
-  options: { skipIfBusy: "boolean" },
-  defaultEnabled: true,
-  requires: ["session.promptAsync", "session.messages", "session.create"],
-  async init(ctx, options, shared) {
-    const dir = await ensureStateDir(ctx.directory)
-    const storePath = `${dir}/schedules.json`
-    const schedules = new Map<string, Schedule>()
-    const timers = new Map<string, Cron | ReturnType<typeof setInterval>>()
-    const skipIfBusy = options.skipIfBusy !== false
-
-    const persist = () => writeJson(storePath, [...schedules.values()])
-
-    async function fire(s: Schedule) {
-      try {
-        if (s.target === "current") {
-          // target still chewing on previous turn -> skip this fire, no pileup
-          if (skipIfBusy && shared.busy.isBusy(s.sessionID)) {
-            await toast(ctx.client, `schedule ${s.id} skipped (session busy)`, "info")
-            return
-          }
-          const ok = await inject(ctx.client, s.sessionID, `[schedule ${s.id} fired]\n${s.prompt}`)
-          if (!ok) await toast(ctx.client, `schedule ${s.id}: target session gone`, "warning")
-        } else {
-          const res = await ctx.client.session.create({ body: { title: `sched:${s.id}` } })
-          const id = res.data?.id
-          if (!id) throw new Error("session.create returned no id")
-          await inject(ctx.client, id, s.prompt)
-          await toast(ctx.client, `schedule ${s.id} fired -> new session`, "info")
+export async function createScheduleManager(deps: ScheduleManagerDeps): Promise<ScheduleManager> {
+  const schedules = new Map<string, ScheduleEntry>()
+  const timers = new Map<string, { stop(): void }>()
+  const skipIfBusy = deps.skipIfBusy !== false
+
+  const persist = async () => writeJson(deps.storePath, [...schedules.values()])
+
+  async function fire(s: ScheduleEntry) {
+    try {
+      if (s.target === "current") {
+        if (skipIfBusy && deps.busy?.isBusy(s.sessionID)) {
+          await toast(deps.client, `schedule ${s.id} skipped (session busy)`, "info")
+          return
         }
-      } catch (e) {
-        console.warn(`[overclock] schedule ${s.id} fire failed: ${e}`)
-        await toast(ctx.client, `schedule ${s.id} failed: ${e}`, "error")
+        const ok = await inject(deps.client, s.sessionID, `[schedule ${s.id} fired]\n${s.prompt}`)
+        if (!ok) await toast(deps.client, `schedule ${s.id}: target session gone`, "warning")
+      } else {
+        const res = await deps.client.session.create({ body: { title: `sched:${s.id}` } })
+        const id = res.data?.id
+        if (!id) throw new Error("session.create returned no id")
+        await inject(deps.client, id, s.prompt)
+        await toast(deps.client, `schedule ${s.id} fired -> new session`, "info")
       }
+    } catch (e) {
+      console.warn(`[overclock] schedule ${s.id} fire failed: ${e}`)
+      await toast(deps.client, `schedule ${s.id} failed: ${e}`, "error")
     }
+  }
 
-    function arm(s: Schedule) {
-      const spec = parseSpec(s.spec)
-      timers.set(
-        s.id,
-        spec.kind === "interval"
-          ? setInterval(() => fire(s), spec.ms)
-          : new Cron(spec.expr, () => fire(s)),
-      )
-    }
+  function arm(s: ScheduleEntry) {
+    const spec = parseSpec(s.spec)
+    const timer =
+      spec.kind === "interval"
+        ? {
+            stop: clearInterval.bind(
+              null,
+              setInterval(() => fire(s), spec.ms),
+            ),
+          }
+        : new Cron(spec.expr, () => fire(s))
+    timers.set(s.id, timer)
+  }
 
-    function disarm(id: string) {
-      const t = timers.get(id)
-      if (!t) return
-      t instanceof Cron ? t.stop() : clearInterval(t)
-      timers.delete(id)
-    }
+  function disarm(id: string) {
+    timers.get(id)?.stop()
+    timers.delete(id)
+  }
+
+  function nextRun(s: ScheduleEntry): string {
+    const spec = parseSpec(s.spec)
+    if (spec.kind === "cron") return new Cron(spec.expr).nextRun()?.toISOString() ?? "never"
+    return `every ${s.spec}`
+  }
 
-    const nextRun = (s: Schedule): string => {
-      const spec = parseSpec(s.spec)
-      if (spec.kind === "cron") return new Cron(spec.expr).nextRun()?.toISOString() ?? "never"
-      return `every ${s.spec}`
+  const stored = await readJson<ScheduleEntry[]>(deps.storePath, [])
+  for (const s of stored) {
+    schedules.set(s.id, s)
+    try {
+      arm(s)
+    } catch (e) {
+      console.warn(`[overclock] rearm ${s.id} failed: ${e}`)
     }
+  }
 
-    // rearm persisted schedules (restart-safe)
-    for (const s of await readJson<Schedule[]>(storePath, [])) {
-      schedules.set(s.id, s)
-      try {
-        arm(s)
-      } catch (e) {
-        console.warn(`[overclock] rearm ${s.id} failed: ${e}`)
+  return {
+    schedules,
+    arm,
+    disarm,
+    nextRun,
+    async create(input) {
+      parseSpec(input.spec)
+      const s: ScheduleEntry = {
+        id: `s-${crypto.randomUUID().slice(0, 6)}`,
+        spec: input.spec,
+        prompt: input.prompt,
+        target: input.target,
+        sessionID: input.sessionID,
+        createdAt: new Date().toISOString(),
       }
-    }
+      schedules.set(s.id, s)
+      arm(s)
+      await persist()
+      return { schedule: s, next: nextRun(s) }
+    },
+    list() {
+      return [...schedules.values()].map((s) => ({ schedule: s, next: nextRun(s) }))
+    },
+    async delete(id: string) {
+      if (!schedules.delete(id)) return false
+      disarm(id)
+      await persist()
+      return true
+    },
+    dispose() {
+      for (const id of [...timers.keys()]) disarm(id)
+    },
+  }
+}
+
+/**
+ * Scheduled runs: cron exprs or plain intervals ("5m"). interval + current session = /loop.
+ * Persisted, rearmed on startup.
+ */
+export const sched: FeatureModule = {
+  name: "sched",
+  tools: ["schedule_create", "schedule_list", "schedule_delete"],
+  defaultEnabled: true,
+  requires: ["session.promptAsync", "session.messages", "session.create"],
+  async init(ctx, rawOptions, shared) {
+    const options = (rawOptions ?? {}) as SchedOptions
+    await ensureStateDir(ctx.directory)
+    const storePath = scheduleStore.path(ctx.directory)
+
+    const manager = await createScheduleManager({
+      storePath,
+      client: ctx.client,
+      busy: shared.busy,
+      skipIfBusy: options.skipIfBusy !== false,
+    })
 
     return {
-      dispose: async () => {
-        for (const id of [...timers.keys()]) disarm(id)
-      },
+      dispose: async () => manager.dispose(),
       tool: {
         schedule_create: tool({
           description:
@@ -116,31 +181,25 @@ export const sched: FeatureModule = {
             target: z.enum(["current", "new-session"]).default("current"),
           },
           async execute(args, tctx) {
-            parseSpec(args.spec) // validate before storing
-            const s: Schedule = {
-              id: `s-${crypto.randomUUID().slice(0, 6)}`,
+            const { schedule, next } = await manager.create({
               spec: args.spec,
               prompt: args.prompt,
               target: args.target,
               sessionID: tctx.sessionID,
-              createdAt: new Date().toISOString(),
-            }
-            schedules.set(s.id, s)
-            arm(s)
-            await persist()
-            return `created ${s.id}: ${args.spec} -> ${args.target} (next: ${nextRun(s)})`
+            })
+            return `created ${schedule.id}: ${args.spec} -> ${args.target} (next: ${next})`
           },
         }),
         schedule_list: tool({
           description: "List schedules.",
           args: {},
           async execute() {
-            const all = [...schedules.values()]
+            const all = manager.list()
             if (!all.length) return "no schedules"
             return all
               .map(
-                (s) =>
-                  `${s.id} [${s.spec}] -> ${s.target} (next: ${nextRun(s)}) :: ${s.prompt.slice(0, 60)}`,
+                ({ schedule: s, next }) =>
+                  `${s.id} [${s.spec}] -> ${s.target} (next: ${next}) :: ${s.prompt.slice(0, 60)}`,
               )
               .join("\n")
           },
@@ -149,9 +208,8 @@ export const sched: FeatureModule = {
           description: "Delete a schedule by id.",
           args: { id: z.string() },
           async execute(args) {
-            if (!schedules.delete(args.id)) return `no schedule ${args.id}`
-            disarm(args.id)
-            await persist()
+            const ok = await manager.delete(args.id)
+            if (!ok) return `no schedule ${args.id}`
             return `deleted ${args.id}`
           },
         }),

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 { NON_INTERACTIVE_ENV } 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()
@@ -125,6 +138,8 @@ export function createTaskManager(opts: {
   stallCheckIntervalMs?: number
   stallThresholdMs?: number
   stallTailBytes?: number
+  /** spawn a tmux split pane to tail task logs (only if TMUX is active) */
+  tmux?: boolean
 }): TaskManager {
   const tasks = new Map<string, TaskEntry>()
   let counter = 0
@@ -153,6 +168,10 @@ export function createTaskManager(opts: {
     // 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,
+      env: {
+        ...process.env,
+        ...NON_INTERACTIVE_ENV,
+      },
     })
     const entry: TaskEntry = {
       id,
@@ -169,6 +188,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,9 +207,15 @@ 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()
@@ -199,6 +231,7 @@ export function createTaskManager(opts: {
     persistMirror()
     if (entry.stallTimer) clearInterval(entry.stallTimer)
     entry.stallTimer = undefined
+    if (entry.tmuxPane) void entry.tmuxPane.close()
     entry.proc.kill("SIGTERM")
     const hard = setTimeout(() => entry.proc.kill("SIGKILL"), 3000)
     entry.proc.exited.then(() => clearTimeout(hard))
@@ -237,17 +270,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) {
+  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,7 +283,8 @@ export const tasks: FeatureModule = {
 
     const manager = createTaskManager({
       logDir,
-      mirrorPath: `${stateDir}/tasks.json`,
+      mirrorPath: taskStore.path(ctx.directory),
+      tmux: options.tmux === true,
       onExit: async (task) => {
         if (task.status === "killed") return
         const tail = await manager.output(task.id, 20)
@@ -284,7 +311,7 @@ export const tasks: FeatureModule = {
                 task.sessionID,
                 `[background task ${task.id} "${task.description}" appears to be waiting for interactive input]\n` +
                   `last output:\n${tail.trimEnd()}\n\n` +
-                  `The command is likely blocked on a prompt. Kill it with task_kill and re-run non-interactively ` +
+                  `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 +320,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 +337,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,99 @@
+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.
+ */
+export function truncateOutput(
+  content: string,
+  maxChars = DEFAULT_MAX_CHARS,
+  headLinesCount = DEFAULT_HEAD_LINES,
+  tailLinesCount = DEFAULT_TAIL_LINES,
+): TruncateResult {
+  if (content.length <= maxChars) {
+    return { text: content, truncated: false, omittedLines: 0, omittedChars: 0 }
+  }
+
+  const lines = content.split("\n")
+  if (lines.length <= headLinesCount + tailLinesCount) {
+    // If few lines but very long strings, hard slice
+    const head = content.slice(0, Math.floor(maxChars * 0.3))
+    const tail = content.slice(-Math.floor(maxChars * 0.7))
+    const omittedChars = 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,
+    }
+  }
+
+  const head = lines.slice(0, headLinesCount).join("\n")
+  const tail = lines.slice(-tailLinesCount).join("\n")
+  const omittedLines = lines.length - headLinesCount - tailLinesCount
+  const omittedChars = 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
+        }
+      },
+    }
+  },
+}