opencode-overclock 0.3.0 → 0.5.0

package/src/features/guard.ts

@@ -1,10 +1,13 @@
+import { isAbsolute, relative } from "node:path"
 import type { FeatureModule } from "../types.ts"
 import { inject, toast } from "../lib/inject.ts"
+import { execBash, redactSensitiveOutput, sanitizeEnv } from "../lib/exec.ts"
 
 export interface GuardHook {
   name: string
   tools: string[]
   pathFilter?: string
+  glob?: Bun.Glob
   run: string
   mode: "inject" | "append"
   debounceMs: number
@@ -14,6 +17,285 @@ export interface GuardHook {
   maxDeferMs: number
 }
 
+export const EDIT_ERROR_PATTERNS = [
+  "oldstring and newstring must be different",
+  "oldstring not found",
+  "found multiple matches for oldstring",
+]
+
+export const EDIT_RECOVERY_HINT =
+  "\n\n[edit recovery hint]\nThe edit failed due to a content mismatch. Use the `read` tool to inspect the latest file state around the target lines before retrying the edit."
+
+export interface FloorGuardOptions {
+  allowSkips?: boolean
+  allowSuppressions?: boolean
+  allowAssertionRemoval?: boolean
+  [key: string]: unknown
+}
+
+export interface FloorViolationPattern {
+  name: string
+  pattern: RegExp
+  description: string
+  testFileOnly?: boolean
+}
+
+export const FLOOR_VIOLATIONS: FloorViolationPattern[] = [
+  {
+    name: "test-skip-js",
+    pattern:
+      /(?:^|[.\s])(?:skip\s*\(|xit\s*\(|xdescribe\s*\()|\b(?:test\.skip|it\.skip|describe\.skip)\b/,
+    description: "Skipping test execution (.skip / xit / xdescribe)",
+    testFileOnly: true,
+  },
+  {
+    name: "test-skip-python",
+    pattern: /@pytest\.mark\.skip|@unittest\.skip/,
+    description: "Skipping test execution (@pytest.mark.skip / @unittest.skip)",
+    testFileOnly: true,
+  },
+  {
+    name: "test-skip-go",
+    pattern: /\bt\.Skip(?:\(|f\()/,
+    description: "Skipping test execution (t.Skip)",
+    testFileOnly: true,
+  },
+  {
+    name: "test-skip-rust",
+    pattern: /#\[ignore(?:\s*=.*)?\]/,
+    description: "Skipping test execution (#[ignore])",
+    testFileOnly: true,
+  },
+  {
+    name: "ts-suppression",
+    pattern:
+      /\/\/\s*@ts-(?:ignore|nocheck)\b|\/\*\s*@ts-(?:ignore|nocheck)\s*\*\/|\{\s*\/\*\s*@ts-(?:ignore|nocheck)\s*\*\/\s*\}/,
+    description: "TypeScript error suppression (@ts-ignore / @ts-nocheck)",
+  },
+  {
+    name: "eslint-suppression",
+    pattern: /\/\*?\s*eslint-disable(?:-next-line)?\b/,
+    description: "ESLint diagnostic suppression (eslint-disable)",
+  },
+  {
+    name: "python-suppression",
+    pattern: /#\s*(?:noqa|type:\s*ignore)\b/,
+    description: "Python diagnostic suppression (# noqa / # type: ignore)",
+  },
+  {
+    name: "empty-catch",
+    pattern: /catch\s*(?:\([^)]*\))?\s*\{\s*\}/,
+    description: "Empty catch block swallowing errors silently",
+  },
+]
+
+export const ASSERTION_PATTERN =
+  /\b(?:expect\s*\(|assert\b|assert\.[a-zA-Z]+|assertEquals|assertTrue|assertFalse|self\.assert)/
+
+export function isTestFile(filePath: string): boolean {
+  const normalized = filePath.toLowerCase().replaceAll("\\", "/")
+  const segments = normalized.split("/")
+  const filename = segments[segments.length - 1] ?? ""
+
+  return (
+    filename.includes(".test.") ||
+    filename.includes(".spec.") ||
+    segments.includes("test") ||
+    segments.includes("tests") ||
+    segments.includes("__tests__") ||
+    filename.endsWith("_test.go") ||
+    filename.endsWith("_test.py") ||
+    filename.endsWith("_spec.rb") ||
+    filename.startsWith("test_")
+  )
+}
+
+export function checkFloorViolation(
+  tool: string,
+  args: Record<string, unknown> | undefined,
+  options: FloorGuardOptions = {},
+): string | null {
+  const toolLower = tool.toLowerCase()
+  if (toolLower !== "edit" && toolLower !== "write") return null
+  if (!args) return null
+
+  const filePath =
+    typeof args.filePath === "string"
+      ? args.filePath
+      : typeof args.path === "string"
+        ? args.path
+        : typeof args.file_path === "string"
+          ? args.file_path
+          : ""
+
+  const isTest = isTestFile(filePath)
+
+  if (toolLower === "edit") {
+    const oldStr = typeof args.oldString === "string" ? args.oldString : ""
+    const newStr = typeof args.newString === "string" ? args.newString : ""
+
+    for (const v of FLOOR_VIOLATIONS) {
+      if (v.testFileOnly && !isTest) continue
+      if (v.testFileOnly && options.allowSkips) continue
+      if (!v.testFileOnly && options.allowSuppressions) continue
+
+      if (v.pattern.test(newStr) && !v.pattern.test(oldStr)) {
+        return `Detected ${v.description} in ${filePath || "edited file"}. Modifying code to bypass tests or suppress warnings is prohibited by floor-guard policy. Fix the underlying issue instead.`
+      }
+    }
+
+    if (!options.allowAssertionRemoval && isTest) {
+      if (
+        ASSERTION_PATTERN.test(oldStr) &&
+        !ASSERTION_PATTERN.test(newStr) &&
+        newStr.trim().length > 0
+      ) {
+        return `Stripped test assertion(s) from ${filePath || "test file"} without replacement. Deleting assertions to make tests pass is prohibited by floor-guard policy. Fix the implementation to satisfy the assertion.`
+      }
+    }
+  } else if (toolLower === "write") {
+    const content = typeof args.content === "string" ? args.content : ""
+
+    for (const v of FLOOR_VIOLATIONS) {
+      if (v.testFileOnly && !isTest) continue
+      if (v.testFileOnly && options.allowSkips) continue
+      if (!v.testFileOnly && options.allowSuppressions) continue
+
+      if (v.pattern.test(content)) {
+        return `Detected ${v.description} in ${filePath || "written file"}. Introducing test skips or error suppressions is prohibited by floor-guard policy.`
+      }
+    }
+  }
+
+  return null
+}
+
+export function checkEditFailure(tool: string, outputText: string): string | null {
+  if (tool.toLowerCase() !== "edit") return null
+  const lower = outputText.toLowerCase()
+  if (EDIT_ERROR_PATTERNS.some((p) => lower.includes(p))) {
+    return EDIT_RECOVERY_HINT
+  }
+  return null
+}
+
+export const GUARD_RECIPES: Record<string, Omit<GuardHook, "glob">> = {
+  tsc: {
+    name: "tsc",
+    tools: ["edit", "write"],
+    pathFilter: "**/*.{ts,tsx}",
+    run: "bun x tsc --noEmit || npx tsc --noEmit",
+    mode: "inject",
+    debounceMs: 2000,
+    timeoutMs: 60000,
+    onSuccess: "silent",
+    maxDeferMs: 300000,
+  },
+  eslint: {
+    name: "eslint",
+    tools: ["edit", "write"],
+    pathFilter: "**/*.{js,jsx,ts,tsx}",
+    run: "bun x eslint . || npx eslint .",
+    mode: "inject",
+    debounceMs: 2000,
+    timeoutMs: 60000,
+    onSuccess: "silent",
+    maxDeferMs: 300000,
+  },
+  ruff: {
+    name: "ruff",
+    tools: ["edit", "write"],
+    pathFilter: "**/*.py",
+    run: "ruff check .",
+    mode: "inject",
+    debounceMs: 2000,
+    timeoutMs: 60000,
+    onSuccess: "silent",
+    maxDeferMs: 300000,
+  },
+  cargo: {
+    name: "cargo",
+    tools: ["edit", "write"],
+    pathFilter: "**/*.rs",
+    run: "cargo check",
+    mode: "inject",
+    debounceMs: 2000,
+    timeoutMs: 60000,
+    onSuccess: "silent",
+    maxDeferMs: 300000,
+  },
+  go: {
+    name: "go",
+    tools: ["edit", "write"],
+    pathFilter: "**/*.go",
+    run: "go test ./...",
+    mode: "inject",
+    debounceMs: 2000,
+    timeoutMs: 60000,
+    onSuccess: "silent",
+    maxDeferMs: 300000,
+  },
+}
+
+export async function detectRecipes(directory: string): Promise<GuardHook[]> {
+  const detected: GuardHook[] = []
+  if (await Bun.file(`${directory}/tsconfig.json`).exists()) {
+    detected.push({ ...GUARD_RECIPES.tsc, glob: new Bun.Glob("**/*.{ts,tsx}") })
+  }
+  if (await Bun.file(`${directory}/Cargo.toml`).exists()) {
+    detected.push({ ...GUARD_RECIPES.cargo, glob: new Bun.Glob("**/*.rs") })
+  }
+  if (
+    (await Bun.file(`${directory}/pyproject.toml`).exists()) ||
+    (await Bun.file(`${directory}/ruff.toml`).exists())
+  ) {
+    detected.push({ ...GUARD_RECIPES.ruff, glob: new Bun.Glob("**/*.py") })
+  }
+  if (await Bun.file(`${directory}/go.mod`).exists()) {
+    detected.push({ ...GUARD_RECIPES.go, glob: new Bun.Glob("**/*.go") })
+  }
+  return detected
+}
+
+/**
+ * Patterns matching dangerous command idioms that are inappropriate for quality-gate hooks,
+ * such as reverse shells, remote script piping, and arbitrary socket relays.
+ */
+export const DANGEROUS_COMMAND_PATTERNS: { pattern: RegExp; reason: string }[] = [
+  { pattern: /\/dev\/(?:tcp|udp)\//i, reason: "network socket redirection (/dev/tcp or /dev/udp)" },
+  { pattern: /\bmkfifo\b/i, reason: "named pipe creation (mkfifo)" },
+  {
+    pattern: /\b(?:nc|netcat)\b.*(?:\s+-e\s+|\s+-c\s+)/i,
+    reason: "netcat remote command execution flag (-e/-c)",
+  },
+  {
+    pattern: /\b(?:curl|wget|fetch)\b.*\|\s*(?:bash|sh|zsh|python|perl|ruby)\b/i,
+    reason: "remote script execution via pipe (curl/wget | shell)",
+  },
+  {
+    pattern: /\bbase64\s+(?:-d|--decode)\b.*\|\s*(?:bash|sh|zsh)\b/i,
+    reason: "encoded payload execution via pipe (base64 -d | shell)",
+  },
+  { pattern: /\bbash\s+-i\b.*>&/i, reason: "interactive reverse shell redirection (bash -i >&)" },
+  { pattern: /\bsocat\s+/i, reason: "socket relay execution (socat)" },
+]
+
+/**
+ * Validates a hook command string against dangerous patterns.
+ * Returns the rejection reason or null if valid.
+ */
+export function validateHookCommand(command: string): string | null {
+  for (const { pattern, reason } of DANGEROUS_COMMAND_PATTERNS) {
+    if (pattern.test(command)) {
+      return reason
+    }
+  }
+  return null
+}
+
+/** Maximum character length of failure payload tail to prevent prompt flooding. */
+export const MAX_FAILURE_PAYLOAD_CHARS = 4000
+
 /** options.hooks -> validated GuardHook[]. Invalid entries -> console.warn, skipped, never throw. */
 export function parseHooks(raw: unknown): GuardHook[] {
   if (!Array.isArray(raw)) return []
@@ -26,38 +308,78 @@ export function parseHooks(raw: unknown): GuardHook[] {
       console.warn(`[overclock] guard: skipping invalid hook config: ${JSON.stringify(entry)}`)
       continue
     }
+
+    const danger = validateHookCommand(e.run)
+    if (danger) {
+      console.warn(`[overclock] guard: rejecting unsafe hook "${e.name}": ${danger}`)
+      continue
+    }
+
+    const pathFilter = typeof e.pathFilter === "string" ? e.pathFilter : undefined
+    if (pathFilter && pathFilter.includes("..")) {
+      console.warn(`[overclock] guard: rejecting hook "${e.name}": pathFilter cannot contain ".."`)
+      continue
+    }
+
     hooks.push({
       name: e.name,
       tools: e.tools as string[],
-      pathFilter: typeof e.pathFilter === "string" ? e.pathFilter : undefined,
+      pathFilter,
+      glob: pathFilter ? new Bun.Glob(pathFilter) : undefined,
       run: e.run,
       mode: e.mode === "append" ? "append" : "inject",
-      debounceMs: typeof e.debounceMs === "number" ? e.debounceMs : 2000,
-      timeoutMs: typeof e.timeoutMs === "number" ? e.timeoutMs : 60000,
+      debounceMs: typeof e.debounceMs === "number" ? Math.max(50, Math.min(e.debounceMs, 60000)) : 2000,
+      timeoutMs: typeof e.timeoutMs === "number" ? Math.max(100, Math.min(e.timeoutMs, 300000)) : 60000,
       onSuccess: e.onSuccess === "notify" ? "notify" : "silent",
-      maxDeferMs: typeof e.maxDeferMs === "number" ? e.maxDeferMs : 300000,
+      maxDeferMs:
+        typeof e.maxDeferMs === "number" ? Math.max(1000, Math.min(e.maxDeferMs, 600000)) : 300000,
     })
   }
   return hooks
 }
 
-/** tools: exact match. pathFilter set + no filePath -> no match. */
-export function matchHook(hook: GuardHook, toolName: string, filePath: string | undefined): boolean {
-  if (!hook.tools.includes(toolName)) return false
+/** tools: exact match or mapped name. pathFilter set + no filePath -> no match. */
+export function matchHook(
+  hook: GuardHook,
+  toolName: string,
+  filePath: string | undefined,
+  resolveTool?: (name: string) => string,
+  cwd?: string,
+): boolean {
+  const matches = hook.tools.some((t) => {
+    if (t === toolName) return true
+    if (resolveTool && resolveTool(t) === toolName) return true
+    return false
+  })
+  if (!matches) return false
   if (!hook.pathFilter) return true
   if (typeof filePath !== "string") return false
-  return new Bun.Glob(hook.pathFilter).match(filePath)
+
+  const glob = hook.glob ?? new Bun.Glob(hook.pathFilter)
+  const normalized = filePath.replaceAll("\\", "/")
+  if (glob.match(normalized)) return true
+
+  if (cwd && isAbsolute(normalized)) {
+    const rel = relative(cwd, normalized).replaceAll("\\", "/")
+    if (glob.match(rel)) return true
+  }
+
+  return false
 }
 
-/** `[guard "<name>" failed (exit <code>)]` + last 40 lines of combined stdout+stderr. */
+/** `[guard "<name>" failed (exit <code>)]` + sanitized last 40 lines of combined stdout+stderr. */
 export function failurePayload(name: string, code: number | null, combined: string): string {
-  const tail = combined.split("\n").slice(-40).join("\n")
+  const sanitized = redactSensitiveOutput(combined)
+  let tail = sanitized.split("\n").slice(-40).join("\n")
+  if (tail.length > MAX_FAILURE_PAYLOAD_CHARS) {
+    tail = tail.slice(-MAX_FAILURE_PAYLOAD_CHARS) + "\n... [truncated for security & length]"
+  }
   return `\n\n[guard "${name}" failed (exit ${code})]\n${tail}`
 }
 
 function buildEnv(toolName: string, filePath: string | undefined): Record<string, string | undefined> {
   return {
-    ...process.env,
+    ...sanitizeEnv(process.env),
     GUARD_TOOL: toolName,
     ...(filePath !== undefined ? { GUARD_FILE: filePath } : {}),
   }
@@ -69,16 +391,13 @@ async function runCommand(
   env: Record<string, string | undefined>,
   register?: (proc: Bun.Subprocess) => void,
 ): Promise<{ code: number | null; combined: string }> {
-  const proc = Bun.spawn(["bash", "-c", hook.run], { cwd, env, stdout: "pipe", stderr: "pipe" })
-  register?.(proc)
-  const killTimer = setTimeout(() => proc.kill("SIGTERM"), hook.timeoutMs)
-  const [out, err, code] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited,
-  ])
-  clearTimeout(killTimer)
-  return { code, combined: out + err }
+  return execBash(hook.run, {
+    cwd,
+    env,
+    timeoutMs: hook.timeoutMs,
+    onSpawn: register,
+    sanitizeEnv: true,
+  })
 }
 
 interface HookState {
@@ -200,7 +519,17 @@ export function createGuardRunner(deps: GuardRunnerDeps): GuardRunner {
   function dispose(): void {
     for (const s of states.values()) {
       if (s.timer) clearTimeout(s.timer)
-      for (const p of s.procs) p.kill("SIGTERM")
+      for (const p of s.procs) {
+        try {
+          p.kill("SIGTERM")
+          const hard = setTimeout(() => {
+            try {
+              p.kill("SIGKILL")
+            } catch {}
+          }, 1000)
+          hard.unref?.()
+        } catch {}
+      }
     }
   }
 
@@ -218,7 +547,6 @@ export function createGuardRunner(deps: GuardRunnerDeps): GuardRunner {
 export const guard: FeatureModule = {
   name: "guard",
   tools: [],
-  options: { hooks: "array" },
   defaultEnabled: true,
   requires: ["session.promptAsync", "session.messages"],
   async init(ctx, options, shared) {
@@ -226,29 +554,85 @@ export const guard: FeatureModule = {
       console.warn(`[overclock] guard: options.hooks must be an array, got ${typeof options.hooks}`)
     }
     const hooks = parseHooks(options.hooks)
-    if (hooks.length === 0) return {}
+    if (Array.isArray(options.recipes)) {
+      for (const r of options.recipes) {
+        if (typeof r === "string" && GUARD_RECIPES[r]) {
+          const recipe = GUARD_RECIPES[r]
+          hooks.push({
+            ...recipe,
+            glob: recipe.pathFilter ? new Bun.Glob(recipe.pathFilter) : undefined,
+          })
+        }
+      }
+    }
+    if (options.auto === true) {
+      const autoHooks = await detectRecipes(ctx.directory)
+      hooks.push(...autoHooks)
+    }
 
-    const runner = createGuardRunner({
-      cwd: ctx.directory,
-      onInject: async (sessionID, payload) => {
-        await inject(ctx.client, sessionID, payload)
-      },
-      onNotify: async (hookName) => {
-        await toast(ctx.client, `guard "${hookName}" passed`, "success")
-      },
-      isBusy: (sessionID) => shared.busy.isBusy(sessionID),
-    })
+    const floorGuardEnabled =
+      options.floorGuard === true ||
+      options.auto === true ||
+      (typeof options.floorGuard === "object" && options.floorGuard !== null)
+    const floorGuardOpts: FloorGuardOptions =
+      typeof options.floorGuard === "object" && options.floorGuard !== null
+        ? (options.floorGuard as FloorGuardOptions)
+        : {}
+
+    const editRecovery =
+      options.editRecovery === true || (hooks.length > 0 && options.editRecovery !== false)
+    if (hooks.length === 0 && !editRecovery && !floorGuardEnabled) return {}
+
+    const runner =
+      hooks.length > 0
+        ? createGuardRunner({
+            cwd: ctx.directory,
+            onInject: async (sessionID, payload) => {
+              await inject(ctx.client, sessionID, payload)
+            },
+            onNotify: async (hookName) => {
+              await toast(ctx.client, `guard "${hookName}" passed`, "success")
+            },
+            isBusy: (sessionID) => shared.busy.isBusy(sessionID),
+          })
+        : undefined
 
     return {
       dispose: async () => {
-        runner.dispose()
+        runner?.dispose()
       },
       "tool.execute.after": async (input, output) => {
+        if (editRecovery && typeof output.output === "string") {
+          const hint = checkEditFailure(input.tool, output.output)
+          if (hint) output.output += hint
+        }
+
+        if (floorGuardEnabled && typeof output.output === "string") {
+          const violation = checkFloorViolation(
+            input.tool,
+            input.args as Record<string, unknown> | undefined,
+            floorGuardOpts,
+          )
+          if (violation) {
+            output.output += `\n\n[overclock floor-guard warning]\n${violation}`
+            void toast(ctx.client, "guard: floor-guard violation detected", "warning")
+          }
+        }
+
+        if (!runner || hooks.length === 0) return
+
         const args = input.args as Record<string, unknown> | undefined
-        const filePath = typeof args?.filePath === "string" ? args.filePath : undefined
+        const filePath =
+          typeof args?.filePath === "string"
+            ? args.filePath
+            : typeof args?.path === "string"
+              ? args.path
+              : typeof args?.file_path === "string"
+                ? args.file_path
+                : undefined
 
         for (const hook of hooks) {
-          if (!matchHook(hook, input.tool, filePath)) continue
+          if (!matchHook(hook, input.tool, filePath, shared?.toolName, ctx.directory)) continue
           if (hook.mode === "append") {
             const payload = await runner.runAppend(hook, input.tool, filePath)
             if (payload && typeof output.output === "string") output.output += payload

package/src/features/index.ts

@@ -1,11 +1,25 @@
 import type { FeatureModule } from "../types.ts"
+import { safety } from "./safety.ts"
+import { workflow } from "./workflow.ts"
 import { tasks } from "./tasks.ts"
 import { sched } from "./sched.ts"
-import { sandbox } from "./sandbox.ts"
 import { guard } from "./guard.ts"
 import { usage } from "./usage.ts"
-import { checkpoints } from "./checkpoints.ts"
 import { buddy } from "./buddy.ts"
+import { truncator } from "./truncator.ts"
+import { recovery } from "./recovery.ts"
 
-/** Registry, ordered. Order = hook composition order. */
-export const features: FeatureModule[] = [tasks, sched, sandbox, guard, usage, checkpoints, buddy]
+/**
+ * Registry, ordered. Order = hook composition order.
+ */
+export const features: FeatureModule[] = [
+  safety,
+  workflow,
+  tasks,
+  sched,
+  guard,
+  usage,
+  buddy,
+  truncator,
+  recovery,
+]