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

package/scripts/package-evidence.mjs

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+/** Build and verify the single immutable npm package evidence artifact. */
+
+import { execFileSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import { tmpdir } from 'node:os'
+import { isAbsolute, join } from 'node:path'
+import { validateInventory } from './manifest-inventory.mjs'
+
+const CI_ARGS = ['ci', '--ignore-scripts', '--omit=dev', '--no-audit', '--no-fund']
+const REQUIRED_PAYLOAD = [
+  'package/package.json',
+  'package/plugin.json',
+  'package/pyproject.toml',
+  'package/src/plugins/tui/package.json',
+  'package/src/plugins/tui/package-lock.json',
+  'package/src/plugin.ts',
+  'package/src/plugin-v2.ts',
+  'package/src/pantheon/v2-bridge.ts',
+  'package/src/plugins/tui/dist/tui.js',
+  'package/src/plugins/tui/dist/server.js',
+  'package/bin/pantheon-init.mjs',
+  'package/scripts/doctor.mjs',
+  'package/.pantheon/code-mode/compress-inline.py',
+]
+
+function fail(message) {
+  throw new Error(message)
+}
+
+function resolveTargetSha(root, supplied) {
+  const raw =
+    supplied ?? execFileSync('git', ['rev-parse', 'HEAD'], { cwd: root, encoding: 'utf8' })
+  const sha = String(raw).trim().toLowerCase()
+  if (!/^[0-9a-f]{40}$/.test(sha))
+    fail('target SHA must be a full lowercase 40-character hexadecimal SHA')
+  return sha
+}
+
+function createOutputDirectory(outputDir) {
+  const directory = outputDir ?? mkdtempSync(join(tmpdir(), 'pantheon-package-evidence-'))
+  mkdirSync(directory, { recursive: true })
+  if (readdirSync(directory).length !== 0) fail(`output directory must be empty: ${directory}`)
+  return { directory }
+}
+
+function packOnce(root, outputDir) {
+  const raw = execFileSync(
+    'npm',
+    ['pack', '--ignore-scripts', '--json', '--pack-destination', outputDir],
+    { cwd: root, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 },
+  )
+  let result
+  try {
+    result = JSON.parse(raw)
+  } catch (error) {
+    fail(`npm pack returned malformed JSON: ${error.message}`)
+  }
+  if (!Array.isArray(result) || result.length !== 1 || typeof result[0]?.filename !== 'string') {
+    fail('npm pack must produce exactly one JSON result')
+  }
+  const tgzFiles = readdirSync(outputDir).filter((name) => name.endsWith('.tgz'))
+  if (tgzFiles.length !== 1)
+    fail(`package evidence requires exactly one .tgz, found ${tgzFiles.length}`)
+  if (tgzFiles[0] !== result[0].filename)
+    fail('npm pack result does not identify the sole .tgz artifact')
+  return join(outputDir, tgzFiles[0])
+}
+
+function validateArchiveEntries(tarball) {
+  const listing = execFileSync('tar', ['-tzf', tarball], { encoding: 'utf8' })
+  const entries = listing.split('\n').filter(Boolean)
+  if (entries.length === 0) fail('package tarball is empty')
+  for (const entry of entries) {
+    const normalized = entry.replace(/\/$/, '')
+    const parts = normalized.split('/')
+    if (
+      isAbsolute(normalized) ||
+      normalized.includes('\\') ||
+      parts.includes('..') ||
+      (!normalized.startsWith('package/') && normalized !== 'package')
+    ) {
+      fail(`unsafe package archive entry: ${entry}`)
+    }
+  }
+  const detailed = execFileSync('tar', ['-tvzf', tarball], { encoding: 'utf8' })
+  for (const line of detailed.split('\n').filter(Boolean)) {
+    if (/^[lh]/i.test(line)) fail(`package archive contains a link entry: ${line}`)
+  }
+  return new Set(entries)
+}
+
+function extractSafely(tarball, workDir) {
+  const extractionRoot = join(workDir, 'extract')
+  mkdirSync(extractionRoot)
+  validateArchiveEntries(tarball)
+  execFileSync(
+    'tar',
+    ['-xzf', tarball, '--directory', extractionRoot, '--no-same-owner', '--no-same-permissions'],
+    { encoding: 'utf8' },
+  )
+  const realRoot = realpathSync(extractionRoot)
+  const walk = (current) => {
+    const stat = lstatSync(current)
+    if (stat.isSymbolicLink()) fail(`package archive extraction contains a symlink: ${current}`)
+    const resolved = realpathSync(current)
+    if (resolved !== realRoot && !resolved.startsWith(`${realRoot}/`)) {
+      fail(`package archive extraction escaped its temporary directory: ${current}`)
+    }
+    if (stat.isDirectory()) for (const name of readdirSync(current)) walk(join(current, name))
+  }
+  walk(extractionRoot)
+  return join(extractionRoot, 'package')
+}
+
+function validatePayload(packageRoot, inventory) {
+  for (const relativePath of REQUIRED_PAYLOAD) {
+    const path = join(packageRoot, relativePath.replace(/^package\//, ''))
+    if (!existsSync(path) || !lstatSync(path).isFile())
+      fail(`required package payload is missing: ${relativePath}`)
+  }
+  for (const document of inventory.documents) {
+    const { entry, path: sourcePath } = document
+    const packagedPath = join(packageRoot, entry.file)
+    if (entry.role === 'lock' && entry.file === 'package-lock.json' && !existsSync(packagedPath)) {
+      // npm-packlist excludes the package root lockfile by policy. It remains
+      // validated below as source evidence, but is not fabricated in the tgz.
+      continue
+    }
+    if (!existsSync(packagedPath) || !lstatSync(packagedPath).isFile())
+      fail(`versioned package payload is missing: package/${entry.file}`)
+    if (sha256(sourcePath) !== sha256(packagedPath))
+      fail(`published package payload differs from source: ${entry.file}`)
+  }
+}
+
+function collectLockfileEvidence(inventory, entries, packageRoot) {
+  return inventory.documents
+    .filter(({ entry }) => entry.role === 'lock')
+    .map(({ entry, data, path: sourcePath }) => {
+      const archivePath = `package/${entry.file}`
+      const packagedPath = join(packageRoot, entry.file)
+      const publishedInTarball = entries.has(archivePath)
+      return {
+        file: entry.file,
+        sourceSha256: sha256(sourcePath),
+        publishedSha256: publishedInTarball ? sha256(packagedPath) : null,
+        sourceName: data.name,
+        sourceVersion: data.version,
+        lockfileVersion: data.lockfileVersion,
+        parity: 'validated-against-manifest',
+        publishedInTarball,
+      }
+    })
+}
+
+function installProductionDependencies(root) {
+  // The root package-lock.json is source evidence only: npm-packlist omits it
+  // from the root of an npm package, so root ci must validate the source tree.
+  execFileSync('npm', CI_ARGS, { cwd: root, stdio: 'inherit' })
+  execFileSync('npm', CI_ARGS, {
+    cwd: join(root, 'src', 'plugins', 'tui'),
+    stdio: 'inherit',
+  })
+}
+
+function sha256(path) {
+  return createHash('sha256').update(readFileSync(path)).digest('hex')
+}
+
+export function createPackageEvidence(root, { outputDir, targetSha } = {}) {
+  const inventory = validateInventory(root)
+  const sha = resolveTargetSha(root, targetSha)
+  const output = createOutputDirectory(outputDir)
+  let workDir
+  try {
+    const tarball = packOnce(root, output.directory)
+    workDir = mkdtempSync(join(tmpdir(), 'pantheon-package-evidence-check-'))
+    const entries = validateArchiveEntries(tarball)
+    const packageRoot = extractSafely(tarball, workDir)
+    validatePayload(packageRoot, inventory)
+    installProductionDependencies(root)
+    const digest = sha256(tarball)
+    if (!/^[0-9a-f]{64}$/.test(digest)) fail('tarball SHA-256 is not lowercase 64-hex')
+    const metadata = {
+      version: inventory.sourceVersion,
+      targetSha: sha,
+      tarballSha256: digest,
+      tarball: tarball.split('/').at(-1),
+      lockfilePolicy: {
+        rootPackageLockfile: entries.has('package/package-lock.json')
+          ? 'published-by-npm-pack'
+          : 'omitted-by-npm-pack',
+        note: entries.has('package/package-lock.json')
+          ? 'npm pack published the root package-lock.json; lockfile parity is validated and recorded as source evidence, while tarball validation covers only the payload npm pack publishes.'
+          : 'npm pack omits the package root package-lock.json by policy; lockfile parity is validated and recorded as source evidence, while tarball validation covers only the payload npm pack publishes.',
+      },
+      lockfileEvidence: collectLockfileEvidence(inventory, entries, packageRoot),
+    }
+    writeFileSync(join(output.directory, 'metadata.json'), `${JSON.stringify(metadata, null, 2)}\n`)
+    writeFileSync(join(output.directory, 'version'), `${metadata.version}\n`)
+    writeFileSync(join(output.directory, 'target-sha'), `${metadata.targetSha}\n`)
+    writeFileSync(join(output.directory, 'tarball-sha256'), `${metadata.tarballSha256}\n`)
+    return { ...metadata, outputDir: output.directory, tarball }
+  } catch (error) {
+    rmSync(output.directory, { recursive: true, force: true })
+    throw error
+  } finally {
+    if (workDir) rmSync(workDir, { recursive: true, force: true })
+  }
+}
+
+function parseOptions(args) {
+  const options = {}
+  for (const arg of args) {
+    const match = /^--(output-dir|target-sha)=(.*)$/.exec(arg)
+    if (!match) fail(`unsupported package evidence option: ${arg}`)
+    options[match[1] === 'output-dir' ? 'outputDir' : 'targetSha'] = match[2]
+  }
+  return options
+}
+
+if (process.argv[1]?.endsWith('package-evidence.mjs')) {
+  try {
+    const evidence = createPackageEvidence(process.cwd(), parseOptions(process.argv.slice(2)))
+    console.log(JSON.stringify(evidence))
+  } catch (error) {
+    console.error(`package-evidence: ${error.message}`)
+    process.exit(1)
+  }
+}

package/scripts/probe-context-rehydrate.mjs

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process'
+/**
+ * Offline/ambiental probe for context_rehydrate and context_session_summary.
+ *
+ * The Python child imports the installed persistence server and exercises the
+ * real FastMCP tools against a temporary SQLite database. No OpenCode command,
+ * network call, LLM, or user database is involved. Missing package/runtime is
+ * NOT_TESTED/AMBIENTAL rather than a false PASS.
+ */
+import { existsSync, mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const requestedVersion = valueFor('--version')
+const jsonOutput = process.argv.includes('--json')
+const runtime = fileURLToPath(new URL('./mcp_persistence_server.py', import.meta.url))
+
+function valueFor(name) {
+  const index = process.argv.indexOf(name)
+  return index >= 0 ? process.argv[index + 1] : undefined
+}
+
+function emit(status, detail, checks = []) {
+  const result = { status, version: requestedVersion, detail, checks }
+  if (jsonOutput) process.stdout.write(JSON.stringify(result))
+  else process.stdout.write(`${status}: ${detail}\n`)
+  if (status === 'FAIL') process.exitCode = 1
+}
+
+function unavailable(detail) {
+  emit('NOT_TESTED', detail)
+}
+
+function pythonCandidates() {
+  const venvPython = process.env.HOME
+    ? join(process.env.HOME, '.config', 'opencode', '.venv', 'bin', 'python')
+    : undefined
+  return [process.env.PANTHEON_PYTHON, venvPython, 'python3'].filter(Boolean)
+}
+
+const PYTHON_HARNESS = `
+import asyncio
+import importlib.util
+import json
+import os
+import sys
+from pathlib import Path
+
+runtime_path = Path(sys.argv[1]).resolve()
+db_root = Path(sys.argv[2]).resolve()
+sys.path.insert(0, str(runtime_path.parent))
+sys.argv = [str(runtime_path), "--global-db", str(db_root / "global.db"),
+            "--project-db", str(db_root / "project.db")]
+
+spec = importlib.util.spec_from_file_location("probe_mcp_persistence", runtime_path)
+if spec is None or spec.loader is None:
+    raise RuntimeError("could not load persistence runtime")
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)
+
+
+async def call(name, arguments):
+    result = await module.mcp.call_tool(name, arguments)
+    if isinstance(result, tuple):
+        structured = result[1]
+        if structured is not None:
+            if isinstance(structured, dict) and "result" in structured:
+                return structured["result"]
+            return structured
+        result = result[0]
+    if isinstance(result, dict):
+        return result
+    if not result:
+        return None
+    text = getattr(result[0], "text", str(result[0]))
+    try:
+        return json.loads(text)
+    except (TypeError, ValueError, json.JSONDecodeError):
+        return text
+
+
+async def main():
+    checks = []
+    slug = "context-rehydrate-probe"
+    session_id = "synthetic-session"
+    checkpoint = {
+        "version": 1,
+        "goal": {"id": "probe-goal", "objective": "verify context recovery",
+                 "status": "in_progress"},
+        "phase": {"current": 2, "total": 3, "name": "offline validation"},
+        "delegations": {"in_flight": [{"alias": "apo-probe", "agent": "apollo",
+                                         "task_id": "probe-task"}]},
+    }
+    tail = ["phase 1 complete", "phase 2 payload validated"]
+
+    # context_save creates the real session-qualified latest pointer. Keeping
+    # tail under its own key also tests the runtime's latest/tail fallback.
+    await call("context_save", {"slug": slug, "key": "tail",
+                                 "content": json.dumps(tail),
+                                 "session_id": session_id})
+    await call("context_save", {"slug": slug, "key": "phase:2",
+                                 "content": json.dumps(checkpoint),
+                                 "session_id": session_id})
+    latest = await call("context_get", {"slug": slug, "key": "latest",
+                                         "session_id": session_id})
+    stored_tail = await call("context_get", {"slug": slug, "key": "tail",
+                                              "session_id": session_id})
+    if latest is None or stored_tail is None:
+        raise AssertionError("synthetic latest/tail checkpoint payload is null")
+    checks.append("synthetic latest/tail/goal/phase/delegation checkpoint: PASS")
+
+    os.environ.pop("PANTHEON_COMPACTION", None)
+    os.environ.pop("PANTHEON_SESSION_END_SUMMARY", None)
+    blocks = await call("context_rehydrate", {"slug": slug})
+    summary = await call("context_session_summary", {"slug": slug})
+    if not isinstance(blocks, list) or not blocks:
+        raise AssertionError("context_rehydrate returned a null/empty payload")
+    if not isinstance(summary, str) or not summary:
+        raise AssertionError("context_session_summary returned a null/empty payload")
+    for fragment in ("verify context recovery", "phase 2/3", "apo-probe",
+                     "phase 2 payload validated"):
+        if not any(fragment in block for block in blocks) and fragment not in summary:
+            raise AssertionError(f"payload is missing {fragment!r}")
+    checks.append("context_rehydrate non-null payload: PASS")
+    checks.append("context_session_summary non-null payload: PASS")
+
+    missing_blocks = await call("context_rehydrate", {"slug": "probe-absent"})
+    missing_summary = await call("context_session_summary", {"slug": "probe-absent"})
+    if missing_blocks is not None or missing_summary is not None:
+        raise AssertionError("absent checkpoint must return null payloads")
+    checks.append("absence returns null: PASS")
+
+    expired_slug = "context-expired-probe"
+    await call("context_save", {"slug": expired_slug, "key": "phase:1",
+                                 "content": json.dumps(checkpoint), "ttl": -1,
+                                 "session_id": session_id})
+    expired_blocks = await call("context_rehydrate", {"slug": expired_slug})
+    expired_summary = await call("context_session_summary", {"slug": expired_slug})
+    if expired_blocks is not None or expired_summary is not None:
+        raise AssertionError("expired checkpoint must return null payloads")
+    checks.append("expiration returns null: PASS")
+
+    invalid_slug = "context-invalid-probe"
+    await call("context_save", {"slug": invalid_slug, "key": "phase:1",
+                                 "content": "not-json", "session_id": session_id})
+    invalid_blocks = await call("context_rehydrate", {"slug": invalid_slug})
+    invalid_summary = await call("context_session_summary", {"slug": invalid_slug})
+    if invalid_blocks is not None or invalid_summary is not None:
+        raise AssertionError("invalid checkpoint must return null payloads")
+    checks.append("invalid payload returns null: PASS")
+
+    os.environ["PANTHEON_COMPACTION"] = "off"
+    switched_blocks = await call("context_rehydrate", {"slug": slug})
+    if switched_blocks is not None:
+        raise AssertionError("PANTHEON_COMPACTION=off must return null")
+    os.environ.pop("PANTHEON_COMPACTION", None)
+    os.environ["PANTHEON_SESSION_END_SUMMARY"] = "off"
+    switched_summary = await call("context_session_summary", {"slug": slug})
+    if switched_summary is not None:
+        raise AssertionError("PANTHEON_SESSION_END_SUMMARY=off must return null")
+    checks.append("kill-switches return null: PASS")
+    print(json.dumps({"checks": checks}))
+
+
+asyncio.run(main())
+`
+
+async function main() {
+  if (requestedVersion !== 'v1' && requestedVersion !== 'v2') {
+    emit('FAIL', 'usage: --version v1|v2 [--json]')
+    return
+  }
+  if (!existsSync(runtime)) {
+    unavailable('installed package does not include mcp_persistence_server.py')
+    return
+  }
+
+  const root = mkdtempSync(join(tmpdir(), 'pantheon-context-probe-'))
+  const dbRoot = join(root, 'db')
+  const python = pythonCandidates().find((candidate) =>
+    candidate.includes('/') ? existsSync(candidate) : true,
+  )
+  if (!python) {
+    rmSync(root, { recursive: true, force: true })
+    unavailable('Python persistence runtime is not available')
+    return
+  }
+
+  try {
+    const child = spawnSync(python, ['-c', PYTHON_HARNESS, runtime, dbRoot], {
+      encoding: 'utf8',
+      timeout: 30000,
+      env: process.env,
+    })
+    if (child.error) {
+      const detail = child.error instanceof Error ? child.error.message : String(child.error)
+      if (/EACCES|permission denied|not found/i.test(detail)) {
+        emit('AMBIENTAL', `persistence runtime unavailable: ${detail}`)
+      } else {
+        unavailable(`persistence runtime unavailable: ${detail}`)
+      }
+      return
+    }
+    if (child.signal === 'SIGTERM') {
+      emit('AMBIENTAL', 'persistence probe timed out after 30s')
+      return
+    }
+    if (child.status !== 0) {
+      const detail = `${child.stderr || child.stdout || 'persistence probe failed'}`.trim()
+      if (
+        /No module named|ModuleNotFoundError|can't open file|No such file|importerror/i.test(detail)
+      ) {
+        unavailable(`persistence runtime unavailable: ${detail.slice(0, 320)}`)
+      } else {
+        emit('FAIL', `offline persistence checks failed: ${detail.slice(0, 320)}`)
+      }
+      return
+    }
+
+    const lines = child.stdout.trim().split('\n').filter(Boolean)
+    const payload = JSON.parse(lines.at(-1) || '')
+    if (!Array.isArray(payload.checks) || payload.checks.length < 6) {
+      emit('FAIL', 'offline persistence probe returned incomplete checks')
+      return
+    }
+    emit(
+      'PASS',
+      'offline synthetic persistence checks passed; no LLM or user DB was used',
+      payload.checks,
+    )
+  } catch (error) {
+    emit('FAIL', error instanceof Error ? error.message : String(error))
+  } finally {
+    rmSync(root, { recursive: true, force: true })
+  }
+}
+
+await main()