pantheon-opencode 1.2.1 → 1.2.2

package/scripts/version-check.mjs

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+/**
+ * version-check.mjs — Single source of truth enforcement
+ *
+ * package.json is the SOURCE OF TRUTH for the Pantheon version.
+ * Every other manifest (pyproject.toml, plugin.json, src/plugins/tui/package.json)
+ * MUST carry the same version. This script:
+ *
+ *   - compares every manifest against package.json and prints a divergence
+ *     table when they differ (exit code 1),
+ *   - with --fix, rewrites each divergent manifest to the package.json version.
+ *
+ * Mirrors the MANIFEST_FILES list in scripts/versioning.mjs so `apply`
+ * and `check` can never drift apart.
+ *
+ * Usage:
+ *   node scripts/version-check.mjs          # verify (exit 0 = in sync)
+ *   node scripts/version-check.mjs --fix    # sync all manifests
+ */
+
+import { readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+/** Same set of manifests as versioning.mjs (minus package.json itself). */
+export const MANIFESTS = [
+  { name: 'pyproject.toml', file: 'pyproject.toml', kind: 'toml' },
+  { name: 'plugin.json', file: 'plugin.json', kind: 'json' },
+  { name: 'src/plugins/tui/package.json', file: join('src', 'plugins', 'tui', 'package.json'), kind: 'json' },
+]
+
+function readTomlVersion(filePath) {
+  const text = readFileSync(filePath, 'utf-8')
+  const match = text.match(/^version\s*=\s*"([^"]+)"/m)
+  if (!match) throw new Error(`no version field in ${filePath}`)
+  return match[1]
+}
+
+function readJsonVersion(filePath) {
+  return JSON.parse(readFileSync(filePath, 'utf-8')).version
+}
+
+function readManifestVersion(filePath, kind) {
+  try {
+    return kind === 'toml' ? readTomlVersion(filePath) : readJsonVersion(filePath)
+  } catch {
+    return null
+  }
+}
+
+function writeManifestVersion(filePath, kind, version) {
+  if (kind === 'toml') {
+    const text = readFileSync(filePath, 'utf-8')
+    const updated = text.replace(/^(version\s*=\s*")[^"]+(")/m, `$1${version}$2`)
+    writeFileSync(filePath, updated)
+  } else {
+    const content = JSON.parse(readFileSync(filePath, 'utf-8'))
+    content.version = version
+    writeFileSync(filePath, `${JSON.stringify(content, null, 2)}\n`)
+  }
+}
+
+/**
+ * Compare every manifest version against package.json (source of truth).
+ *
+ * @param {string} root - repository root containing package.json + manifests
+ * @returns {{source: string, manifests: Array<{name: string, version: string|null, ok: boolean}>, ok: boolean}}
+ *   - source: version read from package.json
+ *   - manifests: per-manifest {name, version (null when unreadable), ok}
+ *   - ok: true when every manifest matches the source version
+ */
+export function compareVersions(root) {
+  const source = JSON.parse(readFileSync(join(root, 'package.json'), 'utf-8')).version
+  const manifests = MANIFESTS.map(({ name, file, kind }) => {
+    const version = readManifestVersion(join(root, file), kind)
+    return { name, version, ok: version === source }
+  })
+  return { source, manifests, ok: manifests.every((m) => m.ok) }
+}
+
+/**
+ * Rewrite every divergent manifest to the package.json version.
+ *
+ * @param {string} root - repository root
+ * @returns {number} count of manifests rewritten
+ */
+export function syncToSource(root) {
+  const { source, manifests } = compareVersions(root)
+  let changed = 0
+  for (const manifest of manifests) {
+    if (manifest.ok) continue
+    const def = MANIFESTS.find((m) => m.name === manifest.name)
+    writeManifestVersion(join(root, def.file), def.kind, source)
+    changed += 1
+  }
+  return changed
+}
+
+function printDivergenceTable(result) {
+  const rows = [
+    ['manifest', 'version', 'status'],
+    ...result.manifests.map((m) => [m.name, m.version ?? 'MISSING', m.ok ? 'ok' : 'DIVERGENT']),
+  ]
+  const widths = rows[0].map((_, i) => Math.max(...rows.map((row) => row[i].length)))
+  console.log(`Source of truth: package.json → v${result.source}\n`)
+  for (const row of rows) {
+    console.log(row.map((cell, i) => cell.padEnd(widths[i])).join('  '))
+  }
+  console.log('')
+}
+
+const isDirectRun =
+  process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href
+
+if (isDirectRun) {
+  // npm scripts run from the package root, so the working directory is the
+  // repository root to check. Explicit cwd keeps the CLI testable.
+  const root = process.cwd()
+  const fix = process.argv.includes('--fix')
+  let result
+  try {
+    result = compareVersions(root)
+  } catch (error) {
+    console.error(`version-check: cannot read package.json — ${error.message}`)
+    process.exit(1)
+  }
+
+  if (result.ok) {
+    console.log(`✓ All manifests match package.json v${result.source}`)
+    process.exit(0)
+  }
+
+  printDivergenceTable(result)
+  if (fix) {
+    const changed = syncToSource(root)
+    const after = compareVersions(root)
+    if (after.ok) {
+      console.log(`✓ Synced ${changed} manifest(s) to v${after.source}`)
+      process.exit(0)
+    }
+    console.error(`version-check: sync incomplete — ${after.manifests.filter((m) => !m.ok).length} manifest(s) still divergent`)
+    process.exit(1)
+  }
+  console.error('version-check: manifests out of sync (run with --fix to sync)')
+  process.exit(1)
+}

package/scripts/versioning.mjs

@@ -29,7 +29,7 @@ const MANIFEST_FILES = [
   'pyproject.toml',
   'package.json',
   'plugin.json',
-  '.github/plugin/plugin.json',
+  'src/plugins/tui/package.json',
 ]
 
 const CHANGELOG_PATH = join(ROOT, 'CHANGELOG.md')
@@ -47,8 +47,11 @@ function run(cmd) {
 }
 
 function getLatestTag() {
-  // Use numerically highest tag, not just nearest git ancestor
-  const tag = run("git tag -l 'v[0-9]*.[0-9]*.[0-9]*' | sort -V | tail -1")
+  // Stable tags only: strict vX.Y.Z with NO pre-release suffix.
+  // The loose glob `v[0-9]*.[0-9]*.[0-9]*` ALSO matches v1.2.0-beta.9.*
+  // (the trailing `*` swallows the -beta suffix), which would poison the
+  // version gate — so filter strictly before sorting.
+  const tag = run("git tag -l 'v*' | grep -E '^v[0-9]+\\.[0-9]+\\.[0-9]+$' | sort -V | tail -1")
   return tag || 'v0.0.0'
 }
 
@@ -207,13 +210,15 @@ switch (command) {
     const latestVer = latestTag.replace(/^v/, '')
 
     // If package.json is already ahead of the latest tag, someone bumped
-    // without tagging — warn and use the current version as-is.
+    // without tagging — warn and use the current version as-is. Tags are
+    // workflow-owned, so there is nothing to create here.
     if (current !== latestVer) {
       console.log(`⚠ package.json (${current}) already ahead of latest tag (${latestTag}).`)
       console.log(`  Syncing all manifests to ${current} and promoting CHANGELOG.`)
       updateManifests(current)
       const date = new Date().toISOString().slice(0, 10)
       promoteUnreleased(current, date)
+      console.log(`Tag v${current} will be created by the release workflow after merge to main.`)
       break
     }
 
@@ -226,16 +231,10 @@ switch (command) {
     promoteUnreleased(newVersion, date)
     console.log(`\nDone. Commit with: git add -A && git commit -m "chore(release): v${newVersion}"`)
 
-    // Create git tag
-    try {
-      const tag = `v${newVersion}`
-      execSync(`git tag -a ${tag} -m "chore(release): ${tag}"`, { stdio: 'inherit' })
-      console.log(`Tag ${tag} created locally. Push: git push origin ${tag}`)
-      console.log(`Auto-release will trigger on main after merge.`)
-    } catch (e) {
-      console.warn(`Tag creation failed: ${e.message}`)
-      console.log('Create manually: git tag -a v' + newVersion + ' -m "chore(release): v' + newVersion + '"')
-    }
+    // Tags are owned by the release workflow — never create them locally.
+    // A local tag on a pre-merge commit drifts from the merged main state
+    // (the untagged-v1.2.1 root cause) and would desync the version gate.
+    console.log(`Tag v${newVersion} will be created by the release workflow after merge to main.`)
     break
   }
 

package/src/mcp/requirements-mcp.txt

@@ -1,5 +1,8 @@
-mcp>=1.28.0
-fastmcp>=3.4.0
-pyyaml>=6.0
-sqlite-vec>=0.1.7
-fastembed>=0.5.0
+# Pantheon MCP runtime dependencies — EXACT pins (issue #21)
+# Pinned to the versions validated in the sandbox venv (2026-08-05).
+# Update deliberately via: pip install -U <pkg> && pip freeze | grep -iE '^(mcp|fastmcp|pyyaml|sqlite-vec|fastembed)'
+mcp==1.29.0
+fastmcp==3.4.6
+pyyaml==6.0.3
+sqlite-vec==0.1.9
+fastembed==0.8.0

package/src/mcp/requirements-vision.txt

@@ -1,3 +1,3 @@
-mcp>=1.28.0
-fastmcp>=3.4.0
-httpx>=0.27.0
+mcp==1.29.0
+fastmcp==3.4.6
+httpx==0.28.1

package/src/plugins/hook-runner.ts

@@ -0,0 +1,186 @@
+/**
+ * hook-runner.ts — version-proof runner for the Pantheon security-hook layer.
+ *
+ * The previous plugin used the Bun Shell `$` injected by the opencode plugin
+ * API (`$.quiet().nothrow().timeout(...)`). `.timeout()` does not exist on the
+ * BunShell interface, so every hook crashed with a TypeError and the layer was
+ * removed (24-25/07). This runner uses ONLY `node:child_process` — stable
+ * across every Node >= 18 runtime and every opencode plugin loader version.
+ *
+ * Claude Code stdin protocol: the hook scripts receive
+ * `{tool_name, tool_input, agent_id, session_id}` as JSON on stdin. Scripts
+ * that read env vars instead (log-session-start.sh, on-subagent-delegation-*)
+ * get their fields mapped into the child env (SESSION_ID / AGENT_NAME /
+ * TASK_DESC) so both protocols work end to end.
+ *
+ * IMPORTANT (verified empirically): the `input:` option on the async
+ * `execFile()` API is silently ignored by Node — it only exists on
+ * spawnSync/execFileSync. This runner therefore writes stdin explicitly to a
+ * spawned child, which delivers the payload reliably.
+ *
+ * Hooks NEVER throw: every failure (missing script, timeout, non-zero exit)
+ * is returned as a structured HookResult so the opencode session can never be
+ * taken down by the security layer.
+ */
+import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process'
+import path from 'node:path'
+import type { Readable } from 'node:stream'
+import { fileURLToPath } from 'node:url'
+
+export const HOOK_TIMEOUT_MS = 15_000
+export const HOOK_MAX_BUFFER = 10 * 1024 * 1024
+
+/** Claude Code hook protocol payload. */
+export type HookPayload = {
+  tool_name?: string
+  tool_input?: unknown
+  agent_id?: string
+  session_id?: string
+}
+
+export type HookResult = {
+  code: number
+  stdout: string
+  stderr: string
+  signal: NodeJS.Signals | null
+  timedOut: boolean
+}
+
+export type RunHookOptions = {
+  env?: Record<string, string | undefined>
+  cwd?: string
+  timeout?: number
+}
+
+/**
+ * Resolve the hooks directory relative to this module — robust to any npm
+ * global-install prefix because it anchors on import.meta.url, not __dirname
+ * or process.cwd().
+ */
+export function resolveHooksDir(): string {
+  return fileURLToPath(new URL('../../scripts/hooks/', import.meta.url))
+}
+
+/**
+ * Map the Claude Code protocol payload into the child environment. Scripts
+ * that read env vars (log-session-start.sh, delegation audit scripts) rely on
+ * these; scripts that read stdin receive the full JSON via `input` in runHook.
+ * PATH is always preserved so `python3`/`bash` resolution inside the scripts
+ * is never affected by a stripped-down environment.
+ */
+export function hookEnv(
+  payload: HookPayload,
+  extra?: Record<string, string | undefined>,
+): NodeJS.ProcessEnv {
+  return {
+    ...process.env,
+    PATH: process.env.PATH ?? '',
+    SESSION_ID: payload.session_id ?? '',
+    AGENT_NAME: payload.agent_id ?? '',
+    TASK_DESC: payload.tool_name ?? '',
+    ...(extra ?? {}),
+  }
+}
+
+/**
+ * Run one hook script with the Claude Code protocol payload on stdin.
+ *
+ * @param script  file name inside scripts/hooks/ (e.g. "validate-tool-safety.sh")
+ * @param payload protocol payload translated from the opencode hook event
+ * @param opts    optional env overrides / cwd / timeout
+ * @returns      HookResult — NEVER throws; resolve with a non-zero code instead
+ */
+export function runHook(
+  script: string,
+  payload: HookPayload,
+  opts: RunHookOptions = {},
+): Promise<HookResult> {
+  const scriptPath = path.join(opts.cwd ?? resolveHooksDir(), script)
+  const timeout = opts.timeout ?? HOOK_TIMEOUT_MS
+
+  return new Promise<HookResult>((resolve) => {
+    const stdoutBuf: { value: string } = { value: '' }
+    const stderrBuf: { value: string } = { value: '' }
+    let settled = false
+
+    const settle = (result: HookResult) => {
+      if (!settled) {
+        settled = true
+        resolve(result)
+      }
+    }
+
+    const spawnOpts = {
+      timeout,
+      killSignal: 'SIGKILL' as const,
+      env: hookEnv(payload, opts.env),
+      // stdio:'pipe' is equivalent to ['pipe','pipe','pipe'] — it guarantees
+      // the child's stdin is OUR pipe, NEVER the opencode TUI's terminal
+      // (which would leave `cat`-style hooks blocked reading forever and hit
+      // the opencode core hook timeout).
+      stdio: 'pipe' as const,
+      windowsHide: true,
+      ...(opts.cwd !== undefined ? { cwd: opts.cwd } : {}),
+    }
+
+    // stdio:'pipe' picks the ChildProcessWithoutNullStreams overload — do not
+    // widen these option literals or child.stdin/stdout become nullable.
+    let child: ChildProcessWithoutNullStreams
+    try {
+      child = spawn(scriptPath, [], spawnOpts)
+    } catch (err) {
+      // Synchronous spawn failure (invalid args etc.) — never propagate.
+      settle({
+        code: 1,
+        stdout: '',
+        stderr: `spawn failed: ${err instanceof Error ? err.message : String(err)}`,
+        signal: null,
+        timedOut: false,
+      })
+      return
+    }
+
+    // The child may exit before we write stdin — swallow EPIPE instead of
+    // crashing the plugin process with an unhandled stream error.
+    child.stdin.on('error', () => {})
+
+    const collect = (stream: Readable, buf: { value: string }) => {
+      stream.setEncoding('utf-8')
+      stream.on('data', (chunk: string) => {
+        if (buf.value.length < HOOK_MAX_BUFFER) {
+          buf.value += chunk.slice(0, HOOK_MAX_BUFFER - buf.value.length)
+        }
+      })
+    }
+    collect(child.stdout, stdoutBuf)
+    collect(child.stderr, stderrBuf)
+
+    child.on('error', (err: NodeJS.ErrnoException) => {
+      // ENOENT / EACCES — script missing or not executable. Report, never throw.
+      settle({
+        code: 1,
+        stdout: stdoutBuf.value,
+        stderr: stderrBuf.value || `hook script failed to spawn: ${err.message}`,
+        signal: null,
+        timedOut: false,
+      })
+    })
+
+    child.on('close', (code, signal) => {
+      settle({
+        code: code ?? 1,
+        stdout: stdoutBuf.value,
+        stderr: stderrBuf.value,
+        signal,
+        timedOut: code === null && signal === 'SIGKILL',
+      })
+    })
+
+    // Deliver the Claude Code protocol JSON on stdin. stdin.end() runs
+    // UNCONDITIONALLY — even for an empty payload {} or a script that never
+    // reads stdin — so the child can never block waiting for input and hit
+    // the runtime hook timeout (reported as "Hook X timed out after 30000ms").
+    child.stdin.write(JSON.stringify(payload))
+    child.stdin.end()
+  })
+}

package/src/plugins/pantheon-hooks.ts

@@ -0,0 +1,153 @@
+/**
+ * pantheon-hooks.ts — Pantheon runtime security-hook plugin for OpenCode.
+ *
+ * Re-created per Council Synthesis 2026-08-05 (P0): the previous hook plugin
+ * was removed on 24-25/07 because it used the Bun Shell `$` from the plugin
+ * API, whose interface has NO `.timeout()` method — every hook crashed with
+ * `TypeError: $.quiet().nothrow().timeout is not a function`. The 10 functional
+ * scripts in scripts/hooks/ (gitleaks covers only staged files, NOT tool
+ * calls) were left orphaned. This plugin wires them back into the opencode
+ * runtime via `node:child_process` (version-proof — see hook-runner.ts).
+ *
+ * Hook mapping (Claude Code protocol payload {tool_name, tool_input,
+ * agent_id, session_id} delivered on the script stdin):
+ *   - tool.execute.before → validate-talos-scope.sh, scan-secrets.sh,
+ *     validate-tool-safety.sh + on-subagent-delegation-start.sh (only when the
+ *     tool is a delegation tool such as `task`, to keep the audit log honest)
+ *   - tool.execute.after  → format-multi-language.sh, log-session-start.sh +
+ *     on-subagent-delegation-stop.sh (delegation tool only)
+ *   - event session.created → log-session-start.sh, validate-post-conditions.sh
+ *
+ * Notes:
+ *   - `agent_id` is NOT present in the opencode tool.execute hook payloads
+ *     ({tool, sessionID, callID}), so it is passed as '' — validate-talos-scope
+ *     then takes its safe skip path; the agent-agnostic scan-secrets and
+ *     validate-tool-safety protections remain fully active.
+ *   - tool.execute hooks cannot hard-deny the tool call through this API
+ *     (the output only mutates args; real deny is the permission system), so
+ *     violations surface as stderr + non-zero exit codes logged below.
+ *   - Logging policy: non-zero exit → console.error (the security signal);
+ *     zero exit → SILENT by default. Audit scripts (log-session-start,
+ *     on-subagent-delegation-*) still write their log FILES (sessions.log,
+ *     delegations.log) from inside the .sh scripts — only the console echo is
+ *     suppressed so the chat/TUI stays clean. Set PANTHEON_HOOKS_LOG=1 (or
+ *     "debug") to re-enable the zero-exit console echo for debugging.
+ *     The env var is read once at plugin load time (opencode startup).
+ *   - Hooks NEVER throw: every body is try/catch'd and only logs.
+ *
+ * IMPORTANT (OpenCode 1.18.11 legacy loader): this module must export EXACTLY
+ * ONE function-valued export — the default plugin (see src/plugin.ts L47-52).
+ * Helpers live in ./hook-runner.ts and are imported from there.
+ */
+import type { Plugin } from '@opencode-ai/plugin'
+import { runHook, type HookPayload } from './hook-runner.ts'
+
+/** Tools that represent a subagent delegation (opencode `task` tool etc.). */
+const DELEGATION_TOOL_RE = /^(task|.*delegate.*|.*subagent.*)$/i
+
+/**
+ * When set to a truthy value ("1" or "debug"), zero-exit audit-hook output is
+ * echoed to the console (opt-in debugging). Default (unset): fully silent on
+ * success — the .sh scripts still persist their log FILES on disk; only the
+ * console echo is suppressed. Read at plugin load time.
+ */
+const AUDIT_LOG_ENABLED = (process.env.PANTHEON_HOOKS_LOG ?? '').trim() !== ''
+
+/** Scripts whose zero-exit stderr is relayed when PANTHEON_HOOKS_LOG is set. */
+const AUDIT_HOOKS = new Set([
+  'log-session-start.sh',
+  'on-subagent-delegation-start.sh',
+  'on-subagent-delegation-stop.sh',
+  'validate-post-conditions.sh',
+])
+
+function trim(s: string, max = 2000): string {
+  const t = s.trim()
+  return t.length > max ? `${t.slice(0, max)}…` : t
+}
+
+/** Translate the opencode hook event into the Claude Code protocol payload. */
+function payloadFor(
+  input: { tool: string; sessionID: string },
+  toolInput: unknown,
+): HookPayload {
+  return {
+    tool_name: input.tool,
+    tool_input: toolInput ?? {},
+    // tool.execute hooks carry no agent — '' lets talos-scope skip safely.
+    agent_id: (input as { agent?: { id?: string } }).agent?.id ?? '',
+    session_id: input.sessionID,
+  }
+}
+
+/** Run one hook with the logging policy; NEVER throw out of the hook. */
+async function safeRun(script: string, payload: HookPayload): Promise<void> {
+  try {
+    const result = await runHook(script, payload)
+    const tag = `[pantheon-hooks:${script}]`
+    if (result.code !== 0) {
+      console.error(
+        `${tag} exit ${result.code}${result.timedOut ? ' (timed out)' : ''}: ${trim(result.stderr || result.stdout || 'no output')}`,
+      )
+    } else if (AUDIT_LOG_ENABLED && AUDIT_HOOKS.has(script) && result.stderr.trim()) {
+      // Opt-in only (PANTHEON_HOOKS_LOG=1): audit scripts echo their FILE
+      // writes here for debugging. Default is silence — the .sh scripts
+      // already persist sessions.log / delegations.log on disk.
+      console.log(`${tag} ${trim(result.stderr)}`)
+    }
+  } catch (err) {
+    // runHook never throws, but the hook body must survive anything.
+    console.error(
+      `[pantheon-hooks:${script}] unexpected failure: ${err instanceof Error ? err.message : String(err)}`,
+    )
+  }
+}
+
+const plugin: Plugin = async () => {
+  return {
+    'tool.execute.before': async (input, output) => {
+      try {
+        const payload = payloadFor(input, output.args ?? {})
+        const hooks = [
+          'validate-talos-scope.sh',
+          'scan-secrets.sh',
+          'validate-tool-safety.sh',
+        ]
+        if (DELEGATION_TOOL_RE.test(input.tool)) {
+          hooks.push('on-subagent-delegation-start.sh')
+        }
+        await Promise.all(hooks.map((script) => safeRun(script, payload)))
+      } catch {
+        // Never let a hook take down the opencode session.
+      }
+    },
+    'tool.execute.after': async (input) => {
+      try {
+        const payload = payloadFor(input, input.args ?? {})
+        const hooks = ['format-multi-language.sh']
+        if (DELEGATION_TOOL_RE.test(input.tool)) {
+          hooks.push('on-subagent-delegation-stop.sh')
+        }
+        await Promise.all(hooks.map((script) => safeRun(script, payload)))
+      } catch {
+        // Never let a hook take down the opencode session.
+      }
+    },
+    event: async ({ event: ev }) => {
+      try {
+        if (ev.type === 'session.created') {
+          const payload: HookPayload = { session_id: ev.properties.info.id }
+          await Promise.all(
+            ['log-session-start.sh', 'validate-post-conditions.sh'].map((script) =>
+              safeRun(script, payload),
+            ),
+          )
+        }
+      } catch {
+        // Never let a hook take down the opencode session.
+      }
+    },
+  }
+}
+
+export default plugin

package/src/plugins/tui/dist/tui.d.ts

@@ -0,0 +1,8 @@
+import { TuiPluginModule } from "@opencode-ai/plugin/tui";
+//#region src/index.d.ts
+declare const plugin: TuiPluginModule & {
+  id: string;
+};
+//#endregion
+export { plugin as default };
+//# sourceMappingURL=tui.d.ts.map

package/src/plugins/tui/dist/tui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui.d.ts","names":[],"sources":["../src/index.tsx"],"mappings":";;cA8qCM,QAAQ;EAAoB"}