pantheon-opencode 1.6.0-beta.1 → 1.6.0-beta.10

package/scripts/test-opencode-v2-sandbox.sh

@@ -34,7 +34,7 @@
 # Env overrides:
 #   PANTHEON_SANDBOX_ROOT    Sandbox root (default: ~/pantheon-sandbox)
 #   OPENCODE_V2_SPEC         npm spec providing the V2 binary
-#                            (default: @opencode-ai/cli@beta). NOTE: this is an
+#                            (default: @opencode/cli@latest). NOTE: this is an
 #                            install spec only — it is not a dependency of this
 #                            package, and no code imports it.
 #   PANTHEON_REPO            Repository the sandbox is built from (default: the
@@ -63,7 +63,7 @@ SANDBOX_ROOT="${PANTHEON_SANDBOX_ROOT:-$HOME/pantheon-sandbox}"
 SANDBOX_HOME="$SANDBOX_ROOT/home"
 NPM_PREFIX="$SANDBOX_HOME/.npm-global"
 
-OPENCODE_V2_SPEC="${OPENCODE_V2_SPEC:-@opencode-ai/cli@beta}"
+OPENCODE_V2_SPEC="${OPENCODE_V2_SPEC:-@opencode/cli@latest}"
 PANTHEON_SANDBOX_MODEL="${PANTHEON_SANDBOX_MODEL:-opencode-go/mimo-v2.5}"
 PANTHEON_PROMPT_TIMEOUT="${PANTHEON_PROMPT_TIMEOUT:-300}"
 
@@ -241,11 +241,11 @@ try:
 except OSError:
     raise SystemExit(1)
 expected = {
-    "code_mode_server.py",
-    "memory_mcp_server.py",
-    "mcp_persistence_server.py",
-    "mcp_resources_server.py",
-    "pantheon_vision_server.py",
+    "code_mode.py",
+    "memory_mcp.py",
+    "mcp_persistence.py",
+    "mcp_resources.py",
+    "pantheon_vision.py",
 }
 pattern = re.compile(
     r"spawning process \{\s*"
@@ -265,7 +265,10 @@ for record in records:
     if command != python_bin or cwd != runtime_dir or script not in expected:
         raise SystemExit(1)
     registered.add(script)
-if len(records) != len(expected) or registered != expected:
+# OpenCode can initialize the same configured workspace more than once during
+# service startup and `mcp list`. Count the logical server set here; the later
+# `mcp list` assertion still requires exactly five connected MCP names.
+if registered != expected:
     raise SystemExit(1)
 PY
     then
@@ -418,6 +421,7 @@ V2_DB="${PANTHEON_V2_DB:-$SANDBOX_DIR/opencode-v2.db}"
 V2_PORT="${PANTHEON_V2_PORT:-49376}"
 V2_LOOPBACK_HOST="${PANTHEON_V2_HOST:-127.0.0.1}"
 V2_HANDSHAKE_TIMEOUT="${PANTHEON_V2_HANDSHAKE_TIMEOUT:-60}"
+V2_MCP_LIST_TIMEOUT="${PANTHEON_V2_MCP_LIST_TIMEOUT:-15}"
 V2_SERVER_LOG="$SANDBOX_DIR/v2-server.log"
 V2_SERVICE_STATE="$SANDBOX_HOME/.local/state/opencode/service.json"
 V2_SERVER_PID=""
@@ -515,11 +519,11 @@ try:
 except OSError:
     raise SystemExit(1)
 expected = {
-    "code_mode_server.py",
-    "memory_mcp_server.py",
-    "mcp_persistence_server.py",
-    "mcp_resources_server.py",
-    "pantheon_vision_server.py",
+    "code_mode.py",
+    "memory_mcp.py",
+    "mcp_persistence.py",
+    "mcp_resources.py",
+    "pantheon_vision.py",
 }
 pattern = re.compile(
     r"spawning process \{\s*"
@@ -642,11 +646,11 @@ config_path = Path(os.environ["CONFIG_PATH"])
 runtime_dir = os.environ["RUNTIME_DIR"]
 python_bin = os.environ["MCP_PYTHON"]
 managed = {
-    "pantheon-code-mode": "code_mode_server.py",
-    "pantheon-memory": "memory_mcp_server.py",
-    "pantheon-persistence": "mcp_persistence_server.py",
-    "pantheon-resources": "mcp_resources_server.py",
-    "pantheon-vision": "pantheon_vision_server.py",
+    "pantheon-code-mode": "code_mode.py",
+    "pantheon-memory": "memory_mcp.py",
+    "pantheon-persistence": "mcp_persistence.py",
+    "pantheon-resources": "mcp_resources.py",
+    "pantheon-vision": "pantheon_vision.py",
 }
 try:
     config = json.loads(config_path.read_text(encoding="utf-8"))
@@ -735,7 +739,8 @@ check_mcp() { # label binary project
   if ! wait_for_v2_mcp_registrations "$project/.opencode" "$project/.venv/bin/python3"; then
     kill "$list_pid" 2>/dev/null || true
     wait "$list_pid" 2>/dev/null || true
-    rm -f "$list_file"
+    echo "--- mcp list output (preserved at $list_file) ---" >&2
+    cat "$list_file" >&2 || true
     record_status "$label MCP" "FAIL" "MCP registrations did not match the active sandbox"
     return 0
   fi
@@ -744,7 +749,8 @@ check_mcp() { # label binary project
   else
     kill "$list_pid" 2>/dev/null || true
     wait "$list_pid" 2>/dev/null || true
-    rm -f "$list_file"
+    echo "--- mcp list output (preserved at $list_file) ---" >&2
+    cat "$list_file" >&2 || true
     record_status "$label MCP" "FAIL" "MCP handshakes did not become ready after mcp list started"
     return 0
   fi
@@ -809,6 +815,11 @@ if ! git -C "$REPO_DIR" ls-files --error-unmatch -- "$TGZ" >/dev/null 2>&1; then
 echo "--- Init (headless) ---"
 pantheon-opencode init --headless -y
 rewrite_v2_mcp_config
+node "$REPO_DIR/scripts/validate-sandbox-install.mjs" \
+  --repo "$REPO_DIR" \
+  --install "$NPM_PREFIX/lib/node_modules/pantheon-opencode" \
+  --project-config "$V2_CONFIG" \
+  --config "$PANTHEON_GLOBAL/opencode.json"
 
 echo "--- MCP Validation ---"
 check_mcp "V2" opencode2 "$SANDBOX_DIR/project-v2"
@@ -829,7 +840,7 @@ else
 fi
 
 echo "--- Gate (b): pantheon://agents CONTENT check ---"
-RESOURCES_SRV="$PANTHEON_GLOBAL/scripts/mcp_resources_server.py"
+RESOURCES_SRV="$PANTHEON_GLOBAL/scripts/mcp_resources.py"
 if [ ! -f "$RESOURCES_SRV" ]; then
   record_status "pantheon://agents resource" "FAIL" "resources server not found at $RESOURCES_SRV"
 else
@@ -871,6 +882,139 @@ fi
 echo "Next: open the isolated TUI with: $SANDBOX_DIR/start-pantheon.sh"
 RUNTEST
   chmod +x "$SANDBOX_ROOT/run-test.sh"
+
+  cat > "$SANDBOX_ROOT/start-pantheon.sh" <<'STARTPANTHEON'
+#!/usr/bin/env bash
+# Generated by pantheon-opencode scripts/test-opencode-v2-sandbox.sh --prepare
+# Launches the installed OpenCode beta with only this sandbox's HOME/config/db.
+set -euo pipefail
+
+SANDBOX_DIR="$(cd "$(dirname "$0")" && pwd)"
+SANDBOX_HOME="$SANDBOX_DIR/home"
+NPM_PREFIX="$SANDBOX_HOME/.npm-global"
+SANDBOX_VENV="$SANDBOX_HOME/.config/opencode/.venv"
+V2_PORT="${PANTHEON_V2_PORT:-49376}"
+if [[ ! "$V2_PORT" =~ ^[0-9]{1,5}$ ]]; then
+  echo "ERROR: PANTHEON_V2_PORT must be an integer from 1 through 65535 (got '$V2_PORT')" >&2
+  exit 1
+fi
+V2_PORT=$((10#$V2_PORT))
+if [ "$V2_PORT" -lt 1 ] || [ "$V2_PORT" -gt 65535 ]; then
+  echo "ERROR: PANTHEON_V2_PORT must be an integer from 1 through 65535 (got '$V2_PORT')" >&2
+  exit 1
+fi
+if ! python3 - "$V2_PORT" "$NPM_PREFIX" <<'CHECKPORT'
+import errno
+import os
+import socket
+import sys
+from urllib.request import urlopen
+
+port = int(sys.argv[1])
+cli_prefix = os.path.realpath(
+    os.path.join(sys.argv[2], "lib", "node_modules", "@opencode", "cli")
+)
+try:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as probe:
+        # A just-stopped service can leave a harmless TIME_WAIT socket behind.
+        # SO_REUSEADDR permits the new service to bind that port without
+        # masking a live listener or an unrelated server.
+        probe.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        probe.bind(("127.0.0.1", port))
+except OSError as exc:
+    if exc.errno != errno.EADDRINUSE:
+        print(f"ERROR: cannot reserve dedicated V2 port 127.0.0.1:{port}: {exc}", file=sys.stderr)
+        raise SystemExit(1)
+
+    # OpenCode intentionally keeps its managed service alive after the TUI exits.
+    # Reuse it only when /proc proves the listener is this sandbox's CLI binary.
+    inodes = set()
+    for table in ("/proc/net/tcp", "/proc/net/tcp6"):
+        try:
+            with open(table, encoding="ascii") as entries:
+                next(entries, None)
+                for line in entries:
+                    fields = line.split()
+                    if len(fields) >= 10 and int(fields[1].rsplit(":", 1)[1], 16) == port and fields[3] == "0A":
+                        inodes.add(fields[9])
+        except OSError:
+            pass
+
+    listener_pids = set()
+    for pid in (entry for entry in os.listdir("/proc") if entry.isdigit()):
+        fd_dir = f"/proc/{pid}/fd"
+        try:
+            for fd in os.listdir(fd_dir):
+                try:
+                    target = os.readlink(os.path.join(fd_dir, fd))
+                except OSError:
+                    continue
+                if target.startswith("socket:[") and target[8:-1] in inodes:
+                    listener_pids.add(pid)
+                    break
+        except OSError:
+            continue
+
+    owns_listener = False
+    for pid in listener_pids:
+        try:
+            with open(f"/proc/{pid}/cmdline", "rb") as command_line:
+                args = [arg.decode(errors="replace") for arg in command_line.read().split(b"\0") if arg]
+        except OSError:
+            continue
+        executable = os.path.realpath(args[0]) if args else ""
+        if (
+            executable.startswith(cli_prefix + os.sep)
+            and "serve" in args
+            and "--service" in args
+            and len(listener_pids) == 1
+        ):
+            owns_listener = True
+            break
+
+    healthy = False
+    if owns_listener:
+        try:
+            scheme = "http"
+            loopback = ".".join(("127", "0", "0", "1"))
+            with urlopen(f"{scheme}://{loopback}:{port}/global/health", timeout=2) as response:
+                healthy = response.status == 200
+        except Exception:
+            pass
+
+    if not healthy:
+        print(
+            f"ERROR: dedicated V2 port 127.0.0.1:{port} is occupied by a different or unverifiable service; no service was stopped",
+            file=sys.stderr,
+        )
+        raise SystemExit(1)
+    print(f"Reusing the existing beta sandbox OpenCode service on 127.0.0.1:{port} (PID {next(iter(listener_pids))}).")
+CHECKPORT
+then
+  exit 1
+fi
+
+export HOME="$SANDBOX_HOME"
+export PATH="$NPM_PREFIX/bin:$SANDBOX_VENV/bin:$PATH"
+export npm_config_prefix="$NPM_PREFIX"
+export XDG_CONFIG_HOME="$SANDBOX_HOME/.config"
+export XDG_CONFIG_DIRS="$SANDBOX_HOME/.config/xdg"
+export XDG_DATA_HOME="$SANDBOX_HOME/.local/share"
+export XDG_DATA_DIRS="$SANDBOX_HOME/.local/share/xdg"
+export XDG_STATE_HOME="$SANDBOX_HOME/.local/state"
+export XDG_CACHE_HOME="$SANDBOX_HOME/.cache"
+export OPENCODE_CONFIG_DIR="$SANDBOX_DIR/project-v2"
+export OPENCODE_DB="${PANTHEON_V2_DB:-$SANDBOX_DIR/opencode-v2.db}"
+export PANTHEON_V2_PORT="$V2_PORT"
+export PORT="$PANTHEON_V2_PORT"
+unset OPENCODE_CONFIG OPENCODE_CONFIG_CONTENT OPENCODE_CONFIG_PROJECT_DISABLE \
+  OPENCODE_DATA_DIR OPENCODE_STATE_DIR OPENCODE_CACHE_DIR OPENCODE_STORAGE_PATH
+
+"$NPM_PREFIX/bin/opencode2" service set port "$V2_PORT"
+cd "$SANDBOX_DIR/project-v2"
+exec "$NPM_PREFIX/bin/opencode2" "$@"
+STARTPANTHEON
+  chmod +x "$SANDBOX_ROOT/start-pantheon.sh"
 }
 
 # ── Reset / Prepare ───────────────────────────────────────────────────────────
@@ -990,6 +1134,7 @@ prepare_project() {
   (cd "$dir" && "$pan" init --project --version "$TARGET_VERSION" --model "$PANTHEON_SANDBOX_MODEL" -y) \
     || die "init --project --version $TARGET_VERSION failed in $dir"
   rewrite_v2_mcp_config
+  validate_sandbox_install
 }
 
 # The installer merges an existing project config. A reused sandbox can
@@ -1013,11 +1158,11 @@ config_path = Path(os.environ["CONFIG_PATH"])
 runtime_dir = os.environ["RUNTIME_DIR"]
 python_bin = os.environ["MCP_PYTHON"]
 managed = {
-    "pantheon-code-mode": "code_mode_server.py",
-    "pantheon-memory": "memory_mcp_server.py",
-    "pantheon-persistence": "mcp_persistence_server.py",
-    "pantheon-resources": "mcp_resources_server.py",
-    "pantheon-vision": "pantheon_vision_server.py",
+    "pantheon-code-mode": "code_mode.py",
+    "pantheon-memory": "memory_mcp.py",
+    "pantheon-persistence": "mcp_persistence.py",
+    "pantheon-resources": "mcp_resources.py",
+    "pantheon-vision": "pantheon_vision.py",
 }
 
 try:
@@ -1077,6 +1222,15 @@ for name, script in managed.items():
 PY
 }
 
+validate_sandbox_install() {
+  node "$REPO_DIR/scripts/validate-sandbox-install.mjs" \
+    --repo "$REPO_DIR" \
+    --install "$NPM_PREFIX/lib/node_modules/pantheon-opencode" \
+    --project-config "$V2_CONFIG" \
+    --config "$SANDBOX_HOME/.config/opencode/opencode.json" \
+    || die "sandbox package/config validation failed"
+}
+
 cmd_prepare() {
   mkdir -p "$SANDBOX_HOME" "$NPM_PREFIX"
   write_run_test_sh

package/scripts/validate-routing.mjs

@@ -19,7 +19,7 @@ import { createHash } from 'node:crypto'
 import { existsSync, readdirSync, readFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import yaml from 'js-yaml'
+import { load } from 'js-yaml'
 import { validatePresetDefs } from '../src/pantheon/presets.mjs'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
@@ -52,7 +52,7 @@ if (!existsSync(routingPath)) {
   console.error('❌ routing.yml not found')
   process.exit(1)
 }
-const routing = yaml.load(readFileSync(routingPath, 'utf8'))
+const routing = load(readFileSync(routingPath, 'utf8'))
 
 console.log('🔍 Validating routing.yml...\n')
 
@@ -253,7 +253,7 @@ function parseFrontmatter(filePath) {
   const match = content.match(FRONTMATTER_RE)
   if (!match) return null
   try {
-    return yaml.load(match[1])
+    return load(match[1])
   } catch {
     return null
   }

package/scripts/validate-sandbox-install.mjs

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import { createHash } from 'node:crypto'
+import { readFileSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const PACKAGE_REF = /^(?:npm:)?pantheon-opencode(?:@[^/]+)?(?:\/(?:plugin|plugin-v2))?$/
+export const SANDBOX_SOURCE_FILES = [
+  'bin/pantheon-init.mjs',
+  'scripts/install/config-migration.mjs',
+  'scripts/install/opencode.mjs',
+  'scripts/validate-sandbox-install.mjs',
+  'src/plugin-v2.ts',
+]
+
+function readJson(path, label) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'))
+  } catch (error) {
+    throw new Error(`cannot read ${label} at ${path}: ${error.message}`)
+  }
+}
+
+function pluginReferences(config) {
+  const refs = []
+  for (const key of ['plugin', 'plugins']) {
+    const value = config?.[key]
+    const entries = Array.isArray(value) ? value : value === undefined ? [] : [value]
+    for (const entry of entries) {
+      if (typeof entry === 'string') refs.push(entry)
+      else if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
+        for (const field of ['package', 'id', 'name', 'path', 'source']) {
+          if (typeof entry[field] === 'string') refs.push(entry[field])
+        }
+      }
+    }
+  }
+  return refs
+}
+
+/**
+ * Prove that the sandbox is executing the package built from this checkout and
+ * that the project config cannot silently load an older npm-cached Pantheon.
+ */
+export function validateSandboxInstall({ repoDir, installDir, projectConfig, configPaths = [] }) {
+  const sourcePackagePath = join(resolve(repoDir), 'package.json')
+  const installedPackagePath = join(resolve(installDir), 'package.json')
+  const sourcePackage = readJson(sourcePackagePath, 'checkout package manifest')
+  const installedPackage = readJson(installedPackagePath, 'sandbox package manifest')
+  if (sourcePackage.version !== installedPackage.version) {
+    throw new Error(
+      `sandbox package version ${installedPackage.version} does not match checkout ${sourcePackage.version}`,
+    )
+  }
+
+  const sourceHash = createHash('sha256')
+  for (const relativePath of SANDBOX_SOURCE_FILES) {
+    let source
+    let installed
+    try {
+      source = readFileSync(join(resolve(repoDir), relativePath))
+      installed = readFileSync(join(resolve(installDir), relativePath))
+    } catch (error) {
+      throw new Error(`cannot compare package source ${relativePath}: ${error.message}`)
+    }
+    if (!source.equals(installed)) {
+      throw new Error(`installed package source differs from checkout: ${relativePath}`)
+    }
+    sourceHash.update(relativePath).update('\0').update(installed).update('\0')
+  }
+
+  const expectedPluginPath = resolve(installDir, 'src', 'plugin-v2')
+  const allConfigPaths = [...new Set([projectConfig, ...configPaths].map((path) => resolve(path)))]
+  let activeProjectPluginCount = 0
+  for (const configPath of allConfigPaths) {
+    const config = readJson(configPath, 'active OpenCode config')
+    if (!config || typeof config !== 'object' || Array.isArray(config)) {
+      throw new Error(`active OpenCode config must be an object: ${configPath}`)
+    }
+    for (const ref of pluginReferences(config)) {
+      const normalized = ref.replaceAll('\\', '/').replace(/\/$/, '')
+      if (PACKAGE_REF.test(normalized)) {
+        throw new Error(`stale Pantheon package reference in ${configPath}: ${ref}`)
+      }
+      if (resolve(ref) === expectedPluginPath) {
+        if (configPath === resolve(projectConfig)) activeProjectPluginCount += 1
+      }
+    }
+  }
+  if (activeProjectPluginCount !== 1) {
+    throw new Error(
+      `project config must reference the sandbox V2 plugin exactly once; found ${activeProjectPluginCount}: ${resolve(projectConfig)}`,
+    )
+  }
+
+  return {
+    status: 'PASS',
+    version: installedPackage.version,
+    sourceSha256: sourceHash.digest('hex'),
+  }
+}
+
+function parseArgs(args) {
+  const options = { configPaths: [] }
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i]
+    if (arg === '--config') options.configPaths.push(args[++i])
+    else if (['--repo', '--install', '--project-config'].includes(arg))
+      options[arg.slice(2).replace('-', '')] = args[++i]
+    else throw new Error(`unknown argument: ${arg}`)
+  }
+  for (const required of ['repo', 'install', 'projectconfig']) {
+    if (!options[required])
+      throw new Error(
+        `missing required option --${required.replace('projectconfig', 'project-config')}`,
+      )
+  }
+  return {
+    repoDir: options.repo,
+    installDir: options.install,
+    projectConfig: options.projectconfig,
+    configPaths: options.configPaths,
+  }
+}
+
+function main() {
+  try {
+    const result = validateSandboxInstall(parseArgs(process.argv.slice(2)))
+    process.stdout.write(
+      `Sandbox install proof: ${result.status} (version ${result.version}, source sha256 ${result.sourceSha256})\n`,
+    )
+  } catch (error) {
+    process.stderr.write(`Sandbox install proof: FAIL — ${error.message}\n`)
+    process.exitCode = 1
+  }
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) main()

package/scripts/versioning.mjs

@@ -24,6 +24,7 @@ import { execFileSync } from 'node:child_process'
 import { existsSync, readFileSync } from 'node:fs'
 import { basename, dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { mergeUnreleasedIntoVersion } from './changelog-merge.mjs'
 import {
   commitPreparedUpdates,
   prepareInventoryVersion,
@@ -471,6 +472,17 @@ switch (command) {
   case 'changelog': {
     const version = arg || getCurrentVersion()
     const date = new Date().toISOString().slice(0, 10)
+    const currentChangelog = readFileSync(CHANGELOG_PATH, 'utf-8')
+    const mergePlan = mergeUnreleasedIntoVersion(currentChangelog, version)
+    if (mergePlan) {
+      if (mergePlan.changed) {
+        commitPreparedUpdates([{ path: CHANGELOG_PATH, content: mergePlan.content }])
+        console.log(`  ✓ CHANGELOG: merged [Unreleased] into existing [v${version}]`)
+      } else {
+        console.log(`  ✓ CHANGELOG: [Unreleased] is empty; [v${version}] unchanged`)
+      }
+      break
+    }
     const changelogPlan = prepareUnreleased(version, date)
     if (changelogPlan.changed) {
       commitPreparedUpdates([{ path: CHANGELOG_PATH, content: changelogPlan.content }])
@@ -492,7 +504,7 @@ Commands:
                        --beta: advance the committed X.Y.Z-beta.N line and
                        promote [Unreleased] → [vX.Y.Z-beta.N] in CHANGELOG
   beta                 Alias for 'apply --beta'
-  changelog [version]  Promote [Unreleased] → [vX.Y.Z] without bumping
+  changelog [version]  Promote [Unreleased], or merge into an existing version section
 
 Release flow (stable):
   1. node scripts/versioning.mjs apply [minor]