peachsim 0.1.527

package/cli/commands/shell-boolean-mode.ts

@@ -0,0 +1,82 @@
+import { rnxExit } from '../run-rnx'
+import { callInBridge, createBridgeFromParsed, parseBridgeCliArgs } from '../ws-bridge'
+
+export type ShellBooleanModeAction = 'on' | 'off' | 'toggle'
+
+export interface ShellBooleanModeOptions {
+  port?: number
+  verbose?: boolean
+}
+
+export interface ShellBooleanModeConfig {
+  modeKey: string
+  displayName: string
+  actionId: string
+}
+
+export interface ShellBooleanModeResult {
+  current: boolean
+  target: boolean
+  changed: boolean
+}
+
+export function parseShellBooleanModeAction(args: string[]): ShellBooleanModeAction {
+  const action = args[0]?.toLowerCase() ?? 'toggle'
+  if (action !== 'on' && action !== 'off' && action !== 'toggle') {
+    console.error(`  unknown argument: "${action}" (expected on | off | toggle)`)
+    rnxExit(1)
+  }
+  return action
+}
+
+export async function runShellBooleanMode(
+  args: string[],
+  opts: ShellBooleanModeOptions,
+  config: ShellBooleanModeConfig,
+): Promise<ShellBooleanModeResult> {
+  const parsed = parseBridgeCliArgs(args, { port: opts.port })
+  const action = parseShellBooleanModeAction(parsed.positional)
+  const bridge = createBridgeFromParsed({ ...parsed, commandTimeoutMs: 5000 })
+  try {
+    const settings = await callInBridge<Record<string, unknown>>(
+      bridge,
+      'SootSim.bridges.settings.get',
+    )
+    const current = Boolean(settings?.[config.modeKey])
+    const target = action === 'on' ? true : action === 'off' ? false : !current
+    if (current === target) {
+      console.log(`  ${config.displayName}: already ${target ? 'on' : 'off'}`)
+      return { current, target, changed: false }
+    }
+    const changed = await bridge.send({
+      type: 'evaluate',
+      acquireLock: true,
+      code: `(async () => {
+        const modeKey = ${JSON.stringify(config.modeKey)}
+        const target = ${JSON.stringify(target)}
+        window.dispatchEvent(new CustomEvent('sootsim:shell-command', {
+          detail: { type: 'fire-action', id: ${JSON.stringify(config.actionId)} },
+        }))
+        const deadline = Date.now() + 1200
+        while (Date.now() < deadline) {
+          if (Boolean(window.SootSim?.bridges?.settings?.get?.()?.[modeKey]) === target) {
+            return true
+          }
+          await new Promise((resolve) => setTimeout(resolve, 40))
+        }
+        return false
+      })()`,
+    })
+    if (!changed) {
+      throw new Error(
+        `${config.displayName} did not change to ${target ? 'on' : 'off'}; the live shell may not support this mode`,
+      )
+    }
+    console.log(
+      `  ${config.displayName}: ${current ? 'on' : 'off'} -> ${target ? 'on' : 'off'}`,
+    )
+    return { current, target, changed: true }
+  } finally {
+    bridge.close()
+  }
+}

package/cli/commands/skills.ts

@@ -0,0 +1,468 @@
+// rnx skill - install and inspect agent skill files
+//
+// usage:
+//   rnx skill install              install all skills to supported agents
+//   rnx skill install codex debug  install specific skills to Codex only
+//   rnx skill show [name]          list skills or print one skill
+
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import { fileURLToPath } from 'url'
+import { rnxPublicBrand } from '../../src/public-brand'
+import { rnxExit } from '../run-rnx'
+
+function getSkillsDir(): string {
+  try {
+    const pkgPath = fileURLToPath(
+      import.meta.resolve(`${rnxPublicBrand.packageName}/package.json`),
+    )
+    return path.join(path.dirname(pkgPath), 'skills')
+  } catch {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url))
+    return path.resolve(__dirname, '../../skills')
+  }
+}
+
+const SKILLS_DIR = getSkillsDir()
+const AGENT_TARGET_IDS = new Set(['all', 'codex', 'claude'])
+
+interface SkillInfo {
+  name: string
+  description: string
+}
+
+interface InstallTarget {
+  label: string
+  dir: string
+}
+
+function printSkillHelp() {
+  console.log(`rnx skill
+
+install and inspect bundled rnx agent skills.
+
+usage:
+  rnx skill install [all|codex|claude] [skill-name...]
+  rnx skill install --target <dir> [skill-name...]
+  rnx skill show [skill-name]
+
+commands:
+  install   install skills; no target means all supported local agents
+  show      list bundled skills, or print one skill markdown
+
+targets:
+  all       Codex and Claude Code (default)
+  codex     $CODEX_HOME/skills, or ~/.codex/skills
+  claude    $CLAUDE_CONFIG_DIR/skills, or ~/.claude/skills
+`)
+}
+
+function printInstallHelp() {
+  console.log(`rnx skill install
+
+install bundled rnx skills in the agent skill layout: <skill>/SKILL.md.
+each skill directory is symlinked back to its source, so edits stay live
+without a re-install. an existing install from an older CLI is upgraded in
+place; an unrelated skill directory is left alone unless --force is passed.
+
+usage:
+  rnx skill install [all|codex|claude] [skill-name...]
+  rnx skill install --target <dir> [skill-name...]
+
+options:
+  --force, -f   replace a conflicting existing skill with the symlink
+
+examples:
+  rnx skill install
+  rnx skill install codex
+  rnx skill install codex rnx-debug
+  rnx skill install --force rnx-debug
+`)
+}
+
+function targetFromHome(envName: string, fallbackDir: string): string {
+  const home = process.env[envName] || path.join(os.homedir(), fallbackDir)
+  return path.join(home, 'skills')
+}
+
+function defaultAgentTargets(): InstallTarget[] {
+  return [
+    { label: 'codex', dir: targetFromHome('CODEX_HOME', '.codex') },
+    { label: 'claude', dir: targetFromHome('CLAUDE_CONFIG_DIR', '.claude') },
+  ]
+}
+
+function agentTarget(target: string): InstallTarget[] {
+  if (target === 'all') return defaultAgentTargets()
+  if (target === 'codex') {
+    return [{ label: 'codex', dir: targetFromHome('CODEX_HOME', '.codex') }]
+  }
+  if (target === 'claude') {
+    return [{ label: 'claude', dir: targetFromHome('CLAUDE_CONFIG_DIR', '.claude') }]
+  }
+  console.error(`  unknown skill install target: ${target}`)
+  console.error('  expected all, codex, or claude')
+  rnxExit(1)
+}
+
+function parseSkillFrontmatter(
+  content: string,
+): { name: string; description: string } | null {
+  const match = content.match(/^---\n([\s\S]*?)\n---/)
+  if (!match) return null
+  const frontmatter = match[1]
+  const name = readFrontmatterField(frontmatter, 'name')
+  if (!name) return null
+  return {
+    name,
+    description: readFrontmatterField(frontmatter, 'description') || '',
+  }
+}
+
+function readFrontmatterField(frontmatter: string, field: string): string | null {
+  const lines = frontmatter.split('\n')
+  const prefix = `${field}:`
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index]
+    if (!line.startsWith(prefix)) continue
+
+    const rawValue = line.slice(prefix.length).trim()
+    if (rawValue === '>-' || rawValue === '>' || rawValue === '|-' || rawValue === '|') {
+      const blockLines: string[] = []
+      for (let blockIndex = index + 1; blockIndex < lines.length; blockIndex++) {
+        const blockLine = lines[blockIndex]
+        if (/^[A-Za-z0-9_-]+:\s*/.test(blockLine)) break
+        if (blockLine.trim() === '') {
+          blockLines.push('')
+          continue
+        }
+        if (!/^\s+/.test(blockLine)) break
+        blockLines.push(blockLine.trim())
+      }
+      return blockLines.join(rawValue.startsWith('|') ? '\n' : ' ').trim()
+    }
+
+    if (
+      (rawValue.startsWith('"') && rawValue.endsWith('"')) ||
+      (rawValue.startsWith("'") && rawValue.endsWith("'"))
+    ) {
+      return rawValue.slice(1, -1)
+    }
+    return rawValue
+  }
+  return null
+}
+
+// bundled skills live in the standard agent layout: skills/<name>/SKILL.md.
+// the directory name is the skill name; frontmatter is the display metadata.
+function listSkills(): SkillInfo[] {
+  if (!fs.existsSync(SKILLS_DIR)) return []
+  const skills: SkillInfo[] = []
+  for (const entry of fs.readdirSync(SKILLS_DIR)) {
+    const skillMd = path.join(SKILLS_DIR, entry, 'SKILL.md')
+    if (!fs.existsSync(skillMd)) continue
+    const meta = parseSkillFrontmatter(fs.readFileSync(skillMd, 'utf8'))
+    if (meta) {
+      skills.push({ name: entry, description: meta.description })
+    }
+  }
+  return skills.sort((a, b) => a.name.localeCompare(b.name))
+}
+
+function matchSkills(skills: SkillInfo[], filters: string[]): SkillInfo[] {
+  if (filters.length === 0) return skills
+  const matched = skills.filter((skill) =>
+    filters.some((filter) => {
+      const needle = filter.replace(/^rnx-/, '')
+      return (
+        skill.name.includes(filter) || skill.name.replace(/^rnx-/, '').includes(needle)
+      )
+    }),
+  )
+  if (matched.length === 0) {
+    console.error(`  no skills matched: ${filters.join(', ')}`)
+    console.error('  available: ' + skills.map((skill) => skill.name).join(', '))
+    rnxExit(1)
+  }
+  return matched
+}
+
+// install is a SYMLINK of the whole skill DIRECTORY from the agent store back
+// to the source, not a copy, so editing the source skill is live everywhere
+// without re-installing. the directory (not the SKILL.md file) is linked
+// because Codex's skill discovery follows directory symlinks but silently
+// skips a SKILL.md that is itself a file symlink. conflict-safe: skip if
+// already linked to source, upgrade an install from an older CLI (or anything
+// under --force), otherwise refuse so we never clobber a skill the user owns.
+type LinkResult = 'up-to-date' | 'linked' | 'replaced' | 'conflict'
+
+function lstatOrNull(p: string): fs.Stats | null {
+  try {
+    return fs.lstatSync(p)
+  } catch {
+    return null
+  }
+}
+
+function symlinkPointsTo(dest: string, src: string): boolean {
+  const stat = lstatOrNull(dest)
+  if (!stat || !stat.isSymbolicLink()) return false
+  try {
+    return fs.realpathSync(dest) === fs.realpathSync(src)
+  } catch {
+    return false
+  }
+}
+
+// a store entry left by an older CLI is safe to upgrade: either a real dir
+// whose only content is a SKILL.md symlink into an rnx skills source (the
+// pre-dir-layout install — possibly broken after the source moved), or a dir
+// holding a byte-identical copy of the skill. only our installer creates
+// those shapes, so replacing them can't lose user work.
+function isOwnLegacyInstall(stat: fs.Stats, dest: string, srcDir: string): boolean {
+  if (stat.isSymbolicLink() || !stat.isDirectory()) return false
+  let entries: string[]
+  try {
+    entries = fs.readdirSync(dest)
+  } catch {
+    return false
+  }
+  if (entries.length !== 1 || entries[0] !== 'SKILL.md') return false
+  const skillMd = path.join(dest, 'SKILL.md')
+  const mdStat = lstatOrNull(skillMd)
+  if (!mdStat) return false
+  if (mdStat.isSymbolicLink()) {
+    try {
+      return fs.readlinkSync(skillMd).includes(`${path.sep}skills${path.sep}`)
+    } catch {
+      return false
+    }
+  }
+  if (!mdStat.isFile()) return false
+  try {
+    return fs.readFileSync(skillMd).equals(fs.readFileSync(path.join(srcDir, 'SKILL.md')))
+  } catch {
+    return false
+  }
+}
+
+function linkSkill(skill: SkillInfo, targetDir: string, force: boolean): LinkResult {
+  const src = path.join(SKILLS_DIR, skill.name)
+  const dest = path.join(targetDir, skill.name)
+  fs.mkdirSync(targetDir, { recursive: true })
+
+  const existing = lstatOrNull(dest)
+  if (!existing) {
+    fs.symlinkSync(src, dest)
+    return 'linked'
+  }
+  if (symlinkPointsTo(dest, src)) {
+    return 'up-to-date'
+  }
+  if (force || isOwnLegacyInstall(existing, dest, src)) {
+    fs.rmSync(dest, { recursive: true, force: true })
+    fs.symlinkSync(src, dest)
+    return 'replaced'
+  }
+  return 'conflict'
+}
+
+// quiet, conflict-safe (re)install of all bundled skills into the agent stores
+// that already exist on this machine. wired into the CLI build so building or
+// updating the CLI re-establishes the symlinks idempotently — never forces, so
+// it can't clobber a skill the user customized, and never creates a store for
+// an agent that isn't set up here. silent on success.
+export function refreshInstalledSkills() {
+  const skills = listSkills()
+  if (skills.length === 0) return
+  for (const target of defaultAgentTargets()) {
+    const skillsDir = path.resolve(target.dir)
+    // only touch agents already present (~/.claude, ~/.codex) — don't seed a
+    // store on a CI runner or a machine that doesn't use that agent.
+    if (!fs.existsSync(path.dirname(skillsDir))) continue
+    try {
+      fs.mkdirSync(skillsDir, { recursive: true })
+    } catch {
+      continue
+    }
+    try {
+      removeLegacyBundledSkills(skillsDir)
+    } catch {}
+    for (const skill of skills) {
+      try {
+        linkSkill(skill, skillsDir, false)
+      } catch {
+        // best-effort: a single bad store must not fail the build
+      }
+    }
+  }
+}
+
+const LEGACY_BUNDLED_SKILL_DIRS = [
+  'sootsim-setup',
+  'sootsim-debug',
+  'sootsim-perf',
+  'sootsim-test',
+  'sootsim-visual',
+]
+
+function removeLegacyBundledSkills(targetDir: string) {
+  for (const name of LEGACY_BUNDLED_SKILL_DIRS) {
+    const dest = path.join(targetDir, name)
+    const stat = lstatOrNull(dest)
+    if (!stat) continue
+    if (
+      stat.isSymbolicLink() ||
+      isOwnLegacyInstall(stat, dest, path.join(SKILLS_DIR, name))
+    ) {
+      fs.rmSync(dest, { recursive: true, force: true })
+    }
+  }
+}
+
+function printSkillList(skills: SkillInfo[]) {
+  if (skills.length === 0) {
+    console.log('  no skills found')
+    return
+  }
+  console.log('\n  available skills:\n')
+  for (const skill of skills) {
+    console.log(`  ${skill.name}`)
+    console.log(`    ${skill.description}\n`)
+  }
+  console.log('  usage: rnx skill install [all|codex|claude] [skill-name...]')
+  console.log('  usage: rnx skill show [skill-name]\n')
+}
+
+function parseInstallArgs(args: string[]): {
+  targets: InstallTarget[]
+  filters: string[]
+  force: boolean
+} {
+  let targets: InstallTarget[] | null = null
+  let force = false
+  const filters: string[] = []
+
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index]
+    if (arg === '--help' || arg === '-h') {
+      printInstallHelp()
+      rnxExit(0)
+    }
+    if (arg === '--force' || arg === '-f') {
+      force = true
+      continue
+    }
+    if (arg === '--target') {
+      const dir = args[index + 1]
+      if (!dir || dir.startsWith('-')) {
+        console.error('  --target requires a directory')
+        rnxExit(1)
+      }
+      if (targets) {
+        console.error('  pass only one install target')
+        rnxExit(1)
+      }
+      targets = [{ label: 'target', dir }]
+      index++
+      continue
+    }
+    if (arg.startsWith('-')) {
+      console.error(`  unknown option: ${arg}`)
+      printInstallHelp()
+      rnxExit(1)
+    }
+    if (!targets && AGENT_TARGET_IDS.has(arg)) {
+      targets = agentTarget(arg)
+      continue
+    }
+    filters.push(arg)
+  }
+
+  return { targets: targets ?? defaultAgentTargets(), filters, force }
+}
+
+async function runInstall(args: string[]) {
+  const skills = listSkills()
+  if (skills.length === 0) {
+    console.error('  no skills found in rnx package')
+    rnxExit(1)
+  }
+
+  const parsed = parseInstallArgs(args)
+  const toInstall = matchSkills(skills, parsed.filters)
+  const resolvedTargets = parsed.targets.map((target) => ({
+    ...target,
+    dir: path.resolve(target.dir),
+  }))
+  for (const target of resolvedTargets) {
+    fs.mkdirSync(target.dir, { recursive: true })
+    if (!fs.statSync(target.dir).isDirectory()) {
+      console.error(`  target is not a directory: ${target.dir}`)
+      rnxExit(1)
+    }
+    removeLegacyBundledSkills(target.dir)
+  }
+
+  console.log(
+    `\n  installing ${toInstall.length} skill(s) to ${resolvedTargets.length} target(s)\n`,
+  )
+  let conflicts = 0
+  for (const target of resolvedTargets) {
+    console.log(`  target ${target.label}: ${target.dir}`)
+    for (const skill of toInstall) {
+      const dest = path.join(target.dir, skill.name)
+      const result = linkSkill(skill, target.dir, parsed.force)
+      if (result === 'linked') console.log(`  linked ${skill.name} -> ${dest}`)
+      else if (result === 'replaced') console.log(`  relinked ${skill.name} -> ${dest}`)
+      else if (result === 'up-to-date') console.log(`  up to date ${skill.name}`)
+      else {
+        conflicts++
+        console.log(
+          `  conflict ${skill.name}: ${dest} exists and is not this skill — pass --force to replace`,
+        )
+      }
+    }
+    console.log('')
+  }
+  if (conflicts > 0) {
+    console.error(
+      `  ${conflicts} conflict(s); rerun with --force only if replacing them is intended.\n`,
+    )
+    rnxExit(1)
+  }
+  console.log('  done. restart the agent session to load newly installed skills.\n')
+}
+
+function runShow(args: string[]) {
+  const skills = listSkills()
+  const name = args.find((arg) => !arg.startsWith('-'))
+  if (!name) {
+    printSkillList(skills)
+    return
+  }
+  const [skill] = matchSkills(skills, [name])
+  const content = fs.readFileSync(path.join(SKILLS_DIR, skill.name, 'SKILL.md'), 'utf8')
+  console.log(content)
+}
+
+export async function runSkill(args: string[]) {
+  const [command, ...rest] = args
+  if (!command || command === '--help' || command === '-h') {
+    printSkillHelp()
+    return
+  }
+  if (command === 'install') {
+    await runInstall(rest)
+    return
+  }
+  if (command === 'show' || command === 'list') {
+    runShow(rest)
+    return
+  }
+
+  console.error(`  unknown skill command: ${command}`)
+  printSkillHelp()
+  rnxExit(1)
+}