@xmoon76/dsh-pi-tui 0.1.8 → 0.2.0

package/scripts/phase4-plugin-smoke.mjs

@@ -0,0 +1,318 @@
+#!/usr/bin/env node
+/**
+ * phase4-plugin-smoke — verify the PACKED Phase-4 advanced surface end
+ * to end with a real third-party-shaped plugin (Phase 4, plan §17):
+ *
+ *   1. the fixture imports ONLY the public `@xmoon76/dsh-pi-tui/
+ *      extensions/advanced` (and the stable `extensions` entry for the
+ *      service type) subpaths — importing `@xmoon76/pi-tui`, `src/tui-app`
+ *      or any repository-relative internal path FAILS the gate (static
+ *      imports, dynamic import() AND require() are all scanned);
+ *   2. the fixture typechecks against the packed `.d.mts`;
+ *   3. the fixture COMPILES to JS and RUNTIME-LOADS against the packed
+ *      bytes (apply() registers through a mock service without throwing);
+ *   4. the fixture exercises the Phase-4 surface: the imperative UI
+ *      broker (select/confirm/input/notify), custom interactive UI
+ *      (ui.custom), and the host-state facade (theme/title/working/
+ *      tools-expanded);
+ *   5. the fixture's module shape (name/inject/apply) matches the Loader;
+ *   6. no duplicate dsh runtime in the fixture tree.
+ *
+ * The probe mirrors the host install with SYMLINKS (no npm install — the
+ * gate is offline-safe; the packed package's runtime deps resolve from
+ * the repo's node_modules exactly like a real profile).
+ *
+ * Usage: node scripts/phase4-plugin-smoke.mjs [path-to-tgz]
+ * @module phase4-plugin-smoke
+ */
+
+import { spawnSync } from 'node:child_process'
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  statSync,
+  lstatSync,
+  symlinkSync,
+  writeFileSync,
+} from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url))
+const PACKAGE_ROOT = join(SCRIPT_DIR, '..')
+const FIXTURE_ROOT = join(PACKAGE_ROOT, 'test', 'fixtures', 'phase4-plugin')
+
+const failures = []
+const checks = []
+
+function check(name, ok, detail = '') {
+  checks.push(`${ok ? 'ok  ' : 'FAIL'} ${name}${detail === '' ? '' : ` — ${detail}`}`)
+  if (!ok) failures.push(`${name}${detail === '' ? '' : `: ${detail}`}`)
+}
+
+function run(command, args, options = {}) {
+  return spawnSync(command, args, { encoding: 'utf8', ...options })
+}
+
+function resolveTarball(explicit) {
+  if (explicit !== undefined) {
+    const absolute = resolve(explicit)
+    if (!existsSync(absolute)) throw new Error(`tarball not found: ${explicit}`)
+    return absolute
+  }
+  const dir = PACKAGE_ROOT
+  const candidates = readdirSync(dir)
+    .filter(name => /xmoon76-dsh-pi-tui-.*\.tgz$/.test(name))
+    .map(name => join(dir, name))
+    .sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs)
+  if (candidates.length === 0) {
+    throw new Error(`no xmoon76-dsh-pi-tui-*.tgz in ${dir}; run pnpm pack:release first`)
+  }
+  return candidates[0]
+}
+
+function main() {
+  const tarball = resolveTarball(process.argv[2])
+  const workDir = mkdtempSync(join(tmpdir(), 'phase4-plugin-'))
+  try {
+    // 1. Extract the packed package.
+    const extractedDir = join(workDir, 'pkg')
+    mkdirSync(extractedDir)
+    const extract = run('tar', ['-xzf', tarball, '-C', extractedDir])
+    check('tarball extracts', extract.status === 0, extract.stderr)
+    const pkgDir = join(extractedDir, 'package')
+    check('packed package has dist/extension/advanced.mjs', existsSync(join(pkgDir, 'dist', 'extension', 'advanced.mjs')))
+    check('packed package has dist/extension/advanced.d.mts', existsSync(join(pkgDir, 'dist', 'extension', 'advanced.d.mts')))
+
+    // 2. IMPORT BAN (plan §15 CI gate): the fixture's IMPORT STATEMENTS
+    //    (multi-line blocks), dynamic import() and require() specifiers
+    //    must never reference private internals.
+    const fixtureSrc = readFileSync(join(FIXTURE_ROOT, 'src', 'index.ts'), 'utf8')
+    const lines = fixtureSrc.split('\n')
+    const importStatements = []
+    for (let index = 0; index < lines.length; index++) {
+      if (/^\s*import\b/.test(lines[index] ?? '')) {
+        let statement = lines[index] ?? ''
+        while (!statement.includes(';') && index + 1 < lines.length) {
+          index += 1
+          statement += lines[index]
+        }
+        importStatements.push(statement)
+      }
+    }
+    const importLines = importStatements.join('\n')
+    const dynamicSpecifiers = [...fixtureSrc.matchAll(/import\s*\(\s*['"]([^'"]+)['"]\s*\)/g)]
+      .map(match => match[1])
+      .concat([...fixtureSrc.matchAll(/require\s*\(\s*['"]([^'"]+)['"]\s*\)/g)]
+        .map(match => match[1]))
+    const banned = [
+      // Word-boundary: `@xmoon76/pi-tui` must NOT match
+      // `@xmoon76/dsh-pi-tui` (a substring of the public package name).
+      ['@xmoon76/pi-tui (the private fork, word-bounded)', /@xmoon76\/pi-tui(?![-a-z])/g],
+      ['@moonshot-ai/pi-tui', /@moonshot-ai\/pi-tui/g],
+      ['src/tui-app', /src\/tui-app/g],
+      ['TuiApp', /\bTuiApp\b/g],
+      ['TuiMainScreen', /\bTuiMainScreen\b/g],
+      ['TuiAltScreen', /\bTuiAltScreen\b/g],
+      ['repository-relative internal path', /\.\.\/\.\.\/src/g],
+    ]
+    for (const [name, pattern] of banned) {
+      const staticMatches = importLines.match(pattern) ?? []
+      const dynamicMatches = dynamicSpecifiers.filter(specifier => pattern.test(specifier))
+      check(`fixture does not import ${name}`, staticMatches.length === 0 && dynamicMatches.length === 0,
+        [...staticMatches, ...dynamicMatches].join(', '))
+    }
+    // The ONLY @xmoon76/dsh-pi-tui imports are the public subpaths
+    // (extensions/advanced + extensions for the service type; cordis is a
+    // legitimate peer for the plugin's apply signature).
+    const dshImports = importLines.match(/@xmoon76\/dsh-pi-tui[^'"]*/g) ?? []
+    check('fixture imports ONLY the public extensions subpaths',
+      dshImports.length === 2
+        && dshImports.includes('@xmoon76/dsh-pi-tui/extensions/advanced')
+        && dshImports.includes('@xmoon76/dsh-pi-tui/extensions'),
+      dshImports.join(', '))
+
+    // 3. PHASE-4 SURFACE EXERCISE (plan §17 acceptance): the fixture
+    //    exercises the Phase-4 advanced surface through the public entry.
+    const surface = [
+      ['ui.ui.select', 'imperative select broker'],
+      ['ui.ui.confirm', 'imperative confirm broker'],
+      ['ui.ui.input', 'imperative input broker'],
+      ['ui.ui.notify', 'imperative notify broker'],
+      ['ui.ui.custom', 'custom interactive UI'],
+      ['AdvancedCustomHost', 'custom host facade type'],
+      ['ui.host.getTheme', 'host-state theme query'],
+      ['ui.host.setTheme', 'host-state theme select'],
+      ['ui.host.setTitle', 'host-state title override'],
+      ['ui.host.setWorkingMessage', 'host-state working override'],
+      ['ui.host.setToolsExpanded', 'host-state tool expansion'],
+    ]
+    for (const [api, label] of surface) {
+      check(`fixture exercises ${label} (${api})`, fixtureSrc.includes(api))
+    }
+    check('fixture never parses raw terminal bytes (no CSI-u / escape matching in the plugin)',
+      !/\\x1b\[/.test(fixtureSrc) && !/escape\s*\(/.test(fixtureSrc.replace(/handleInput/g, '')))
+
+    // 4. The fixture tree: symlink the packed package + the host's
+    //    node_modules (the offline-safe mirror of a real profile install).
+    const fixtureDir = join(workDir, 'fixture')
+    mkdirSync(join(fixtureDir, 'node_modules', '@xmoon76'), { recursive: true })
+    symlinkSync(pkgDir, join(fixtureDir, 'node_modules', '@xmoon76', 'dsh-pi-tui'), 'dir')
+    const hostModules = join(PACKAGE_ROOT, 'node_modules')
+    mkdirSync(join(pkgDir, 'node_modules'), { recursive: true })
+    for (const entry of readdirSync(hostModules)) {
+      const target = join(pkgDir, 'node_modules', entry)
+      if (existsSync(target)) continue
+      symlinkSync(join(hostModules, entry), target, 'dir')
+    }
+    mkdirSync(join(fixtureDir, 'node_modules'), { recursive: true })
+    for (const entry of readdirSync(hostModules)) {
+      const target = join(fixtureDir, 'node_modules', entry)
+      if (existsSync(target)) continue
+      symlinkSync(join(hostModules, entry), target, 'dir')
+    }
+    mkdirSync(join(fixtureDir, 'src'), { recursive: true })
+    writeFileSync(join(fixtureDir, 'src', 'index.ts'), fixtureSrc)
+    writeFileSync(join(fixtureDir, 'tsconfig.json'), JSON.stringify({
+      compilerOptions: {
+        target: 'ES2022',
+        module: 'NodeNext',
+        moduleResolution: 'NodeNext',
+        strict: true,
+        noEmit: true,
+        skipLibCheck: true,
+        types: [],
+      },
+      include: ['src'],
+    }, null, 2))
+    writeFileSync(join(fixtureDir, 'package.json'), JSON.stringify({
+      name: 'dsh-pi-phase4-fixture',
+      private: true,
+      type: 'module',
+    }, null, 2))
+
+    // 5. Typecheck against the packed .d.mts (the repo's tsc — no
+    //    registry fetch).
+    const tsc = run('node', [join(PACKAGE_ROOT, 'node_modules', 'typescript', 'bin', 'tsc'), '-p', join(fixtureDir, 'tsconfig.json')], { cwd: fixtureDir })
+    check('fixture typechecks against the packed .d.mts', tsc.status === 0,
+      tsc.status === 0 ? '' : (tsc.stdout + tsc.stderr).split('\n').slice(-6).join(' '))
+
+    // 6. Module shape.
+    const moduleShape = /export const name = ['"][^'"]+['"]/s.test(fixtureSrc)
+      && /export const inject = \[/s.test(fixtureSrc)
+      && /export function apply\(ctx: Context\)/s.test(fixtureSrc)
+    check('fixture module shape (name/inject/apply) matches the Loader', moduleShape)
+
+    // 7. RUNTIME LOAD: compile the fixture to JS and apply() it with a
+    //    mock service — the registrations must not throw and must resolve
+    //    the PACKED advanced module.
+    const emitDir = join(fixtureDir, 'dist-out')
+    const emit = run('node', [join(PACKAGE_ROOT, 'node_modules', 'typescript', 'bin', 'tsc'),
+      '-p', join(fixtureDir, 'tsconfig.json'), '--noEmit', 'false', '--outDir', emitDir], { cwd: fixtureDir })
+    check('fixture compiles to JS for the runtime probe', emit.status === 0,
+      emit.status === 0 ? '' : (emit.stdout + emit.stderr).split('\n').slice(-4).join(' '))
+    if (emit.status === 0) {
+      writeFileSync(join(fixtureDir, 'runtime-probe.mjs'), `
+        const context = {
+          get: (name) => name === 'piTuiExtensions' ? mockService() : undefined,
+          on: () => {},
+        }
+        function mockService() {
+          const inertLease = {
+            id: 'inert', active: false, focused: false,
+            focus: () => {}, blur: () => {}, invalidate: () => {},
+            close: () => {}, hide: () => {}, show: () => {},
+          }
+          const inertControls = {
+            getEditorState: () => ({ text: '', cursor: 0, focused: false, composing: false }),
+            setEditorText: () => {}, setEditorCursor: () => {},
+            insertEditorText: () => {}, pasteToEditor: () => {}, requestEditorFocus: () => {},
+          }
+          return {
+            api: () => ({
+              apiVersion: 1,
+              hostVersion: 'test',
+              capabilities: new Set(['advanced.input.capture', 'advanced.ui.interactive', 'advanced.editor.control']),
+              deprecations: new Map(),
+            }),
+            _advancedCaptureInput: (spec) => ({ id: spec.id, dispose: () => {} }),
+            _advancedShowInteractiveOverlay: () => inertLease,
+            _advancedEditorControls: () => inertControls,
+            _advancedUiSelect: () => Promise.resolve(undefined),
+            _advancedUiConfirm: () => Promise.resolve(false),
+            _advancedUiInput: () => Promise.resolve(undefined),
+            _advancedUiNotify: () => {},
+            _advancedUiCustom: () => Promise.resolve(undefined),
+            _advancedHostState: () => ({
+              getTheme: () => 'dark',
+              setTheme: () => {},
+              setTitle: () => {},
+              setWorkingMessage: () => {},
+              setToolsExpanded: () => {},
+            }),
+          }
+        }
+        const plugin = await import(${JSON.stringify(join(emitDir, 'index.js').replaceAll('\\', '/'))})
+        plugin.apply(context)
+        if (plugin.name !== 'dsh-pi-phase4-fixture') throw new Error('bad name: ' + plugin.name)
+        console.log('fixture-runtime-ok')
+      `)
+      const runtime = run(process.execPath, [join(fixtureDir, 'runtime-probe.mjs')], { cwd: fixtureDir })
+      check('fixture runtime-loads and apply() registers without throwing',
+        runtime.status === 0 && runtime.stdout.includes('fixture-runtime-ok'),
+        runtime.status === 0 ? '' : (runtime.stderr || runtime.stdout).split('\n').slice(-8).join(' '))
+    }
+
+    // 8. No duplicate dsh runtime: every @deepseek-ai entry in BOTH the
+    //    packed package tree AND the fixture tree must be a SYMLINK whose
+    //    realpath resolves into the host module tree (the packed tarball
+    //    itself carries no node_modules — the scaffolding symlinks them,
+    //    exactly like a real profile resolves in-box packages from the
+    //    dsh installation). A REAL directory is a duplicate runtime copy.
+    const probeReal = resolve(workDir)
+    const auditTrees = [
+      ['packed package', join(pkgDir, 'node_modules', '@deepseek-ai')],
+      ['fixture tree', join(fixtureDir, 'node_modules', '@deepseek-ai')],
+    ]
+    const realDirs = []
+    for (const [label, nm] of auditTrees) {
+      const entries = existsSync(nm) ? readdirSync(nm) : []
+      for (const name of entries) {
+        const entry = join(nm, name)
+        let isSymlink = false
+        try { isSymlink = lstatSync(entry).isSymbolicLink() } catch { /* missing */ }
+        if (!isSymlink) {
+          realDirs.push(`${label}:${name} (real dir)`)
+          continue
+        }
+        try {
+          const target = resolve(realpathSync(entry))
+          if (target.startsWith(probeReal)) realDirs.push(`${label}:${name}->${target}`)
+        } catch {
+          realDirs.push(`${label}:${name} (dangling)`)
+        }
+      }
+    }
+    check('no duplicate @deepseek-ai dsh-runtime copy (symlinks only, both trees)',
+      realDirs.length === 0,
+      realDirs.join(', '))
+  } finally {
+    if (process.env.ADVANCED_SMOKE_KEEP !== '1') rmSync(workDir, { recursive: true, force: true })
+  }
+
+  for (const line of checks) console.log(line)
+  if (failures.length > 0) {
+    console.error(`\nphase4-plugin smoke FAILED (${failures.length}):`)
+    for (const failure of failures) console.error(`  - ${failure}`)
+    process.exit(1)
+  }
+  console.log('\nphase4-plugin smoke passed')
+}
+
+main()

package/scripts/tarball-smoke.mjs

@@ -149,10 +149,12 @@ function main() {
     // --- structure ---
     const files = walkFiles(extracted)
     const has = (path) => files.includes(path)
-    check('exports entry dist/index.mjs', has('dist/index.mjs'))
-    check('exports entry dist/startup.mjs', has('dist/startup.mjs'))
-    check('types dist/index.d.mts', has('dist/index.d.mts'))
-    check('types dist/startup.d.mts', has('dist/startup.d.mts'))
+    check('exports entry dist/extension/advanced.mjs', has('dist/extension/advanced.mjs'))
+    check('exports entry dist/extension/unstable.mjs', has('dist/extension/unstable.mjs'))
+    check('types dist/extension/advanced.d.mts', has('dist/extension/advanced.d.mts'))
+    check('types dist/extension/unstable.d.mts', has('dist/extension/unstable.d.mts'))
+    check('exports entry dist/builtins.mjs', has('dist/builtins.mjs'))
+    check('types dist/builtins.d.mts', has('dist/builtins.d.mts'))
     check('cordis.patch.yml included', has('cordis.patch.yml'))
     check('config/ included', files.some(name => name.startsWith('config/')))
     check('repair-session.mjs included', has('scripts/repair-session.mjs'))
@@ -225,6 +227,62 @@ function main() {
       checks.push(`skip .d.mts parse — typescript unavailable`)
     }
 
+    // --- public .d.mts leak gate (M3/E, round-1/2 review): the shipped
+    // declarations must not reference the vendored fork, TuiApp, private
+    // screens, or repository source paths. tsdown INLINES types into the
+    // .d.mts with `//#region <path>` markers; a fork leak shows up as a
+    // region pointing OUTSIDE the package's own src/ (`../pi-tui/...`,
+    // `node_modules/@xmoon76/pi-tui/...`) or as fork module names
+    // (`src/tui-main-screen.d.ts`), often inside an auto-generated SHARED
+    // CHUNK that the SDK entries only re-export. The gate therefore:
+    //   (a) scans EVERY dist/*.d.mts (entries AND chunks);
+    //   (b) treats any region marker whose path is not this package's own
+    //       src/ as a leak (allowlist by construction);
+    //   (c) bans fork imports and fork module names anywhere;
+    //   (d) bans the bare private identifiers (TuiMainScreen/TuiAltScreen/
+    //       TuiApp) line-scoped over every file, skipping comment lines.
+    const dtsAll = files.filter(name => name.startsWith('dist/') && name.endsWith('.d.mts'))
+    const sdkIdentifiers = [/\bTuiMainScreen\b/, /\bTuiAltScreen\b/, /\bTuiApp\b/]
+    const dtsLeaks = []
+    for (const name of dtsAll) {
+      const text = readFileSync(join(extracted, name), 'utf8')
+      const lines = text.split('\n')
+      // (b) region markers: allow only `//#region src/<public module>.d.ts`.
+      // The ROOT entry (dist/index.d.mts) is the runner's own surface: it
+      // legitimately inlines the TuiApp implementation (src/tui-app.d.ts)
+      // for the Loader row — it is NOT a third-party SDK entry. Its region
+      // is exempted; everything else (chunks, extensions, builtins) must
+      // name only the public modules below.
+      const isRoot = name === 'dist/index.d.mts'
+      for (const line of lines) {
+        const match = /\/\/#region\s+(\S+)/.exec(line)
+        if (match) {
+          const regionPath = match[1]
+          const allowed = /^src\/(builtins|commands|diag|extension\/advanced|extension\/advanced-types|extension\/public-types|extension\/service|extension\/slot-map|extension\/unstable|extension\/unstable-types|extensions|index|skill-catalog|startup|surface-catalog)\.d\.ts$/.test(regionPath)
+          const rootAllowed = isRoot && /^src\/tui-app\.d\.ts$/.test(regionPath)
+          if (!allowed && !rootAllowed) dtsLeaks.push(`${name}: region ${regionPath}`)
+        }
+      }
+      // (c) fork imports and fork module names anywhere.
+      if (/from\s*["']@xmoon76\/pi-tui["']/.test(text)) dtsLeaks.push(`${name}: fork import`)
+      if (/packages\/pi-tui/.test(text)) dtsLeaks.push(`${name}: packages/pi-tui path`)
+      if (/\b(tui-main-screen|tui-alt-screen)\.d\.ts\b/.test(text)) dtsLeaks.push(`${name}: fork screen module`)
+      // (d) bare private identifiers, line-scoped (comments skipped). No
+      // exemption: the clean dist has zero TuiApp identifiers anywhere
+      // (round-3 finding 1 — the old root exemption was dead code).
+      for (const line of lines) {
+        const trimmed = line.trim()
+        if (trimmed.startsWith('*') || trimmed.startsWith('//') || trimmed.startsWith('/*')) continue
+        for (const pattern of sdkIdentifiers) {
+          if (pattern.test(trimmed)) dtsLeaks.push(`${name}: bare ${pattern}`)
+        }
+      }
+    }
+    check('every public .d.mts leaks no private pi-tui / internal paths', dtsLeaks.length === 0,
+      dtsLeaks.length === 0 ? '' : dtsLeaks.join('; '))
+    // The .mjs bodies must not import the fork externally either (it is
+    // bundled) — the existing dist check below covers every .mjs.
+
     // --- install + runtime ---
     if (skipInstall) {
       checks.push('skip npm install (TARBALL_SMOKE_SKIP_INSTALL=1)')
@@ -242,10 +300,14 @@ function main() {
         const installed = join(probeDir, 'node_modules', '@xmoon76', 'dsh-pi-tui')
         check('installed package contains dist', existsSync(join(installed, 'dist', 'index.mjs')))
         const importRun = run(process.execPath, ['--input-type=module', '-e',
-          "Promise.all([import('@xmoon76/dsh-pi-tui'), import('@xmoon76/dsh-pi-tui/startup')])"
-            + ".then(m => console.log('imports-ok')).catch(e => { console.error(e.message); process.exit(1) })",
+          "Promise.all([import('@xmoon76/dsh-pi-tui'), import('@xmoon76/dsh-pi-tui/startup'),"
+            + "import('@xmoon76/dsh-pi-tui/extensions'), import('@xmoon76/dsh-pi-tui/builtins'),"
+            + "import('@xmoon76/dsh-pi-tui/extensions/advanced'), import('@xmoon76/dsh-pi-tui/extensions/unstable')])"
+            + ".then(m => { if (m[4].ADVANCED_API_LEVEL !== 1) throw new Error('ADVANCED_API_LEVEL');"
+            + "if (m[5].UNSTABLE_API_LEVEL !== 1) throw new Error('UNSTABLE_API_LEVEL'); console.log('imports-ok') })"
+            + ".catch(e => { console.error(e.message); process.exit(1) })",
         ], { cwd: probeDir })
-        check('both exports entries import', importRun.status === 0 && importRun.stdout.includes('imports-ok'),
+        check('all exports entries import', importRun.status === 0 && importRun.stdout.includes('imports-ok'),
           importRun.status === 0 ? '' : importRun.stderr.slice(0, 200))
         const forkRun = run(process.execPath, ['--input-type=module', '-e',
           "import('@xmoon76/pi-tui').then(() => process.exit(0)).catch(() => process.exit(3))",