pantheon-opencode 1.1.1-beta.3 → 1.1.1-beta.4

package/scripts/install/migrate.mjs

@@ -8,9 +8,10 @@
  *   node scripts/install/migrate.mjs --target ~/.config/opencode --force
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { readState, writeState, createInitialState } from './state.mjs'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const ROOT = join(__dirname, '..', '..')
@@ -33,16 +34,9 @@ function readPackageVersion() {
  * @returns {string|null} - version string or null for fresh install
  */
 export function detectVersion(target) {
-  const stateFile = join(target, '.pantheon', 'install-state.json')
-  if (existsSync(stateFile)) {
-    try {
-      const state = JSON.parse(readFileSync(stateFile, 'utf8'))
-      return state.pantheon_version || state.version || 'unknown'
-    } catch {
-      /* corrupted state — treat as unknown */
-    }
-  }
-  return null // fresh install
+  const state = readState(target)
+  if (state) return state.pantheon_version || state.version || 'unknown'
+  return null
 }
 
 /**
@@ -96,9 +90,42 @@ export function runMigrations(target, currentVersion, { dryRun = false } = {}) {
     semver[2] = 1
   }
 
+  // ── Migration: v3.19.1 → v3.19.2 ──────────────────────────────────
+  // Upgrade state schema from v1 to v2
+  if (semver && lt(semver, [3, 19, 2])) {
+    applied.push({
+      from: formatSemver(semver),
+      to: '3.19.2',
+      description: 'Upgrade install state schema to v2 with component tracking',
+    })
+    semver[0] = 3
+    semver[1] = 19
+    semver[2] = 2
+  }
+
   // ── Write updated state ───────────────────────────────────────────
   if (applied.length > 0 && !dryRun) {
-    writeInstallState(target, formatSemver(semver))
+    const newVersion = formatSemver(semver)
+    let state = readState(target)
+    if (!state) state = createInitialState(newVersion)
+    state.pantheon_version = newVersion
+    for (const m of applied) {
+      state.applied_migrations.push({
+        from: m.from,
+        to: m.to,
+        applied_at: new Date().toISOString(),
+        status: 'completed',
+      })
+    }
+    if (!state.components) {
+      state.components = {
+        agents: { version: 1, status: 'installed' },
+        skills: { version: 1, status: 'installed' },
+        plugins: { version: 1, status: 'installed' },
+        runtime: { version: 1, status: 'installed' },
+      }
+    }
+    writeState(target, state)
   }
 
   return {
@@ -107,20 +134,150 @@ export function runMigrations(target, currentVersion, { dryRun = false } = {}) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Checkpoint system for crash recovery
+// ---------------------------------------------------------------------------
+
+const CHECKPOINT_FILE = '.migration-checkpoint'
+const STATE_DIR = '.pantheon'
+
+/**
+ * Read the migration checkpoint file if it exists.
+ * @param {string} target
+ * @returns {object|null}
+ */
+export function readCheckpoint(target) {
+  const cpFile = join(target, STATE_DIR, CHECKPOINT_FILE)
+  if (!existsSync(cpFile)) return null
+  try {
+    return JSON.parse(readFileSync(cpFile, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Write a migration checkpoint before starting migrations.
+ * @param {string} target
+ * @param {string} fromVersion
+ * @param {string} toVersion
+ * @param {string[]} steps - Ordered list of step names
+ * @returns {object} The checkpoint object
+ */
+export function writeCheckpoint(target, fromVersion, toVersion, steps) {
+  const cpDir = join(target, STATE_DIR)
+  if (!existsSync(cpDir)) mkdirSync(cpDir, { recursive: true })
+  const cpFile = join(cpDir, CHECKPOINT_FILE)
+  const checkpoint = {
+    from: fromVersion,
+    to: toVersion,
+    started_at: new Date().toISOString(),
+    steps_completed: [],
+    steps_pending: [...steps],
+  }
+  writeFileSync(cpFile, `${JSON.stringify(checkpoint, null, 2)}\n`, 'utf8')
+  return checkpoint
+}
+
+/**
+ * Advance the checkpoint: mark a step as completed and remove from pending.
+ * @param {string} target
+ * @param {string} stepName
+ * @returns {object|null} Updated checkpoint, or null if none exists
+ */
+export function advanceCheckpoint(target, stepName) {
+  const cp = readCheckpoint(target)
+  if (!cp) return null
+  cp.steps_completed.push(stepName)
+  cp.steps_pending = cp.steps_pending.filter((s) => s !== stepName)
+  const cpFile = join(target, STATE_DIR, CHECKPOINT_FILE)
+  writeFileSync(cpFile, `${JSON.stringify(cp, null, 2)}\n`, 'utf8')
+  return cp
+}
+
+/**
+ * Remove the checkpoint file on successful completion.
+ * @param {string} target
+ */
+export function removeCheckpoint(target) {
+  const cpFile = join(target, STATE_DIR, CHECKPOINT_FILE)
+  if (existsSync(cpFile)) {
+    rmSync(cpFile, { force: true })
+  }
+}
+
+/**
+ * Resume from a pending checkpoint.
+ * Reads the checkpoint and reports what steps remain.
+ * @param {string} target
+ * @returns {object|null} The checkpoint, or null if none pending
+ */
+export function resumePendingMigration(target) {
+  const cp = readCheckpoint(target)
+  if (!cp) return null
+  console.log(`  \u{1F504} Resuming migration from checkpoint: ${cp.from} \u2192 ${cp.to}`)
+  console.log(`     Completed: ${cp.steps_completed.join(', ') || 'none'}`)
+  console.log(`     Pending: ${cp.steps_pending.join(', ') || 'none'}`)
+  return cp
+}
+
+// ---------------------------------------------------------------------------
+// Rollback support
+// ---------------------------------------------------------------------------
+
 /**
- * Write install state with current version to target.
+ * Roll back the last completed migration for a given version.
+ * Each migration step should define a corresponding down-migration.
+ * This is a stub — actual down-migration logic should be registered
+ * in a DOWN_MIGRATIONS registry.
+ *
+ * @param {string} target
+ * @param {string} version - The version to roll back from
+ * @returns {{ success: boolean, reason?: string, migration?: object }}
  */
-function writeInstallState(target, version) {
-  const stateDir = join(target, '.pantheon')
-  const stateFile = join(stateDir, 'install-state.json')
-  if (!existsSync(stateDir)) {
-    mkdirSync(stateDir, { recursive: true })
+export function rollbackMigration(target, version) {
+  const state = readState(target)
+  if (!state) {
+    console.log('  \u26A0\uFE0F  No install state found — nothing to roll back')
+    return { success: false, reason: 'No install state' }
   }
-  const state = {
-    pantheon_version: version,
-    updated_at: new Date().toISOString(),
+
+  const migrations = state.applied_migrations || []
+  const targetMigration = migrations.find(
+    (m) => m.to === version && m.status === 'completed',
+  )
+  if (!targetMigration) {
+    console.log(`  \u26A0\uFE0F  No completed migration found for version ${version}`)
+    return { success: false, reason: 'Migration not found' }
+  }
+
+  console.log(
+    `  \u{1F504} Rolling back migration: ${targetMigration.from} \u2192 ${targetMigration.to}`,
+  )
+
+  targetMigration.status = 'rolled_back'
+  state.pantheon_version = targetMigration.from
+  writeState(target, state)
+
+  console.log(`  \u2705 Rolled back to ${targetMigration.from}`)
+  return { success: true, migration: targetMigration }
+}
+
+/**
+ * List all applied migrations from the install state.
+ * @param {string} target
+ * @returns {{ currentVersion: string|null, previousVersion: string|null, migrations: object[] }}
+ */
+export function listAppliedMigrations(target) {
+  const state = readState(target)
+  if (!state) {
+    return { currentVersion: null, previousVersion: null, migrations: [] }
+  }
+  return {
+    currentVersion: state.pantheon_version,
+    previousVersion: state.previous_version,
+    migrations: state.applied_migrations || [],
   }
-  writeFileSync(stateFile, `${JSON.stringify(state, null, 2)}\n`, 'utf8')
 }
 
 // ---------------------------------------------------------------------------
@@ -172,15 +329,38 @@ function main() {
   const target = targetIdx !== -1 ? args[targetIdx + 1] : process.cwd()
   const dryRun = args.includes('--dry-run')
   const force = args.includes('--force')
+  const list = args.includes('--list')
+
+  if (list) {
+    const history = listAppliedMigrations(target)
+    if (!history.currentVersion) {
+      console.log('  \u2139\uFE0F  No install state found in: ' + target)
+      return
+    }
+    console.log(`  Current version: ${history.currentVersion}`)
+    console.log(`  Previous version: ${history.previousVersion || 'N/A'}`)
+    console.log(`  Applied migrations: ${history.migrations.length}`)
+    for (const m of history.migrations) {
+      const icon = m.status === 'completed' ? '\u2705' : m.status === 'rolled_back' ? '\u{1F504}' : '\u26A0\uFE0F'
+      console.log(`    ${icon} ${m.from} \u2192 ${m.to} [${m.status}] (${m.applied_at})`)
+    }
+    return
+  }
+
+  const rollbackTo = args.find((a) => a.startsWith('--rollback='))?.split('=', 2)[1]
+  if (rollbackTo) {
+    rollbackMigration(target, rollbackTo)
+    return
+  }
 
   const currentVersion = detectVersion(target)
   if (!currentVersion) {
-    // Fresh install — write state and exit
     if (!dryRun) {
-      writeInstallState(target, PANTHON_VERSION)
-      console.log(`  ✅ Fresh install — state written (${PANTHON_VERSION})`)
+      const state = createInitialState(PANTHON_VERSION)
+      writeState(target, state)
+      console.log(`  \u2705 Fresh install — state written (${PANTHON_VERSION})`)
     } else {
-      console.log(`  ✅ Fresh install — would write state (${PANTHON_VERSION})`)
+      console.log(`  \u2705 Fresh install — would write state (${PANTHON_VERSION})`)
     }
     return
   }
@@ -188,19 +368,19 @@ function main() {
   console.log(`  Current version: ${currentVersion}`)
 
   if (!force && currentVersion === PANTHON_VERSION) {
-    console.log('  ⏭️  Already at latest version — no migrations needed')
+    console.log('  \u23ED\uFE0F  Already at latest version — no migrations needed')
     return
   }
 
   const migration = runMigrations(target, currentVersion, { dryRun })
 
   if (migration.applied > 0) {
-    console.log(`  ✅ Applied ${migration.applied} migration(s):`)
+    console.log(`  \u2705 Applied ${migration.applied} migration(s):`)
     for (const msg of migration.messages) {
-      console.log(`     • ${msg}`)
+      console.log(`     \u2022 ${msg}`)
     }
   } else {
-    console.log('  ⏭️  No applicable migrations')
+    console.log('  \u23ED\uFE0F  No applicable migrations')
   }
 }
 

package/scripts/install/opencode.mjs

@@ -3,17 +3,16 @@
  * opencode.mjs — OpenCode platform installer
  */
 
-import { execSync } from 'node:child_process'
 import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join, resolve } from 'node:path'
 import { healthCheck } from './health-check.mjs'
 import { detectVersion, runMigrations } from './migrate.mjs'
+import { configure, section, step, success, warning, error, info, bullet, spinner, printSummary } from './cli-ui.mjs'
 import {
   collectSkillNames,
   copyFiles,
   installSkills,
-  PLATFORM_DIR,
   parseFrontmatter,
   ROOT,
   sourceDirValid,
@@ -22,6 +21,8 @@ import {
   writeIfChanged,
 } from './shared.mjs'
 import { setupVenv } from './venv.mjs'
+import { installPlugin, registerPlugin, unregisterPlugin } from './plugin.mjs'
+import { resolveComponents } from './component.mjs'
 
 function deepClone(value) {
   return JSON.parse(JSON.stringify(value))
@@ -94,21 +95,23 @@ export function installOpenCode(
   const _subDir = isGlobal ? '' : '.opencode'
   const agentPrefix = isGlobal ? 'agents' : '.opencode/agents'
 
+  configure({ dryRun })
+
   if (isGlobal) {
-    console.log(
-      '  🌐 Global config directory detected — using flat layout (agents/, skills/, commands/)',
-    )
+    info('Global config directory detected — using flat layout (agents/, skills/, commands/)')
   }
 
   // -----------------------------------------------------------------------
   // 1. Install agents (--components agents)
   // -----------------------------------------------------------------------
   if (componentSet.has('agents')) {
+    section('\uD83D\uDCE6 Agents')
     const srcDir = join(ROOT, 'src', 'agents')
     if (!sourceDirValid(srcDir)) {
-      console.warn(`  ⚠️  Agent source directory not found: ${srcDir}`)
+      warning(`Agent source directory not found: ${srcDir}`)
       stats.errors++
     } else {
+      const agentStep = step('Installing agents')
       const dstDir = isGlobal ? join(target, 'agents') : join(target, '.opencode', 'agents')
       if (!dryRun) mkdirSync(dstDir, { recursive: true })
       if (clean && existsSync(dstDir) && !dryRun) {
@@ -120,6 +123,7 @@ export function installOpenCode(
       const { created, skipped } = copyFiles(srcDir, dstDir, dryRun)
       stats.created += created
       stats.skipped += skipped
+      agentStep(true)
     }
   }
 
@@ -139,9 +143,10 @@ export function installOpenCode(
   // 2. Install skills (--components skills)
   // -----------------------------------------------------------------------
   if (componentSet.has('skills')) {
+    section('\uD83D\uDCDA Skills')
     const skillNames = collectSkillNames()
     if (skillNames.length > 0) {
-      console.log(`  📚 Installing ${skillNames.length} skills...`)
+      const skillStep = step(`Installing ${skillNames.length} skills`)
       const dstSkillsDir = isGlobal ? join(target, 'skills') : join(target, '.opencode', 'skills')
       if (clean && existsSync(dstSkillsDir) && !dryRun) {
         const existing = readdirSync(dstSkillsDir)
@@ -158,6 +163,7 @@ export function installOpenCode(
       )
       stats.created += sCreated
       stats.skipped += sSkipped
+      skillStep(true)
     }
   }
 
@@ -165,6 +171,7 @@ export function installOpenCode(
   // 2.5 Install instructions: AGENTS.md + instructions/ (--components instructions)
   // -----------------------------------------------------------------------
   if (componentSet.has('instructions')) {
+    section('\uD83D\uDCCB Instructions')
     // AGENTS.md
     const srcAgentsMd = join(ROOT, 'AGENTS.md')
     const dstAgentsMd = join(target, 'AGENTS.md')
@@ -188,6 +195,7 @@ export function installOpenCode(
   // 2.6 Install prompts (--components prompts)
   // -----------------------------------------------------------------------
   if (componentSet.has('prompts')) {
+    section('\uD83D\uDCAC Prompts')
     const srcPrompts = join(ROOT, 'prompts')
     const dstPrompts = join(target, 'prompts')
     if (existsSync(srcPrompts)) {
@@ -201,6 +209,7 @@ export function installOpenCode(
   // 2.7 Install commands (--components commands)
   // -----------------------------------------------------------------------
   if (componentSet.has('commands')) {
+    section('\u26A1 Commands')
     const srcCmds = join(ROOT, 'commands')
     const dstCmds = isGlobal ? join(target, 'commands') : join(target, '.opencode', 'commands')
     if (existsSync(srcCmds)) {
@@ -223,10 +232,10 @@ export function installOpenCode(
         if (cfg.subagent_depth === undefined) { cfg.subagent_depth = 2; changed = true }
         if (changed && !dryRun) {
           writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + '\n')
-          console.log('    ✅ subagent_depth: 2 added to opencode.json')
+          success('subagent_depth: 2 added to opencode.json')
         }
       } catch (e) {
-        console.warn(`    ⚠️  Could not update opencode.json: ${e.message}`)
+        warning(`Could not update opencode.json: ${e.message}`)
       }
     }
   }
@@ -234,46 +243,15 @@ export function installOpenCode(
   // 2.8 Install TUI plugins (--components plugins)
   // -----------------------------------------------------------------------
   if (componentSet.has('plugins')) {
+    section('\uD83D\uDD0C Plugins')
     const srcPluginDir = join(ROOT, 'src', 'plugins', 'tui')
     const dstPluginDir = isGlobal
       ? join(target, 'plugins', 'pantheon-tui')
       : join(target, '.opencode', 'plugins', 'pantheon-tui')
-    if (!dryRun) mkdirSync(dstPluginDir, { recursive: true })
-    if (clean && existsSync(dstPluginDir) && !dryRun) {
-      rmSync(dstPluginDir, { recursive: true, force: true })
-      mkdirSync(dstPluginDir, { recursive: true })
-    }
-    if (!dryRun) mkdirSync(join(dstPluginDir, "dist"), { recursive: true })
-    // Copy src/index.tsx -> index.tsx
-    const srcIdx = join(srcPluginDir, "src", "index.tsx")
-    if (existsSync(srcIdx)) {
-      writeIfChanged(join(dstPluginDir, "index.tsx"), readFileSync(srcIdx, "utf8"), dryRun)
-      stats.created++
-    }
-    // Copy dist files
-    const distSrc = join(srcPluginDir, "dist")
-    if (existsSync(distSrc)) {
-      for (const f of readdirSync(distSrc)) {
-        const c = readFileSync(join(distSrc, f), "utf8")
-        writeIfChanged(join(dstPluginDir, "dist", f), c, dryRun)
-        stats.created++
-      }
-    }
-    // Copy package.json
-    const pkgSrc = join(srcPluginDir, "package.json")
-    if (existsSync(pkgSrc)) {
-      writeIfChanged(join(dstPluginDir, "package.json"), readFileSync(pkgSrc, "utf8"), dryRun)
-      stats.created++
-    }
-    // Install plugin dependencies (@opentui/core, @opentui/solid, solid-js)
-    if (!dryRun) {
-      try {
-        execSync('npm install --omit=dev --no-audit', { cwd: dstPluginDir, stdio: 'pipe' })
-      } catch (e) {
-        console.warn('    ⚠️  Failed to install TUI plugin dependencies:', e.message)
-      }
-    }
-
+    const pluginStats = installPlugin(srcPluginDir, dstPluginDir, { dryRun, clean })
+    stats.created += pluginStats.created
+    stats.skipped += pluginStats.skipped
+    stats.errors += pluginStats.errors
   }
 
   // -----------------------------------------------------------------------
@@ -282,30 +260,9 @@ export function installOpenCode(
   const targetTuiConfigPath = isGlobal
     ? join(target, 'tui.json')
     : join(target, '.opencode', 'tui.json')
-  let tuiConfig = { plugin: [] }
-  if (existsSync(targetTuiConfigPath)) {
-    try {
-      tuiConfig = JSON.parse(readFileSync(targetTuiConfigPath, 'utf8'))
-    } catch {
-      /* use default */
-    }
-  }
-  if (!Array.isArray(tuiConfig.plugin)) {
-    tuiConfig.plugin = []
-  }
-  // Remove stale plugin refs (old dist/tui.tsx path)
-  const staleRefs = ["plugins/pantheon-tui/dist/tui.tsx", "plugins/pantheon-tui/dist/tui.js"]
-  for (const stale of staleRefs) {
-    const idx = tuiConfig.plugin.indexOf(stale)
-    if (idx !== -1) tuiConfig.plugin.splice(idx, 1)
-  }
-  // Add our plugin if not already present
   const pluginRef = 'plugins/pantheon-tui'
-  if (!tuiConfig.plugin.includes(pluginRef)) {
-    tuiConfig.plugin.push(pluginRef)
-  }
-  const tuiContent = `${JSON.stringify(tuiConfig, null, 2)}\n`
-  const tuiStatus = writeIfChanged(targetTuiConfigPath, tuiContent, dryRun)
+  unregisterPlugin(targetTuiConfigPath, pluginRef, { dryRun })
+  const tuiStatus = registerPlugin(targetTuiConfigPath, pluginRef, { dryRun })
   if (tuiStatus === 'created') stats.created++
   else stats.skipped++
 
@@ -314,6 +271,7 @@ export function installOpenCode(
   //      MCP server scripts, code-mode scripts, tiers.json
   // -----------------------------------------------------------------------
   if (componentSet.has('runtime')) {
+    section('\u2699\uFE0F Runtime')
     const runtimeTarget = isGlobal ? target : join(target, '.opencode')
 
     // ── MCP server scripts ──
@@ -331,7 +289,7 @@ export function installOpenCode(
     for (const script of mcpScripts) {
       const src = join(srcScriptsDir, script)
       if (!existsSync(src)) {
-        console.warn(`  ⚠️  Script not found: ${src}`)
+        warning(`Script not found: ${src}`)
         stats.errors++
         continue
       }
@@ -683,9 +641,9 @@ export function installOpenCode(
     if (currentVersion) {
       const migration = runMigrations(target, currentVersion, { dryRun })
       if (migration.applied > 0) {
-        console.log(`  ✅ Applied ${migration.applied} migration(s)`)
+        success(`Applied ${migration.applied} migration(s)`)
         for (const msg of migration.messages) {
-          console.log(`     • ${msg}`)
+          bullet(msg, 1)
         }
       }
     }
@@ -696,22 +654,30 @@ export function installOpenCode(
   // -----------------------------------------------------------------------
   if (componentSet.has('runtime')) {
     try {
+      const venvSpinner = spinner('Setting up Python virtual environment')
       setupVenv(target, { dryRun, force: clean })
+      venvSpinner(true)
       const health = healthCheck(target, { dryRun })
 
       // Print health summary
-      console.log('\n  📊 Health Check:')
-      for (const p of health.passed) console.log(`    ✅ ${p.check}: ${p.detail}`)
-      for (const w of health.warnings) console.log(`    ⚠️  ${w.check}: ${w.detail}`)
-      for (const f of health.failed) console.log(`    ❌ ${f.check}: ${f.detail}`)
+      section('\uD83D\uDD0D Health Check')
+      const healthStep = step('Running health checks')
+      for (const p of health.passed) success(`${p.check}: ${p.detail}`)
+      for (const w of health.warnings) warning(`${w.check}: ${w.detail}`)
+      for (const f of health.failed) error(`${f.check}: ${f.detail}`)
 
       if (health.failed.length > 0) {
-        console.log(`  ⚠️  ${health.failed.length} check(s) failed — review above`)
+        healthStep(false)
+        warning(`${health.failed.length} check(s) failed — review above`)
         stats.errors += health.failed.length
+      } else {
+        healthStep(true)
       }
     } catch (err) {
-      console.error(`  ❌ Setup failed: ${err.message}`)
+      error(`Setup failed: ${err.message}`)
       throw err  // Fatal — abort installation
     }
   }
+
+  printSummary(target, ['opencode'], stats)
 }