dsh-perm-gate 4.1.2 → 4.2.0-beta.1

package/scripts/patch-permission-glyph.mjs

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 /**
- * Give this plugin's own permission tiers the composer glyphs the host will not
- * draw for them.
+ * Add `permissive-full` to the DSH composer's permission-glyph map.
  *
  * WHY THIS EXISTS
  * ---------------
@@ -10,40 +9,22 @@
  *
  *     const permissionGlyphs = new Map([
  *       ["read-only", <svg …/>],
+ *       ["permissive", <svg …/>],          // the 自动审查 tier's shield+eye
  *       ["workspace-write", <svg …/>],
- *       [FULL_ACCESS, <svg …/>],      // const FULL_ACCESS = "danger-full-access"
+ *       ["danger-full-access", <svg …/>],
  *     ]);
  *     function permissionGlyph(value) { return permissionGlyphs.get(value); }
  *
  * The source comment states the rule: "host-configured names outside the design
  * set get none." There is no plugin-facing seam — the option objects the host
  * supplies carry only `{value, name, description}`, and the map itself is a
- * closure variable. So a plugin-contributed tier renders with no icon in the
- * dropdown and falls back to plain text in the trigger.
+ * closure variable. So a plugin-contributed tier such as `permissive-full`
+ * renders with no icon in the dropdown and falls back to plain text in the
+ * trigger, while the built-in `permissive` tier shows the shield+eye.
  *
- * The only way to give our tiers the same glyph is to add entries to that map.
- * This script does exactly that — one glyph per tier, copied from the built-in
- * tier whose file sandbox the plugin tier shares:
- *
- *     permissive       sandbox: workspace-write    <- the ["workspace-write",] entry
- *     permissive-full  sandbox: danger-full-access <- the [FULL_ACCESS,] entry
- *
- * WHY THE SOURCES ARE DECLARED AND THE ANCHOR IS RESOLVED
- * -------------------------------------------------------
- * DSH 0.1.2 shipped four glyphs, `permissive` among them; 0.1.5-rc.2 ships three
- * (`read-only` / `workspace-write` / `danger-full-access`) and the string
- * `permissive` no longer occurs anywhere in the bundle — so a splice anchored on
- * `["permissive",` dies with "anchor not found" on the current host. Two
- * properties keep this working across such a design-set change:
- *
- *   1. the source key is a declaration (`GLYPH_TARGETS`) rather than a literal
- *      buried in the splice, so re-pointing a tier is a one-line edit; and
- *   2. the anchor for a key is RESOLVED, not assumed to be a string literal:
- *      `["<key>",` first, then the constant alias the bundle may use instead
- *      (`[FULL_ACCESS,` for `"danger-full-access"`).
- *
- * When a declared source key is gone, the refusal names the keys the map DOES
- * carry, so the next drift is diagnosed from the error text alone.
+ * The only way to give our tier the same glyph is to add an entry to that map.
+ * This script does exactly that: it duplicates the `permissive` entry under the
+ * `permissive-full` key, so the two tiers of one plugin look alike.
  *
  * VOLUNTARY, NOT AUTOMATIC
  * ------------------------
@@ -61,11 +42,8 @@
  *   npx dsh-perm-gate-patch-glyph --check      # report only; exit 1 if missing
  *   node scripts/patch-permission-glyph.mjs <path/to/client.js>
  *
- * With no argument it probes the profile scopes first and the CLI install second,
- * and lists any other DSH install that carries the same bundle — on a host with
- * both, only one of them serves the UI, so the explicit-path form is the answer
- * when the probe picks the wrong one. The script is idempotent (a second run is a
- * no-op), backs the file up once, applies every target or none, and refuses to
+ * With no argument it probes the usual global-install locations. The script is
+ * idempotent (a second run is a no-op), backs the file up once, and refuses to
  * write a bundle it cannot slice correctly, so it can never half-apply.
  */
 import { existsSync, readFileSync, writeFileSync, copyFileSync } from 'node:fs'
@@ -74,23 +52,13 @@ import { homedir } from 'node:os'
 import { dirname, join, resolve } from 'node:path'
 import { pathToFileURL } from 'node:url'
 
+/** The map key whose entry is cloned, and the key it is cloned onto. */
+export const SOURCE_KEY = 'permissive'
+export const TARGET_KEY = 'permissive-full'
+
 /** Relative path from a package root to the bundle holding the map. */
 const BUNDLE = join('@deepseek-ai', 'dsh-client-ui-conversation', 'lib', 'client.js')
 
-/**
- * The glyphs to add: each plugin tier, and the built-in tier it copies.
- *
- * The pairing is by file-sandbox meaning, not by name similarity — `permissive`
- * runs in the same sandbox as `workspace-write`, `permissive-full` in the same
- * sandbox as `danger-full-access` — so the icon a user sees matches the access
- * the tier actually grants. A tier listed here gets that built-in's entry
- * verbatim apart from its key.
- */
-export const GLYPH_TARGETS = [
-  { target: 'permissive', source: 'workspace-write' },
-  { target: 'permissive-full', source: 'danger-full-access' },
-]
-
 /** Thrown for every refusal; the CLI turns it into an exit code 1. */
 export class GlyphPatchError extends Error {}
 
@@ -98,15 +66,6 @@ export class GlyphPatchError extends Error {}
  * Candidate bundle paths, most specific first. Pure: no filesystem access, so
  * the probe order is unit-testable.
  *
- * Profile scope before CLI-install scope, and that order is load-bearing on a
- * machine with more than one DSH: a profile's UI is served by the profile's own
- * dependency scope, not by whichever global CLI install happens to sit beside the
- * running `node`. Measured on this project's own host — a global install under
- * `dirname(node)` existed and shadowed the profile's bundle under an older probe
- * order, so the patch reported success while the picker stayed icon-free. On a
- * stock single-install machine every candidate is one inode, so the order decides
- * nothing there; it only matters exactly when guessing wrong is silent.
- *
  * `execDir` is `dirname(process.execPath)`. Deriving from the running node
  * binary — never from a hardcoded nvm version or install path — is what keeps
  * the script working across node upgrades and re-pointed install symlinks.
@@ -116,111 +75,19 @@ export class GlyphPatchError extends Error {}
  */
 export function candidateBundles({ execDir, cwd, dshHome }) {
   return [
-    // 1. Whatever profile the caller is standing in.
-    join(cwd, 'node_modules', BUNDLE),
-    // 2. The hoisted scope every profile under DSH_HOME shares.
-    join(dshHome, 'profiles', 'node_modules', BUNDLE),
-    // 3. `@deepseek-ai` scope hoisted beside the running node binary.
+    // 1. `@deepseek-ai` scope hoisted beside the running node binary.
     join(execDir, 'node_modules', BUNDLE),
-    // 4. The same scope nested inside the `dsh` package itself.
+    // 2. The same scope nested inside the `dsh` package itself.
     join(execDir, 'node_modules', '@deepseek-ai', 'dsh', 'node_modules', BUNDLE),
+    // 3. Whatever profile the caller is standing in.
+    join(cwd, 'node_modules', BUNDLE),
+    // 4. The hoisted scope shared by every profile under DSH_HOME.
+    join(dshHome, 'profiles', 'node_modules', BUNDLE),
   ]
 }
 
 /**
- * In-page string constants (`const FULL_ACCESS = "danger-full-access"`), as
- * name -> value. First declaration wins, so a later reassignment cannot shadow
- * the spelling the map was built with above it.
- *
- * The bundle may key a map entry by such a name rather than by a literal, which
- * is the whole reason the anchor is resolved instead of concatenated.
- *
- * @param {string} source
- * @returns {Map<string, string>} constant name -> its string value
- */
-export function pageConstants(source) {
-  const constants = new Map()
-  for (const match of source.matchAll(/(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*"([^"]*)"/g)) {
-    if (!constants.has(match[1])) constants.set(match[1], match[2])
-  }
-  return constants
-}
-
-/**
- * The `permissionGlyphs` map's text, brackets included.
- *
- * Parsed rather than assumed: the map is a `new Map([ … ])` closure variable, so
- * its extent is found by bracket depth from its `[`. Reading the map (instead of
- * only probing for one anchor inside it) is what lets a refusal report the keys
- * the host actually renders.
- *
- * @param {string} source
- * @returns {string} the map array text, from `[` to the matching `]`
- */
-export function glyphMapText(source) {
-  const start = source.search(/permissionGlyphs\s*=\s*new Map\(\s*\[/)
-  if (start === -1) throw new GlyphPatchError('permissionGlyphs map not found in this bundle')
-  const open = source.indexOf('[', start)
-  let depth = 0
-  for (let i = open; i < source.length; i += 1) {
-    const ch = source[i]
-    if (ch === '[' || ch === '(' || ch === '{') depth += 1
-    else if (ch === ']' || ch === ')' || ch === '}') {
-      depth -= 1
-      if (depth === 0) return source.slice(open, i + 1)
-    }
-  }
-  throw new GlyphPatchError('unterminated permissionGlyphs map')
-}
-
-/**
- * The preset values the map renders a glyph for — literals as-is, and entries
- * keyed by an in-page constant resolved to that constant's value.
- *
- * @param {string} source
- * @returns {string[]} e.g. `['read-only', 'workspace-write', 'danger-full-access']`
- */
-export function glyphKeys(source) {
-  const constants = pageConstants(source)
-  const keys = []
-  for (const match of glyphMapText(source).matchAll(/\[\s*(?:"([^"]+)"|([A-Za-z_$][\w$]*))\s*,/g)) {
-    if (match[1] !== undefined) keys.push(match[1])
-    else keys.push(constants.get(match[2]) ?? match[2])
-  }
-  return keys
-}
-
-/**
- * Resolve the anchor text of one map entry, literal first, constant alias second.
- *
- * @param {string} source the bundle's text
- * @param {string} key the preset value, e.g. `danger-full-access`
- * @returns {{ anchor: string, index: number }}
- * @throws {GlyphPatchError} when the host renders no glyph for `key`
- */
-export function resolveAnchor(source, key) {
-  for (const anchor of [`["${key}",`, `['${key}',`]) {
-    const index = source.indexOf(anchor)
-    if (index !== -1) return { anchor, index }
-  }
-  const name = [...pageConstants(source)].find(([, value]) => value === key)?.[0]
-  if (name !== undefined) {
-    const anchor = `[${name},`
-    const index = source.indexOf(anchor)
-    if (index !== -1) return { anchor, index }
-    throw new GlyphPatchError(
-      `anchor not found: ${anchor} (the alias for "${key}")`,
-    )
-  }
-  throw new GlyphPatchError(
-    `this host renders no glyph for "${key}" — the map carries: ` +
-    `${glyphKeys(source).map((k) => `"${k}"`).join(', ')}\n` +
-    '  Re-point GLYPH_TARGETS at a key the map does carry.',
-  )
-}
-
-/**
- * Extract the full `["<key>", …]` (or `[CONST, …]`) map entry, by bracket depth.
+ * Extract the full `["<key>", …]` map entry, by bracket depth.
  *
  * The scan starts ON the entry's opening `[` (the one immediately before the
  * key), so depth returns to zero exactly at that entry's closing `]`. Starting
@@ -231,12 +98,12 @@ export function resolveAnchor(source, key) {
  * contain no brackets.
  *
  * @param {string} source
- * @param {string} anchor the text returned by {@link resolveAnchor}
+ * @param {string} key
  * @returns {string} the entry, brackets included
  */
-export function sliceEntry(source, anchor) {
-  const start = source.indexOf(anchor)
-  if (start === -1) throw new GlyphPatchError(`anchor not found: ${anchor}`)
+export function sliceEntry(source, key) {
+  const start = source.indexOf(`["${key}",`)
+  if (start === -1) throw new GlyphPatchError(`anchor not found: ["${key}",`)
   let depth = 0
   for (let i = start; i < source.length; i += 1) {
     const ch = source[i]
@@ -246,41 +113,24 @@ export function sliceEntry(source, anchor) {
       if (depth === 0) return source.slice(start, i + 1)
     }
   }
-  throw new GlyphPatchError(`unterminated entry for ${anchor}`)
+  throw new GlyphPatchError(`unterminated entry for ["${key}",`)
 }
 
 /**
- * Splice every declared glyph into the map.
- *
- * All or nothing: a source key this host does not carry throws before the caller
- * can write anything, so a partially-glyphed bundle is impossible. Idempotent
- * per target — a target already present is left untouched and reported as such.
+ * Clone the `permissive` glyph entry onto the `permissive-full` key.
  *
  * @param {string} source the bundle's text
- * @returns {{ changed: boolean, source: string, added: string[], already: string[] }}
+ * @returns {{ changed: boolean, source: string, entry: string | null }}
+ *   `changed: false` means the target key was already present (idempotent no-op).
  */
 export function applyGlyphPatch(source) {
-  let next = source
-  const added = []
-  const already = []
-
-  for (const { target, source: sourceKey } of GLYPH_TARGETS) {
-    if (next.includes(`["${target}",`)) {
-      already.push(target)
-      continue
-    }
-    const { anchor } = resolveAnchor(next, sourceKey)
-    const sourceEntry = sliceEntry(next, anchor)
-    if (!sourceEntry.includes('svg')) {
-      throw new GlyphPatchError(`the ${anchor} entry does not look like a glyph`)
-    }
-    const clonedEntry = sourceEntry.replace(anchor, `["${target}",`)
-    // A function replacement: the entry is spliced verbatim, `$` never expanded.
-    next = next.replace(sourceEntry, () => `${sourceEntry},\n\t\t\t${clonedEntry}`)
-    added.push(target)
+  if (source.includes(`["${TARGET_KEY}",`)) return { changed: false, source, entry: null }
+  const sourceEntry = sliceEntry(source, SOURCE_KEY)
+  if (!sourceEntry.includes('svg')) {
+    throw new GlyphPatchError(`the ["${SOURCE_KEY}",] entry does not look like a glyph`)
   }
-
-  return { changed: added.length > 0, source: next, added, already }
+  const clonedEntry = sourceEntry.replace(`["${SOURCE_KEY}",`, `["${TARGET_KEY}",`)
+  return { changed: true, source: source.replace(sourceEntry, `${sourceEntry},\n\t\t\t${clonedEntry}`), entry: clonedEntry }
 }
 
 /** Resolve the bundle to patch, or throw with an explanation. */
@@ -301,29 +151,8 @@ export function findBundle(argv, where) {
   )
 }
 
-/**
- * A warning block naming the other DSH installs that carry this bundle.
- *
- * Reported rather than patched: on a host with a global CLI install and a
- * launcher-managed runtime, only one of them serves the UI in front of the user,
- * and picking the wrong one is invisible — the patch succeeds and the picker
- * stays icon-free. Naming the others turns that into a one-line fix (pass the
- * path explicitly).
- *
- * @param {string[]} others bundle paths that exist but were not chosen
- * @returns {string} an empty string when there is nothing to report
- */
-function describeOtherInstalls(others) {
-  if (others.length === 0) return ''
-  return `  note: ${others.length} other DSH install(s) carry this bundle — NOT patched:\n` +
-    others.map((path) => `    ${path}\n`).join('') +
-    '  If the tier still has no icon, the UI is served by one of those; re-run with\n' +
-    '  that path as the argument.\n'
-}
-
 function main(argv) {
   const check = argv.includes('--check')
-  const explicit = argv.slice(2).find((arg) => !arg.startsWith('-'))
   const where = {
     execDir: dirname(process.execPath),
     cwd: process.cwd(),
@@ -331,27 +160,17 @@ function main(argv) {
   }
 
   const bundle = findBundle(argv, where)
-  const others = explicit === undefined
-    ? candidateBundles(where).filter((candidate) => candidate !== bundle && existsSync(candidate))
-    : []
-  const otherNote = describeOtherInstalls(others)
   const original = readFileSync(bundle, 'utf8')
-  const { changed, source: patched, added, already } = applyGlyphPatch(original)
+  const { changed, source: patched } = applyGlyphPatch(original)
 
   if (!changed) {
-    process.stdout.write(
-      `patch-permission-glyph: all glyphs already present in\n  ${bundle}\n` +
-      `  present: ${already.map((key) => `["${key}",]`).join(' ')}\n` +
-      otherNote,
-    )
+    process.stdout.write(`patch-permission-glyph: ["${TARGET_KEY}",] already present in\n  ${bundle}\n`)
     return 0
   }
   if (check) {
     process.stdout.write(
-      `patch-permission-glyph: MISSING ${added.map((key) => `["${key}",]`).join(' ')} from\n  ${bundle}\n` +
-      `  present: ${already.length > 0 ? already.map((key) => `["${key}",]`).join(' ') : '(none)'}\n` +
-      '  (--check: nothing written; re-run without --check to apply)\n' +
-      otherNote,
+      `patch-permission-glyph: ["${TARGET_KEY}",] is MISSING from\n  ${bundle}\n` +
+      '  (--check: nothing written; re-run without --check to apply)\n',
     )
     return 1
   }
@@ -370,11 +189,9 @@ function main(argv) {
   }
 
   process.stdout.write(
-    `patch-permission-glyph: added ${added.map((key) => `["${key}",]`).join(' ')} to\n  ${bundle}\n` +
-    already.map((key) => `  already present: ["${key}",]\n`).join('') +
+    `patch-permission-glyph: added ["${TARGET_KEY}",] to\n  ${bundle}\n` +
     `  backup: ${backup}\n` +
-    '  NOTE: this edits a DSH package — re-run after any DSH upgrade or reinstall.\n' +
-    otherNote,
+    '  NOTE: this edits a DSH package — re-run after any DSH upgrade or reinstall.\n',
   )
   return 0
 }