pantheon-opencode 1.2.0 → 1.2.2

package/scripts/hooks/run-type-check.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# run-type-check.sh — Pantheon PostToolUse Type Check Hook
+# Runs mypy (Python) or tsc (TypeScript) if config exists.
+set -euo pipefail
+
+# Only run if relevant config files exist
+if [[ -f "pyproject.toml" ]] || [[ -f "setup.cfg" ]] || [[ -f ".mypy.ini" ]]; then
+    if command -v mypy >/dev/null 2>&1; then
+        echo "[TYPE CHECK] Running mypy..." >&2
+        mypy . --ignore-missing-imports || true
+    fi
+fi
+
+if [[ -f "tsconfig.json" ]]; then
+    if command -v tsc >/dev/null 2>&1; then
+        echo "[TYPE CHECK] Running tsc --noEmit..." >&2
+        tsc --noEmit || true
+    fi
+fi
+
+exit 0

package/scripts/hooks/scan-secrets.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# scan-secrets.sh — Pantheon PreToolUse Secret Scanning Hook
+# Detects hardcoded secrets in tool input.
+set -euo pipefail
+
+SECRET_PATTERNS=(
+    "AKIA[0-9A-Z]{16}"
+    "gh[pousr]_[A-Za-z0-9_]{36,}"
+    "glpat-[A-Za-z0-9_\\-]{20}"
+    "sk-[a-zA-Z0-9]{20,}"
+    "sk_live_[a-zA-Z0-9]{20,}"
+    "sk_test_[a-zA-Z0-9]{20,}"
+    "xox[baprs]-[0-9]{10,13}-[0-9]{10,13}-[a-zA-Z0-9]{24}"
+    "[a-zA-Z0-9_-]*api[_-]?key[a-zA-Z0-9_-]*\s*[:=]\s*[\"']?[a-zA-Z0-9_\\-]{16,}[\"']?"
+    "[a-zA-Z0-9_-]*password[a-zA-Z0-9_-]*\s*[:=]\s*[\"'][^\"']{8,}[\"']"
+    "[a-zA-Z0-9_-]*secret[a-zA-Z0-9_-]*\s*[:=]\s*[\"'][^\"']{8,}[\"']"
+    "bearer\s+[a-zA-Z0-9_\\-\\.]{20,}"
+    "eyJ[A-Za-z0-9_-]*\.eyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]*"
+)
+
+# Keep provider-specific markers assembled so this scanner is not self-matched
+# by the repository secret test.
+BIFROST_HEADER="x""-bf-""vk"
+BIFROST_TOKEN_PREFIX="sk""-bf-"
+SECRET_PATTERNS+=(
+    "$BIFROST_HEADER"
+    "${BIFROST_TOKEN_PREFIX}[A-Za-z0-9_-]{8,}"
+)
+
+INPUT="${1:-${TOOL_INPUT:-}}"
+if [[ -z "$INPUT" ]] && [[ ! -t 0 ]]; then
+    INPUT=$(cat)
+fi
+
+if [[ -z "$INPUT" ]]; then
+    exit 0
+fi
+
+FOUND=0
+for pattern in "${SECRET_PATTERNS[@]}"; do
+    if echo "$INPUT" | grep -iqE "$pattern"; then
+        MATCH=$(echo "$INPUT" | grep -ioE "$pattern" | head -1)
+        # Mask the match for safe logging
+        MASKED="${MATCH:0:4}****${MATCH: -4}"
+        echo "[SECRET SCAN] Potential secret detected: $MASKED (pattern: $pattern)" >&2
+        FOUND=1
+    fi
+done
+
+if [[ $FOUND -eq 1 ]]; then
+    echo "[SECRET SCAN] Hardcoded secret detected. Remove it and use environment variables or a vault." >&2
+    exit 1
+fi
+
+exit 0

package/scripts/hooks/validate-post-conditions.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# validate-post-conditions.sh — Stop hook
+# Checks that Themis review was called after implementation
+set -euo pipefail
+
+# Read JSON input from stdin
+INPUT=$(cat)
+SESSION_ID=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('session_id',''))" 2>/dev/null || echo "")
+
+REVIEW_DIR=".pantheon/memory-bank/.tmp"
+if [ -d "$REVIEW_DIR" ]; then
+    REVIEW_COUNT=$(ls "$REVIEW_DIR"/REVIEW-* 2>/dev/null | wc -l)
+    if [ "$REVIEW_COUNT" -eq 0 ]; then
+        echo "[POST-CONDITION] ⚠️ No REVIEW artifact found in $REVIEW_DIR/" >&2
+        echo "[POST-CONDITION] 💡 Remember: implementation agents MUST call @themis for review" >&2
+    else
+        echo "[POST-CONDITION] ✅ $REVIEW_COUNT REVIEW artifact(s) found" >&2
+    fi
+fi
+
+exit 0

package/scripts/hooks/validate-talos-scope.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+# validate-talos-scope.sh — PreToolUse hook for Talos
+# Receives JSON on stdin, enforces Talos boundaries
+set -euo pipefail
+
+# Read JSON input from stdin (Claude Code hook protocol)
+INPUT=$(cat)
+
+# Extract tool info from JSON input
+TOOL_NAME=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('tool_name',''))" 2>/dev/null || echo "")
+TOOL_INPUT=$(echo "$INPUT" | python3 -c "import sys,json; d=json.load(sys.stdin); print(json.dumps(d.get('tool_input',{})))" 2>/dev/null || echo "")
+
+# Only validate for Talos agent
+AGENT_NAME=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('agent_id',''))" 2>/dev/null || echo "")
+if [ "$AGENT_NAME" != "talos" ]; then
+    # Not Talos — allow pass-through
+    echo "[TALOS SCOPE] Not Talos agent, skipping" >&2
+    exit 0
+fi
+
+# Get changed files from the tool input
+if echo "$TOOL_INPUT" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('command','') or d.get('filePath','') or d.get('file_path',''))" 2>/dev/null | grep -qE '(migration|schema\.sql|alembic|models/.*\.py|auth|security|password|token|secret)'; then
+    echo "[TALOS SCOPE] ❌ Blocked: Talos cannot modify schema/security files" >&2
+    exit 2
+fi
+
+# Count files in the edit/write operation
+FILE_COUNT=$(echo "$TOOL_INPUT" | python3 -c "
+import sys, json
+try:
+    d = json.load(sys.stdin)
+    # Count unique file paths in the input
+    files = set()
+    for key in ['filePath', 'file_path', 'command', 'content']:
+        if key in d and d[key]:
+            files.add(str(d[key]))
+    print(len(files))
+except:
+    print('0')
+" 2>/dev/null || echo "0")
+
+echo "[TALOS SCOPE] ✅ Scope check passed" >&2
+exit 0

package/scripts/hooks/validate-tool-safety.sh

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+# validate-tool-safety.sh — Pantheon PreToolUse Security Hook
+# Blocks destructive commands: rm -rf, DROP TABLE, TRUNCATE, etc.
+set -euo pipefail
+
+BLOCKED_PATTERNS=(
+    # "rm -rf /" appears mid-JSON in the hook stdin protocol (e.g.
+    # {"tool_input":{"command":"rm -rf /"}}), so the old `/$` end-of-line
+    # anchor never matched. Match "/" followed by a JSON delimiter (", },
+    # comma), whitespace, or end of line — catches bare "rm -rf /" anywhere
+    # in the payload while keeping "rm -rf /some/path" (safe) unblocked.
+    "rm\s+-rf\s+/([\"},\t[:space:]]|$)"   # rm -rf / (root only)
+    "rm\s+-rf\s+/\*"         # rm -rf /*
+    "rm\s+-rf\s+~([\",[:space:]]|$)"      # rm -rf ~ (home only)
+    "rm\s+-rf\s+~/"          # rm -rf ~/...
+    "rm\s+-rf\s+\.\.?/"      # rm -rf ./ or rm -rf ../
+    "DROP\s+TABLE"
+    "DROP\s+DATABASE"
+    "TRUNCATE\s+TABLE"
+    "DELETE\s+FROM\s+.*;?\s*$"
+    "rm\s+.*\s+--no-preserve-root"
+    ":(){ :|:& };:"
+    ">\s*/dev/\(sd[a-z]\|hd[a-z]\|disk[0-9]*\)"
+    "dd\s+if=.*of=/dev/"
+    "mkfs\."
+    "fdisk\s+/dev/"
+)
+
+INPUT="${1:-${TOOL_INPUT:-}}"
+if [[ -z "$INPUT" ]] && [[ ! -t 0 ]]; then
+    INPUT=$(cat)
+fi
+
+if [[ -z "$INPUT" ]]; then
+    exit 0
+fi
+
+for pattern in "${BLOCKED_PATTERNS[@]}"; do
+    if echo "$INPUT" | grep -iqE "$pattern"; then
+        echo "[SECURITY BLOCKED] Pattern matched: $pattern" >&2
+        echo "[SECURITY BLOCKED] Destructive command detected and blocked by Pantheon hook." >&2
+        exit 1
+    fi
+done
+
+exit 0

package/scripts/install/health-check.mjs

@@ -9,7 +9,7 @@
  */
 
 import { spawnSync } from 'node:child_process'
-import { existsSync } from 'node:fs'
+import { existsSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
 
 /**
@@ -24,6 +24,7 @@ import { join } from 'node:path'
 export function healthCheck(target, { dryRun = false } = {}) {
   const results = { passed: [], failed: [], warnings: [] }
   const python = findPython(target)
+  const visionServer = resolveVisionServer(target)
 
   // Check 1: Critical runtime scripts exist
   const scripts = ['mcp_persistence_server.py', '_pantheon_paths.py']
@@ -38,9 +39,70 @@ export function healthCheck(target, { dryRun = false } = {}) {
       })
     }
   }
+  if (visionServer) {
+    results.passed.push({
+      check: visionServer.check,
+      detail: visionServer.detail,
+    })
+    const installedVisionServer = join(target, 'scripts', 'pantheon_vision_server.py')
+    const canonicalVisionServer = join(target, 'src', 'mcp', 'pantheon_vision_server.py')
+    if (existsSync(installedVisionServer) && existsSync(canonicalVisionServer)) {
+      try {
+        if (
+          readFileSync(installedVisionServer, 'utf8') !==
+          readFileSync(canonicalVisionServer, 'utf8')
+        ) {
+          results.failed.push({
+            check: 'pantheon-vision source drift',
+            detail: 'installed script differs from src/mcp/pantheon_vision_server.py',
+          })
+        }
+      } catch {
+        results.failed.push({
+          check: 'pantheon-vision source drift',
+          detail: 'could not compare installed script with src/mcp source',
+        })
+      }
+    }
+  } else {
+    results.failed.push({
+      check: 'src/mcp/pantheon_vision_server.py',
+      detail: 'NOT FOUND — canonical vision server source is unavailable',
+    })
+  }
 
   if (dryRun) return results
 
+  // Check 1.5: Vision keeps a small, isolated dependency manifest.
+  const visionRequirements = [
+    join(target, 'src', 'mcp', 'requirements-vision.txt'),
+    join(target, 'requirements-vision.txt'),
+    join(target, '.opencode', 'requirements-vision.txt'),
+  ].find((path) => existsSync(path))
+  if (!visionRequirements) {
+    results.failed.push({
+      check: 'requirements-vision.txt',
+      detail: 'NOT FOUND — vision dependency isolation is incomplete',
+    })
+  } else {
+    const requirements = readFileSync(visionRequirements, 'utf8').toLowerCase()
+    const forbidden = ['pillow', 'paddle', 'gemini', 'torch']
+    const unwanted = forbidden.filter((name) =>
+      new RegExp(`^${name}(?:[<>=!~]|$)`, 'm').test(requirements),
+    )
+    if (unwanted.length > 0) {
+      results.failed.push({
+        check: 'requirements-vision.txt',
+        detail: `forbidden MVP dependencies: ${unwanted.join(', ')}`,
+      })
+    } else {
+      results.passed.push({
+        check: 'requirements-vision.txt',
+        detail: 'isolated and free of heavyweight vision runtimes',
+      })
+    }
+  }
+
   // Check 2: Syntax check on each MCP server script
   const mcpScripts = [
     'mcp_persistence_server.py',
@@ -67,6 +129,22 @@ export function healthCheck(target, { dryRun = false } = {}) {
       }
     }
   }
+  if (visionServer && python) {
+    const result = spawnSync(python, ['-m', 'py_compile', visionServer.path], {
+      stdio: 'pipe',
+    })
+    if (result.status === 0) {
+      results.passed.push({
+        check: 'syntax:pantheon_vision_server.py',
+        detail: 'valid',
+      })
+    } else {
+      results.failed.push({
+        check: 'syntax:pantheon_vision_server.py',
+        detail: result.stderr.toString().trim().split('\n').slice(-1)[0],
+      })
+    }
+  }
 
   // Check 3: _pantheon_paths import works
   if (python) {
@@ -150,6 +228,28 @@ export function healthCheck(target, { dryRun = false } = {}) {
   return results
 }
 
+/**
+ * Resolve the canonical source when checking the repository, or the generated
+ * runtime copy when checking an installed target.
+ * @param {string} target
+ * @returns {{path: string, check: string, detail: string}|null}
+ */
+function resolveVisionServer(target) {
+  const candidates = [
+    {
+      path: join(target, 'src', 'mcp', 'pantheon_vision_server.py'),
+      check: 'src/mcp/pantheon_vision_server.py',
+      detail: 'canonical source exists',
+    },
+    {
+      path: join(target, 'scripts', 'pantheon_vision_server.py'),
+      check: 'scripts/pantheon_vision_server.py',
+      detail: 'installed copy exists (deployed from src/mcp)',
+    },
+  ]
+  return candidates.find(({ path }) => existsSync(path)) ?? null
+}
+
 /**
  * Find the target's venv python, falling back to system python3.
  * @param {string} target

package/scripts/install/model-picker.mjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+/**
+ * model-picker.mjs — interactive model preset selection + persistence
+ *
+ * Used by the installer (interactive prompt) and the `pantheon-opencode`
+ * CLI. Writes the active preset marker to <presetDir>/.pantheon/active-preset.json
+ * which the plugin (src/plugin.ts) reads on startup via resolveActivePreset().
+ */
+import { copyFileSync, existsSync, mkdirSync, renameSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { createInterface } from 'node:readline/promises'
+import { loadPresetDefs } from '../../src/pantheon/presets.mjs'
+
+/**
+ * Build the active-preset.json payload (version 1).
+ *
+ * @param {string} presetName
+ * @param {string} [source] 'cli' | 'interactive'
+ * @returns {{version: number, preset: string, source: string, updated_at: string}}
+ */
+export function buildActivePresetFile(presetName, source = 'cli') {
+  return {
+    version: 1,
+    preset: presetName,
+    source,
+    updated_at: new Date().toISOString(),
+  }
+}
+
+/**
+ * Persist the active preset marker, backing up any previous file to .bak.
+ *
+ * @param {string} presetDir install target (project root or global opencode dir)
+ * @param {string} presetName
+ * @param {{dryRun?: boolean, source?: string, logger?: object}} [opts]
+ * @returns {{written: boolean, path: string, backupPath: string|null}}
+ */
+export function writeActivePreset(
+  presetDir,
+  presetName,
+  { dryRun = false, source = 'cli', logger = console } = {},
+) {
+  const dir = join(presetDir, '.pantheon')
+  const filePath = join(dir, 'active-preset.json')
+  const backupPath = join(dir, 'active-preset.json.bak')
+
+  if (dryRun) {
+    logger.log?.(`[dry-run] Would write model preset "${presetName}" to ${filePath}`)
+    return { written: false, path: filePath, backupPath: null }
+  }
+
+  mkdirSync(dir, { recursive: true })
+  let backupMade = false
+  if (existsSync(filePath)) {
+    copyFileSync(filePath, backupPath)
+    backupMade = true
+  }
+  writeFileSync(`${filePath}.tmp-${process.pid}`, `${JSON.stringify(buildActivePresetFile(presetName, source), null, 2)}\n`)
+  renameSync(`${filePath}.tmp-${process.pid}`, filePath)
+  return { written: true, path: filePath, backupPath: backupMade ? backupPath : null }
+}
+
+/**
+ * Interactive model preset picker. Asks the user to choose a preset; persists
+ * the choice unless dryRun. `rl` may be injected for tests; otherwise a
+ * readline/promises interface on stdin/stdout is created and closed.
+ *
+ * @param {{presetDir?: string, presets?: object, dryRun?: boolean, logger?: object, rl?: object}} [opts]
+ * @returns {Promise<string|null>} chosen preset name or null (skipped/unknown)
+ */
+export async function runModelPicker({
+  presetDir,
+  presets,
+  dryRun = false,
+  logger = console,
+  rl,
+} = {}) {
+  const defs = presets ?? loadPresetDefs()
+  const names = Object.keys(defs)
+  if (names.length === 0) {
+    logger.warn?.('Model presets: no presets defined in routing.yml')
+    return null
+  }
+
+  const list = names.map((n, i) => `  ${i + 1}) ${n} — ${defs[n].description ?? ''}`).join('\n')
+  const rli = rl ?? createInterface({ input: process.stdin, output: process.stdout })
+  try {
+    const answer = await rli.question(
+      `\nModel presets (number or name; blank to skip):\n${list}\n> `,
+    )
+    const trimmed = (answer ?? '').trim()
+    if (trimmed === '' || trimmed.toLowerCase() === 'none') {
+      logger.log?.('Skipping model preset selection.')
+      return null
+    }
+    let name = null
+    if (names.includes(trimmed)) {
+      name = trimmed
+    } else {
+      const idx = Number(trimmed)
+      if (Number.isInteger(idx) && idx >= 1 && idx <= names.length) {
+        name = names[idx - 1]
+      }
+    }
+    if (!name) {
+      logger.warn?.(`Unknown preset "${trimmed}" — skipping model preset selection.`)
+      return null
+    }
+    if (!dryRun) {
+      writeActivePreset(presetDir, name, { dryRun: false, source: 'interactive', logger })
+    } else {
+      logger.log?.(`[dry-run] Would set model preset "${name}"`)
+    }
+    return name
+  } finally {
+    if (!rl) rli.close()
+  }
+}