pantheon-opencode 1.2.0 → 1.2.2

package/scripts/install/opencode.mjs

@@ -3,12 +3,33 @@
  * opencode.mjs — OpenCode platform installer
  */
 
-import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
 import { homedir } from 'node:os'
-import { join, resolve } from 'node:path'
+import { basename, join, resolve } from 'node:path'
+import {
+  bullet,
+  colors,
+  configure,
+  error,
+  info,
+  printSummary,
+  section,
+  spinner,
+  step,
+  success,
+  warning,
+} from './cli-ui.mjs'
 import { healthCheck } from './health-check.mjs'
 import { detectVersion, runMigrations } from './migrate.mjs'
-import { colors, configure, section, step, success, warning, error, info, bullet, spinner, printSummary } from './cli-ui.mjs'
+import { installPlugin, registerPlugin, unregisterPlugin } from './plugin.mjs'
 import {
   collectSkillNames,
   copyFiles,
@@ -20,11 +41,17 @@ import {
   syncDir,
   writeIfChanged,
 } from './shared.mjs'
-import { setupVenv } from './venv.mjs'
-import { installPlugin, registerPlugin, unregisterPlugin } from './plugin.mjs'
-import { resolveComponents } from './component.mjs'
-
-const COMPONENT_NAMES = ['agents', 'skills', 'instructions', 'prompts', 'commands', 'plugins', 'runtime']
+import { setupVenv, venvPythonPath } from './venv.mjs'
+
+const COMPONENT_NAMES = [
+  'agents',
+  'skills',
+  'instructions',
+  'prompts',
+  'commands',
+  'plugins',
+  'runtime',
+]
 
 function deepClone(value) {
   return JSON.parse(JSON.stringify(value))
@@ -63,7 +90,7 @@ function mergeMissing(target, source) {
  * Global installs use a flat layout: agents/ skills/ commands/ plugins/
  * Project installs use the .opencode/ sub-directory layout.
  */
-function isGlobalConfigDir(target) {
+export function isGlobalConfigDir(target) {
   // Primary: ~/.opencode (actual OpenCode installation)
   const homeDir = resolve(join(homedir(), '.opencode'))
   if (resolve(target) === homeDir) return true
@@ -166,8 +193,9 @@ export async function installOpenCode(
     const srcRouting = join(ROOT, 'src', 'routing.yml')
     const dstRouting = join(target, 'routing.yml')
     if (existsSync(srcRouting)) {
-      writeIfChanged(dstRouting, readFileSync(srcRouting, 'utf8'), dryRun)
-      stats.created++
+      const routingStatus = writeIfChanged(dstRouting, readFileSync(srcRouting, 'utf8'), dryRun)
+      if (routingStatus === 'created') stats.created++
+      else stats.skipped++
     }
   }
 
@@ -253,24 +281,12 @@ export async function installOpenCode(
 
   // -----------------------------------------------------------------------
   // -----------------------------------------------------------------------
-  // 2.7 Ensure subagent_depth in opencode.json
+  // 2.7 subagent_depth is merged into opencode.json in the config section
+  // below (always runs) — see "Ensure critical top-level config sections".
+  // Previously this was a separate block gated on the config file already
+  // existing, so a FRESH install only gained subagent_depth on the SECOND
+  // init run (idempotence bug, issue #19).
   // -----------------------------------------------------------------------
-  if (componentSet.has('agents')) {
-    const cfgPath = join(target, 'opencode.json')
-    if (existsSync(cfgPath)) {
-      try {
-        const cfg = JSON.parse(readFileSync(cfgPath, 'utf8'))
-        let changed = false
-        if (cfg.subagent_depth === undefined) { cfg.subagent_depth = 2; changed = true }
-        if (changed && !dryRun) {
-          writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + '\n')
-          success('subagent_depth: 2 added to opencode.json')
-        }
-      } catch (e) {
-        warning(`Could not update opencode.json: ${e.message}`)
-      }
-    }
-  }
 
   // 2.8 Install TUI plugins (--components plugins)
   // -----------------------------------------------------------------------
@@ -292,9 +308,16 @@ export async function installOpenCode(
   const targetTuiConfigPath = isGlobal
     ? join(target, 'tui.json')
     : join(target, '.opencode', 'tui.json')
-  const pluginRef = 'plugins/pantheon-tui'
-  unregisterPlugin(targetTuiConfigPath, pluginRef, { dryRun })
-  const tuiStatus = registerPlugin(targetTuiConfigPath, pluginRef, { dryRun })
+  // Hermetic TUI plugin registration: opencode's tui loader treats relative
+  // entries ("plugins/pantheon-tui") as npm/github package specs and fails
+  // with NpmInstallFailedError ("Repository not found"). Register the plugin
+  // by the ABSOLUTE path of the built dist inside the installed package
+  // (derived from ROOT — never hardcoded), mirroring the loader's
+  // absolute-path support (same pattern as the hooks plugin fix).
+  const tuiPluginRef = join(ROOT, 'src', 'plugins', 'tui', 'dist', 'tui.tsx')
+  // Clean up the old broken relative ref (and stale dist refs) on upgrade.
+  unregisterPlugin(targetTuiConfigPath, 'plugins/pantheon-tui', { dryRun })
+  const tuiStatus = registerPlugin(targetTuiConfigPath, tuiPluginRef, { dryRun })
   if (tuiStatus === 'created') stats.created++
   else stats.skipped++
 
@@ -314,12 +337,26 @@ export async function installOpenCode(
       'scrub-secrets.py',
       '_pantheon_paths.py',
       'mcp_persistence_server.py',
+      'pantheon_vision_server.py',
     ]
     const srcScriptsDir = join(ROOT, 'scripts')
+    // Canonical MCP server sources live in src/mcp/. Map them explicitly so the
+    // sync always copies from the canonical source, never from the stale root
+    // scripts/ copies (which previously propagated bugs like the missing
+    // `import uuid` in mcp_persistence_server.py). scrub-secrets.py is not in
+    // src/mcp/ and intentionally falls back to join(ROOT, 'scripts').
+    const canonicalMcpScripts = {
+      'mcp_resources_server.py': join(ROOT, 'src', 'mcp', 'mcp_resources_server.py'),
+      'code_mode_server.py': join(ROOT, 'src', 'mcp', 'code_mode_server.py'),
+      'memory_mcp_server.py': join(ROOT, 'src', 'mcp', 'memory_mcp_server.py'),
+      '_pantheon_paths.py': join(ROOT, 'src', 'mcp', '_pantheon_paths.py'),
+      'mcp_persistence_server.py': join(ROOT, 'src', 'mcp', 'mcp_persistence_server.py'),
+      'pantheon_vision_server.py': join(ROOT, 'src', 'mcp', 'pantheon_vision_server.py'),
+    }
     const dstScriptsDir = join(runtimeTarget, 'scripts')
     if (!dryRun) mkdirSync(dstScriptsDir, { recursive: true })
     for (const script of mcpScripts) {
-      const src = join(srcScriptsDir, script)
+      const src = canonicalMcpScripts[script] || join(srcScriptsDir, script)
       if (!existsSync(src)) {
         warning(`Script not found: ${src}`)
         stats.errors++
@@ -341,6 +378,18 @@ export async function installOpenCode(
       } else stats.skipped++
     }
 
+    // Keep Vision's dependency contract available to the installed runtime.
+    const visionRequirements = join(ROOT, 'src', 'mcp', 'requirements-vision.txt')
+    if (existsSync(visionRequirements)) {
+      const destination = join(runtimeTarget, 'requirements-vision.txt')
+      const status = writeIfChanged(destination, readFileSync(visionRequirements, 'utf8'), dryRun)
+      if (status === 'created') stats.created++
+      else stats.skipped++
+    } else {
+      warning(`Requirements file not found: ${visionRequirements}`)
+      stats.errors++
+    }
+
     // ── Code-mode scripts ──
     const srcCodeModeDir = join(ROOT, '.pantheon', 'code-mode')
     const dstCodeModeDir = join(runtimeTarget, '.pantheon', 'code-mode')
@@ -519,15 +568,41 @@ export async function installOpenCode(
   if (!config.default_agent && pantheonConfig.default_agent) {
     config.default_agent = pantheonConfig.default_agent
   }
+  // Merge subagent_depth HERE (the config merge always runs, including on a
+  // fresh install) instead of a file-existence-gated block, so run #1 already
+  // produces the final config — run #2 must be a byte-identical no-op (#19).
+  if (config.subagent_depth === undefined) {
+    config.subagent_depth = 2
+  }
+
+  // --------------------------------------------------------------------
+  // B.5.1 Hermetic plugin resolution (packaging fix)
+  // --------------------------------------------------------------------
+  // The packaged opencode.json may reference the pantheon-hooks plugin via a
+  // developer-machine absolute path (e.g. /home/<dev>/pantheon/src/plugins/...).
+  // Copying that verbatim into the user's config would break every global
+  // install on any other machine. Option A: rewrite the entry to the plugin
+  // file inside the INSTALLED package (derived from ROOT — never hardcoded),
+  // so both dev and global installs resolve to a path that actually exists.
+  // The source opencode.json keeps its dev path for local development; the
+  // transform happens at install/sync time only.
+  function resolveInstalledPlugin(plugin) {
+    const file = basename(plugin)
+    const packaged = join(ROOT, 'src', 'plugins', file)
+    return existsSync(packaged) ? packaged : plugin
+  }
 
   if (!Array.isArray(config.plugin)) {
     config.plugin = []
   }
   if (Array.isArray(pantheonConfig.plugin)) {
     for (const plugin of pantheonConfig.plugin) {
-      if (!config.plugin.includes(plugin)) {
-        config.plugin.push(plugin)
-      }
+      const resolved = resolveInstalledPlugin(plugin)
+      const file = basename(resolved)
+      // Replace any pre-existing entry for the same plugin file (e.g. a stale
+      // dev-machine path from an earlier install) so upgrades stay hermetic.
+      config.plugin = config.plugin.filter((p) => basename(p) !== file)
+      config.plugin.push(resolved)
     }
   }
 
@@ -604,10 +679,16 @@ export async function installOpenCode(
   // --------------------------------------------------------------------
   if (componentSet.has('runtime')) {
     config.mcp = config.mcp || {}
+    // P1-3: derive the MCP python from the SAME venv layout setupVenv
+    // creates (<target>/.venv via venvPythonPath). For project installs the
+    // runtime payload lives under <target>/.opencode (runtimeTarget), but the
+    // venv is created at <target>/.venv — pointing MCP commands at
+    // runtimeTarget/.venv would reference an executable that never exists.
     const runtimeTarget = isGlobal ? target : join(target, '.opencode')
-    const pythonPath = process.platform === 'win32' ? 'python' : 'python3'
-    const venvPython = join(runtimeTarget, '.venv', 'bin', 'python3')
-    const memoryPython = existsSync(venvPython) ? venvPython : pythonPath
+    const venvPython = venvPythonPath(target)
+    // Point the config at the venv even on a first install; setupVenv runs
+    // later in this function and creates this path before OpenCode starts.
+    const memoryPython = venvPython
 
     // Only add if not already configured by user
     if (!config.mcp['pantheon-resources']) {
@@ -642,6 +723,14 @@ export async function installOpenCode(
         enabled: true,
       }
     }
+    if (!config.mcp['pantheon-vision']) {
+      config.mcp['pantheon-vision'] = {
+        type: 'local',
+        cwd: runtimeTarget,
+        command: [memoryPython, 'scripts/pantheon_vision_server.py'],
+        enabled: true,
+      }
+    }
 
     // Default MCP permissions
     config.permission = config.permission || {}
@@ -658,6 +747,9 @@ export async function installOpenCode(
     if (!config.permission.mcp['pantheon-persistence']) {
       config.permission.mcp['pantheon-persistence'] = 'allow'
     }
+    if (!config.permission.mcp['pantheon-vision']) {
+      config.permission.mcp['pantheon-vision'] = 'ask'
+    }
   }
 
   const configContent = `${JSON.stringify(config, null, 2)}\n`
@@ -707,7 +799,7 @@ export async function installOpenCode(
       }
     } catch (err) {
       error(`Setup failed: ${err.message}`)
-      throw err  // Fatal — abort installation
+      throw err // Fatal — abort installation
     }
   }
 
@@ -718,18 +810,38 @@ export async function installOpenCode(
 
     process.stdout.write('\n')
     process.stdout.write(`  ${colors.bold(colors.green('Installation complete'))}\n`)
-    process.stdout.write(`  ${colors.dim('\u2500'.repeat(Math.min(process.stdout.columns || 60, 60)))}\n`)
+    process.stdout.write(
+      `  ${colors.dim('\u2500'.repeat(Math.min(process.stdout.columns || 60, 60)))}\n`,
+    )
     process.stdout.write(`  ${colors.green('\u2713')} ${created} component(s) installed\n`)
-    if (skipped > 0) process.stdout.write(`  ${colors.dim('\u2014')} ${skipped} already up-to-date\n`)
-    if (errors > 0) process.stdout.write(`  ${colors.yellow('\u26a0')} ${errors} error(s) encountered\n`)
+    if (skipped > 0)
+      process.stdout.write(`  ${colors.dim('\u2014')} ${skipped} already up-to-date\n`)
+    if (errors > 0)
+      process.stdout.write(`  ${colors.yellow('\u26a0')} ${errors} error(s) encountered\n`)
     process.stdout.write('\n')
     process.stdout.write(`  ${colors.bold('Next steps:')}\n`)
     process.stdout.write(`  ${colors.dim('\u2022')} Configure agents in opencode.json\n`)
     process.stdout.write(`  ${colors.dim('\u2022')} Add MCP servers in mcp.json\n`)
     process.stdout.write(`  ${colors.dim('\u2022')} Run 'opencode doctor' to verify\n`)
-    process.stdout.write(`  ${colors.dim('\u2022')} Run 'opencode' to start using Pantheon agents\n`)
+    process.stdout.write(
+      `  ${colors.dim('\u2022')} Run 'opencode' to start using Pantheon agents\n`,
+    )
     process.stdout.write('\n')
   } else {
     printSummary(target, ['opencode'], stats)
   }
+
+  // -----------------------------------------------------------------------
+  // 5. Model preset selection (--components agents). Interactive picker runs
+  //    unless autoYes (use defaults) or an explicit --preset was given.
+  // -----------------------------------------------------------------------
+  if (interactive && !dryRun && !autoYes && !opts.preset) {
+    const { runModelPicker } = await import('./model-picker.mjs')
+    await runModelPicker({ presetDir: target, logger: console })
+  }
+
+  if (opts.preset && !dryRun) {
+    const { writeActivePreset } = await import('./model-picker.mjs')
+    writeActivePreset(target, opts.preset, { source: 'cli' })
+  }
 }

package/scripts/install/plugin.mjs

@@ -128,8 +128,10 @@ export function unregisterPlugin(tuiJsonPath, pluginId, { dryRun = false } = {})
   if (!Array.isArray(tuiConfig.plugin)) {
     tuiConfig.plugin = []
   }
-  // Remove stale plugin refs (old dist/tui.tsx path)
-  const staleRefs = [`${pluginId}/dist/tui.tsx`, `${pluginId}/dist/tui.js`]
+  // Remove stale refs: the bare relative id (openCode < 1.19 wrote
+  // "plugins/pantheon-tui", which its tui loader misreads as an npm/github
+  // spec → NpmInstallFailedError) and the old dist paths.
+  const staleRefs = [pluginId, `${pluginId}/dist/tui.tsx`, `${pluginId}/dist/tui.js`]
   for (const stale of staleRefs) {
     const idx = tuiConfig.plugin.indexOf(stale)
     if (idx !== -1) tuiConfig.plugin.splice(idx, 1)

package/scripts/install/venv.mjs

@@ -17,6 +17,25 @@ import { fileURLToPath } from 'node:url'
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const ROOT = join(__dirname, '..', '..')
 
+/**
+ * Resolve the python executable of the venv that setupVenv creates for a
+ * target. Single source of truth for the venv layout: the venv always lives
+ * at <target>/.venv — even for PROJECT installs, where the runtime payload
+ * goes to <target>/.opencode. MCP commands and health checks MUST derive
+ * their python from here (never from a runtime sub-directory), or a project
+ * install would point at <target>/.opencode/.venv/bin/python3, which
+ * setupVenv never creates (P1-3).
+ *
+ * @param {string} target - target installation directory
+ * @returns {string} absolute path to the venv python executable
+ */
+export function venvPythonPath(target) {
+  const venvPath = join(target, '.venv')
+  return process.platform === 'win32'
+    ? join(venvPath, 'Scripts', 'python.exe')
+    : join(venvPath, 'bin', 'python3')
+}
+
 /**
  * Set up a Python virtual environment and install MCP dependencies.
  *
@@ -26,7 +45,7 @@ const ROOT = join(__dirname, '..', '..')
  */
 export function setupVenv(target, { dryRun = false, skipInstall = false, force = false } = {}) {
   const venvPath = join(target, '.venv')
-  const pythonBin = join(venvPath, 'bin', 'python3')
+  const pythonBin = venvPythonPath(target)
 
   // Step 1: Force recreate venv if --force
   if (force && existsSync(venvPath)) {
@@ -94,7 +113,11 @@ export function setupVenv(target, { dryRun = false, skipInstall = false, force =
         if (r2.status !== 0) {
           throw new Error(
             'Failed to install MCP dependencies. ' +
-            'Try: PIP_USER=0 ' + pip + ' install -r ' + reqFile + ' --break-system-packages'
+              'Try: PIP_USER=0 ' +
+              pip +
+              ' install -r ' +
+              reqFile +
+              ' --break-system-packages',
           )
         }
       }