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

package/scripts/install/plugin.mjs

@@ -0,0 +1,139 @@
+/**
+ * plugin.mjs — Plugin installation utilities for the OpenCode installer
+ */
+
+import { execSync } from 'node:child_process'
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { warning } from './cli-ui.mjs'
+import { writeIfChanged } from './shared.mjs'
+
+/**
+ * Install a plugin from source to destination.
+ * @param {string} srcDir - Source plugin directory (e.g. ROOT/src/plugins/tui)
+ * @param {string} dstDir - Destination plugin directory
+ * @param {object} [options]
+ * @param {boolean} [options.dryRun=false] - If true, don't write files
+ * @param {boolean} [options.clean=false] - If true, remove existing before install
+ * @returns {{ created: number, skipped: number, errors: number }}
+ */
+export function installPlugin(srcDir, dstDir, { dryRun = false, clean = false } = {}) {
+  const result = { created: 0, skipped: 0, errors: 0 }
+
+  if (!dryRun) mkdirSync(dstDir, { recursive: true })
+  if (clean && existsSync(dstDir) && !dryRun) {
+    rmSync(dstDir, { recursive: true, force: true })
+    mkdirSync(dstDir, { recursive: true })
+  }
+  if (!dryRun) mkdirSync(join(dstDir, 'dist'), { recursive: true })
+
+  // Copy src/index.tsx -> index.tsx
+  const srcIdx = join(srcDir, 'src', 'index.tsx')
+  if (existsSync(srcIdx)) {
+    const idxStatus = writeIfChanged(join(dstDir, 'index.tsx'), readFileSync(srcIdx, 'utf8'), dryRun)
+    if (idxStatus === 'created') result.created++
+    else result.skipped++
+  }
+
+  // Copy dist/* files
+  const distSrc = join(srcDir, 'dist')
+  if (existsSync(distSrc)) {
+    for (const f of readdirSync(distSrc)) {
+      const c = readFileSync(join(distSrc, f), 'utf8')
+      writeIfChanged(join(dstDir, 'dist', f), c, dryRun)
+      result.created++
+    }
+  }
+
+  // Copy package.json
+  const pkgSrc = join(srcDir, 'package.json')
+  if (existsSync(pkgSrc)) {
+    const pkgStatus = writeIfChanged(join(dstDir, 'package.json'), readFileSync(pkgSrc, 'utf8'), dryRun)
+    if (pkgStatus === 'created') result.created++
+    else result.skipped++
+  }
+
+  // Install plugin dependencies (@opentui/core, @opentui/solid, solid-js)
+  if (!dryRun) {
+    try {
+      execSync('npm install --omit=dev --no-audit', { cwd: dstDir, stdio: 'pipe' })
+    } catch (e) {
+      warning('Failed to install TUI plugin dependencies: ' + e.message)
+      result.errors++
+    }
+  }
+
+  return result
+}
+
+/**
+ * Install plugin dependencies via npm.
+ * @param {string} pluginDir - Directory containing package.json
+ * @param {object} [options]
+ * @param {boolean} [options.dryRun=false] - If true, skip npm install
+ */
+export function installPluginDependencies(pluginDir, { dryRun = false } = {}) {
+  if (dryRun) return
+  try {
+    execSync('npm install --omit=dev --no-audit', { cwd: pluginDir, stdio: 'pipe' })
+  } catch (e) {
+    warning('Failed to install plugin dependencies: ' + e.message)
+  }
+}
+
+/**
+ * Register a plugin in tui.json.
+ * @param {string} tuiJsonPath - Path to tui.json
+ * @param {string} pluginId - Plugin identifier string
+ * @param {object} [options]
+ * @param {boolean} [options.dryRun=false]
+ * @returns {'created'|'skipped'}
+ */
+export function registerPlugin(tuiJsonPath, pluginId, { dryRun = false } = {}) {
+  let tuiConfig = { plugin: [] }
+  if (existsSync(tuiJsonPath)) {
+    try {
+      tuiConfig = JSON.parse(readFileSync(tuiJsonPath, 'utf8'))
+    } catch {
+      /* use default */
+    }
+  }
+  if (!Array.isArray(tuiConfig.plugin)) {
+    tuiConfig.plugin = []
+  }
+  if (!tuiConfig.plugin.includes(pluginId)) {
+    tuiConfig.plugin.push(pluginId)
+  }
+  const tuiContent = `${JSON.stringify(tuiConfig, null, 2)}\n`
+  return writeIfChanged(tuiJsonPath, tuiContent, dryRun)
+}
+
+/**
+ * Unregister stale plugin references from tui.json.
+ * @param {string} tuiJsonPath - Path to tui.json
+ * @param {string} pluginId - Plugin to unregister
+ * @param {object} [options]
+ * @param {boolean} [options.dryRun=false]
+ * @returns {'created'|'skipped'}
+ */
+export function unregisterPlugin(tuiJsonPath, pluginId, { dryRun = false } = {}) {
+  let tuiConfig = { plugin: [] }
+  if (existsSync(tuiJsonPath)) {
+    try {
+      tuiConfig = JSON.parse(readFileSync(tuiJsonPath, 'utf8'))
+    } catch {
+      /* use default */
+    }
+  }
+  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`]
+  for (const stale of staleRefs) {
+    const idx = tuiConfig.plugin.indexOf(stale)
+    if (idx !== -1) tuiConfig.plugin.splice(idx, 1)
+  }
+  const tuiContent = `${JSON.stringify(tuiConfig, null, 2)}\n`
+  return writeIfChanged(tuiJsonPath, tuiContent, dryRun)
+}

package/scripts/install/state.mjs

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+/**
+ * state.mjs — State manifest for Pantheon installations (schema v2)
+ *
+ * Manages the install-state.json manifest with version tracking,
+ * component state, and applied migration history.
+ *
+ * Schema v2:
+ *   {
+ *     "schema_version": 2,
+ *     "pantheon_version": "1.1.1",
+ *     "previous_version": "1.1.0",
+ *     "updated_at": "2026-07-26T10:30:00Z",
+ *     "migration_checkpoint": null,
+ *     "applied_migrations": [
+ *       { "from": "1.1.0", "to": "1.1.1", "applied_at": "2026-07-26T10:30:00Z", "status": "completed" }
+ *     ],
+ *     "components": {
+ *       "agents": { "version": 1, "status": "installed" },
+ *       "skills": { "version": 1, "status": "installed" },
+ *       "plugins": { "version": 1, "status": "installed" },
+ *       "runtime": { "version": 1, "status": "installed" }
+ *     }
+ *   }
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+const STATE_FILE = 'install-state.json'
+const STATE_DIR = '.pantheon'
+
+/**
+ * Create a fresh v2 state object for a new install.
+ * @param {string} version - Pantheon version string
+ * @returns {object} v2 state
+ */
+export function createInitialState(version) {
+  return {
+    schema_version: 2,
+    pantheon_version: version || '0.0.0',
+    previous_version: null,
+    updated_at: new Date().toISOString(),
+    migration_checkpoint: null,
+    applied_migrations: [],
+    components: {
+      agents: { version: 1, status: 'pending' },
+      skills: { version: 1, status: 'pending' },
+      plugins: { version: 1, status: 'pending' },
+      runtime: { version: 1, status: 'pending' },
+    },
+  }
+}
+
+/**
+ * Read install-state.json from a target directory.
+ * Backward-compatible with v1 schema (auto-upgrades on read).
+ * @param {string} target - Installation directory
+ * @returns {object|null} v2 state object, or null if not found
+ */
+export function readState(target) {
+  const stateFile = join(target, STATE_DIR, STATE_FILE)
+  if (!existsSync(stateFile)) return null
+  try {
+    const raw = JSON.parse(readFileSync(stateFile, 'utf8'))
+    return normalizeState(raw)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Detect whether the raw state is v1 format (pre-schema_version).
+ * v1 state has pantheon_version (or version) but no schema_version.
+ * @param {object} state
+ * @returns {boolean}
+ */
+export function isV1State(state) {
+  if (!state || typeof state !== 'object') return false
+  return !state.schema_version && (!!state.pantheon_version || !!state.version)
+}
+
+/**
+ * Upgrade a v1 state to v2 schema.
+ * Preserves all existing fields, adds defaults for new ones.
+ * @param {object} state - v1 state object
+ * @returns {object} v2 state object
+ */
+export function upgradeStateV1toV2(state) {
+  const now = new Date().toISOString()
+  return {
+    schema_version: 2,
+    pantheon_version: state.pantheon_version || state.version || 'unknown',
+    previous_version: state.previous_version || null,
+    updated_at: state.updated_at || now,
+    migration_checkpoint: null,
+    applied_migrations: Array.isArray(state.applied_migrations) ? state.applied_migrations : [],
+    components: state.components && typeof state.components === 'object' ? state.components : {
+      agents: { version: 1, status: 'installed' },
+      skills: { version: 1, status: 'installed' },
+      plugins: { version: 1, status: 'unknown' },
+      runtime: { version: 1, status: 'unknown' },
+    },
+  }
+}
+
+/**
+ * Normalize any state to v2 (handles v1 → v2 upgrade).
+ * @param {object} state
+ * @returns {object|null}
+ */
+function normalizeState(state) {
+  if (!state || typeof state !== 'object') return null
+  if (isV1State(state)) return upgradeStateV1toV2(state)
+  if (!state.schema_version || state.schema_version < 2) return upgradeStateV1toV2(state)
+  return state
+}
+
+/**
+ * Write state to target's install-state.json (always v2 format).
+ * @param {string} target - Installation directory
+ * @param {object} state - v2 state object
+ */
+export function writeState(target, state) {
+  const stateDir = join(target, STATE_DIR)
+  if (!existsSync(stateDir)) {
+    mkdirSync(stateDir, { recursive: true })
+  }
+  const stateFile = join(stateDir, STATE_FILE)
+  state.updated_at = new Date().toISOString()
+  state.schema_version = 2
+  writeFileSync(stateFile, `${JSON.stringify(state, null, 2)}\n`, 'utf8')
+}
+
+/**
+ * Check whether install-state.json exists in target.
+ * @param {string} target
+ * @returns {boolean}
+ */
+export function hasState(target) {
+  return existsSync(join(target, STATE_DIR, STATE_FILE))
+}
+
+/**
+ * Add a migration record to the applied_migrations array.
+ * @param {object} state
+ * @param {string} fromVersion
+ * @param {string} toVersion
+ * @param {string} [status='completed']
+ */
+export function addMigrationRecord(state, fromVersion, toVersion, status = 'completed') {
+  if (!Array.isArray(state.applied_migrations)) {
+    state.applied_migrations = []
+  }
+  state.applied_migrations.push({
+    from: fromVersion,
+    to: toVersion,
+    applied_at: new Date().toISOString(),
+    status,
+  })
+}
+
+/**
+ * Update the pantheon_version and previous_version.
+ * @param {object} state
+ * @param {string} newVersion
+ */
+export function updateVersion(state, newVersion) {
+  state.previous_version = state.pantheon_version || null
+  state.pantheon_version = newVersion
+}
+
+/**
+ * Get a component's state object.
+ * @param {object} state
+ * @param {string} component - Component name (agents, skills, plugins, runtime)
+ * @returns {{ version: number, status: string }|null}
+ */
+export function getComponentState(state, component) {
+  if (!state.components) return null
+  return state.components[component] || null
+}
+
+/**
+ * Set a component's version and status.
+ * @param {object} state
+ * @param {string} component
+ * @param {number} version
+ * @param {string} status
+ */
+export function setComponentState(state, component, version, status) {
+  if (!state.components) state.components = {}
+  state.components[component] = { version, status }
+}

package/src/plugins/tui/package.json

@@ -18,15 +18,15 @@
   "peerDependencies": {
     "@opencode-ai/plugin": ">=1.14.0",
     "@opencode-ai/sdk": ">=1.14.0",
-    "@opentui/core": ">=0.2.0",
-    "@opentui/solid": ">=0.2.0",
+    "@opentui/core": ">=0.4.5",
+    "@opentui/solid": ">=0.4.5",
     "solid-js": ">=1.9.0"
   },
   "devDependencies": {},
   "dependencies": {
     "@opencode-ai/plugin": "^1.14.0",
-    "@opentui/core": "^0.2.0",
-    "@opentui/solid": "^0.2.0",
+    "@opentui/core": "^0.4.5",
+    "@opentui/solid": "^0.4.5",
     "solid-js": "^1.9.0"
   }
 }