dsh-eda-mcp 0.6.2 → 0.7.0

package/lib/client.js

@@ -1097,6 +1097,22 @@ function NumberField(props) {
     }
   ) });
 }
+function TextField(props) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Field, { label: props.label, hint: props.hint, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "input",
+    {
+      type: "text",
+      value: props.value ?? "",
+      placeholder: props.placeholder,
+      disabled: props.disabled,
+      onChange: (event) => {
+        const text = event.target.value.trim();
+        props.onChange(text === "" ? void 0 : text);
+      },
+      style: inputStyle
+    }
+  ) });
+}
 function BooleanField(props) {
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Field, { label: props.label, hint: props.hint, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
     import_dsh_client_ui_primitives.Switch,
@@ -1235,6 +1251,20 @@ function EdaMcpSettingsCard(props) {
           }
         }
       ),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        TextField,
+        {
+          label: t("settings.edaExecutable"),
+          hint: t("settings.edaExecutableHint"),
+          value: draft.edaExecutable,
+          placeholder: "lceda-pro.exe",
+          disabled,
+          onChange: (value) => {
+            clearNotice();
+            update("edaExecutable", value);
+          }
+        }
+      ),
       /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
         BooleanField,
         {
@@ -1417,6 +1447,8 @@ var zh = {
   "settings.toolCallTimeoutMsHint": "\u5355\u6B21 EDA API \u8C03\u7528\u8D85\u65F6\uFF0C\u9ED8\u8BA4 60000\u3002",
   "settings.allowRawApi": "\u5141\u8BB8\u901A\u7528 eda_api_call",
   "settings.allowRawApiHint": "\u5F00\u542F\u540E MCP \u5DE5\u5177 eda_api_call \u53EF\u8C03\u7528\u767D\u540D\u5355\u5185\u7684 JLCEDA \u6269\u5C55 API\u3002",
+  "settings.edaExecutable": "\u5609\u7ACB\u521BEDA \u53EF\u6267\u884C\u6587\u4EF6\uFF08\u53EF\u9009\uFF09",
+  "settings.edaExecutableHint": "\u7559\u7A7A\u5373\u81EA\u52A8\u63A2\u6D4B\uFF1A\u73AF\u5883\u53D8\u91CF \u2192 \u6CE8\u518C\u8868\u767B\u8BB0\u7684\u6587\u4EF6\u5173\u8054 \u2192 \u5E38\u89C1\u5B89\u88C5\u76EE\u5F55 \u2192 PATH\u3002\u53EA\u6709\u81EA\u52A8\u63A2\u6D4B\u5931\u8D25\u65F6\u624D\u9700\u8981\u586B\u5B8C\u6574\u8DEF\u5F84\u3002",
   "settings.save": "\u4FDD\u5B58",
   "settings.saving": "\u4FDD\u5B58\u4E2D\u2026",
   "settings.saved": "\u5DF2\u4FDD\u5B58",
@@ -1445,6 +1477,8 @@ var en = {
   "settings.toolCallTimeoutMsHint": "Timeout for one EDA API call; default 60000.",
   "settings.allowRawApi": "Allow generic eda_api_call",
   "settings.allowRawApiHint": "Expose the eda_api_call tool restricted to the allow-listed JLCEDA APIs.",
+  "settings.edaExecutable": "JLCEDA Pro executable (optional)",
+  "settings.edaExecutableHint": "Leave empty to auto-detect: environment variable, the file-association command in the registry, conventional install directories, then PATH. Set a full path only when auto-detection fails.",
   "settings.save": "Save",
   "settings.saving": "Saving\u2026",
   "settings.saved": "Saved",

package/lib/index.js

@@ -492,7 +492,9 @@ var Config = z.object({
   enabled: z.boolean().default(true).volatile(),
   announceToAgent: z.boolean().default(true).volatile(),
   toolCallTimeoutMs: z.number().min(1e3).max(3e5).default(6e4).volatile(),
-  allowRawApi: z.boolean().default(true).volatile()
+  allowRawApi: z.boolean().default(true).volatile(),
+  /** Optional path to lceda-pro.exe; empty means "let eda_launch discover it". */
+  edaExecutable: z.string().default("").volatile()
 });
 var FIBER_DISPOSED = 4;
 var FIBER_UNLOADING = 5;
@@ -544,7 +546,9 @@ function bridgeLaunchFor(active) {
     env: {
       ...runtime.extraEnv,
       DSH_EDA_MCP_ALLOW_RAW_API: allowRawApi ? "1" : "0",
-      DSH_EDA_MCP_TOOL_TIMEOUT_MS: String(toolCallTimeoutMs)
+      DSH_EDA_MCP_TOOL_TIMEOUT_MS: String(toolCallTimeoutMs),
+      // eda_launch falls back to the registry / install dirs / PATH when empty.
+      DSH_EDA_EXECUTABLE: typeof active.edaExecutable === "string" ? active.edaExecutable : ""
     },
     cwd: dirname2(BRIDGE_PATH),
     toolCallTimeoutMs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-eda-mcp",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "DeepSeek Harness (DSH) plugin — connects DSH to JLCEDA Pro (EasyEDA Pro) via a local MCP bridge and draws schematics through the JLCEDA extension API.",
   "license": "Apache-2.0",
   "author": {
@@ -49,6 +49,7 @@
     "test",
     "docs",
     "jlc-extension",
+    "dsh-eda-bridge-extension-*.zip",
     "dsh-eda-bridge-extension.zip",
     "cordis.patch.yml",
     "CHANGELOG.md",
@@ -72,9 +73,10 @@
   "scripts": {
     "build": "node build.mjs",
     "typecheck": "tsc --noEmit",
-    "test": "node --experimental-strip-types test/node-runtime.test.ts && node --experimental-strip-types test/config-values.test.ts && node --experimental-strip-types test/design-rules.test.ts && node --experimental-strip-types test/seams.test.ts",
+    "test": "node --experimental-strip-types test/node-runtime.test.ts && node --experimental-strip-types test/config-values.test.ts && node --experimental-strip-types test/design-rules.test.ts && node --experimental-strip-types test/seams.test.ts && node --experimental-strip-types test/eda-launch.test.ts",
     "seam-check": "node scripts/seam-check.mjs",
-    "check": "pnpm typecheck && pnpm test && pnpm build",
+    "contract-check": "node scripts/contract-check.mjs",
+    "check": "pnpm typecheck && pnpm test && pnpm contract-check && pnpm build",
     "docs": "node scripts/gen-tools-doc.mjs",
     "prepublishOnly": "pnpm check",
     "prepare": "pnpm build"

package/src/bridge/eda-launch.ts

@@ -0,0 +1,267 @@
+/**
+ * Launching JLCEDA Pro (EasyEDA Pro) from a tool call.
+ *
+ * Nothing here is machine-specific: the executable is resolved from an explicit
+ * override, an environment variable, the registry entry the installer creates, a
+ * list of conventional install directories, and finally PATH. Every step is
+ * skipped when its inputs are absent.
+ *
+ * String operations only (no regex literals): the discovery rules stay readable
+ * and the resolution order is unit-tested without spawning anything.
+ */
+
+export type Platform = 'win32' | 'darwin' | 'linux' | (string & {})
+
+/** Everything the resolver needs from the outside world. */
+export interface LaunchProbe {
+  platform: Platform
+  env: Record<string, string | undefined>
+  exists: (path: string) => boolean
+  /** Raw stdout of the registry query, or undefined when the key does not exist. */
+  registryQuery: (key: string, valueName?: string) => string | undefined
+}
+
+export interface ResolveOptions {
+  executable?: string
+  project?: string
+}
+
+export type ExecutableSource = 'config' | 'env' | 'registry' | 'install-dir' | 'path'
+
+export interface ResolvedLaunch {
+  executable: string
+  source: ExecutableSource
+}
+
+export const EXECUTABLE_ENV_KEYS = ['DSH_EDA_EXECUTABLE', 'JLCEDA_EXECUTABLE'] as const
+export const EXECUTABLE_NAMES = ['lceda-pro.exe', 'lceda-pro', 'LCEDA Pro'] as const
+export const PROJECT_EXTENSIONS = ['.eprj2', '.eprj'] as const
+
+const CN_PRO_EDITION = '嘉立创EDA专业版'
+const CLASSES = 'Software\\Classes'
+
+export const INSTALL_SUFFIXES = [
+  'lceda-pro',
+  'Program Files\\lceda-pro',
+  'Program Files (x86)\\lceda-pro',
+  'Program Files\\' + CN_PRO_EDITION,
+  'Program Files (x86)\\' + CN_PRO_EDITION,
+] as const
+
+/** Strip trailing path separators from a directory. */
+function trimSeparator(value: string): string {
+  let end = value.length
+  while (end > 0) {
+    const ch = value[end - 1]
+    if (ch !== '\\' && ch !== '/') break
+    end -= 1
+  }
+  return value.slice(0, end)
+}
+
+/** Strip leading path separators. */
+function trimLeadingSeparators(value: string): string {
+  let start = 0
+  while (start < value.length && (value[start] === '\\' || value[start] === '/')) start += 1
+  return value.slice(start)
+}
+
+function joinPath(platform: Platform, ...parts: string[]): string {
+  const separator = platform === 'win32' ? '\\' : '/'
+  return parts
+    .filter(part => part !== '')
+    .map((part, index) => (index === 0 ? part : trimLeadingSeparators(part)))
+    .join(separator)
+}
+
+/** Split an install suffix into path segments, on either separator. */
+function splitSegments(value: string): string[] {
+  return value.split('\\').join('/').split('/').filter(part => part !== '')
+}
+
+/**
+ * Pull the executable out of a registered open command such as
+ * `"D:\\lceda-pro\\lceda-pro.exe" "%1"` or `C:\\App\\lceda-pro.exe %1`.
+ */
+export function parseExecutableFromCommand(command: string | undefined): string | undefined {
+  const text = (command ?? '').trim()
+  if (text === '') return undefined
+  if (text.startsWith('"')) {
+    const end = text.indexOf('"', 1)
+    if (end === -1) return undefined
+    const quoted = text.slice(1, end).trim()
+    return quoted === '' ? undefined : quoted
+  }
+  const space = text.indexOf(' ')
+  const tab = text.indexOf(String.fromCharCode(9))
+  const stops = [space, tab].filter(index => index > 0)
+  const end = stops.length === 0 ? text.length : Math.min(...stops)
+  const first = text.slice(0, end).trim()
+  return first === '' ? undefined : first
+}
+
+/**
+ * Decode `reg` output. The tool writes in the console code page (GBK on a Chinese
+ * Windows), and progid names are non-ASCII, so a UTF-8 decode can produce
+ * replacement characters that no longer match a registry key. When that happens,
+ * decode again as GBK (both decoders ship with the Node the host provides).
+ */
+export function decodeRegistryOutput(raw: Uint8Array): string {
+  const utf8 = new TextDecoder('utf-8').decode(raw)
+  if (!utf8.includes(String.fromCharCode(0xFFFD))) return utf8
+  try {
+    return new TextDecoder('gbk').decode(raw)
+  } catch {
+    return utf8
+  }
+}
+
+/** Take the string payload of a registry line (`... REG_SZ  <value>`). */
+export function parseRegStringValue(output: string | undefined): string | undefined {
+  for (const raw of (output ?? '').split(String.fromCharCode(10))) {
+    const line = raw.trim()
+    const index = line.toUpperCase().indexOf('REG_SZ')
+    if (index === -1) continue
+    const value = line.slice(index + 'REG_SZ'.length).trim()
+    // `reg query` prints "(value not set)" for an unset default; it is not a value.
+    if (value === '' || value.startsWith('(')) continue
+    return value
+  }
+  return undefined
+}
+
+/** Value names of a registry listing (the first column of every value line). */
+export function parseRegValueNames(output: string | undefined): string[] {
+  const names: string[] = []
+  for (const raw of (output ?? '').split(String.fromCharCode(10))) {
+    const line = raw.trim()
+    const marker = line.indexOf('REG_')
+    if (marker <= 0) continue
+    const name = line.slice(0, marker).trim()
+    if (name !== '' && !name.startsWith('HKEY')) names.push(name)
+  }
+  return names
+}
+
+function firstExisting(probe: LaunchProbe, candidates: string[]): string | undefined {
+  for (const candidate of candidates) {
+    if (candidate !== '' && probe.exists(candidate)) return candidate
+  }
+  return undefined
+}
+
+/** Candidate executables derived from environment variables (no registry access). */
+export function envCandidates(probe: LaunchProbe): string[] {
+  const env = probe.env
+  const roots = [
+    env.ProgramFiles,
+    env['ProgramFiles(x86)'],
+    env.LOCALAPPDATA === undefined ? undefined : joinPath(probe.platform, env.LOCALAPPDATA, 'Programs'),
+    env.APPDATA === undefined ? undefined : joinPath(probe.platform, env.APPDATA, 'Programs'),
+    env.SystemDrive,
+    env.USERPROFILE,
+    env.HOME,
+  ].filter((root): root is string => typeof root === 'string' && root !== '')
+
+  const candidates: string[] = []
+  for (const root of roots) {
+    for (const suffix of INSTALL_SUFFIXES) {
+      for (const name of EXECUTABLE_NAMES) {
+        candidates.push(joinPath(probe.platform, trimSeparator(root), ...splitSegments(suffix), name))
+      }
+    }
+  }
+  return candidates
+}
+
+/** Look for the executable in the directories listed on PATH. */
+export function pathCandidates(probe: LaunchProbe): string[] {
+  const raw = probe.env.PATH ?? probe.env.Path ?? ''
+  const separator = probe.platform === 'win32' ? ';' : ':'
+  return raw
+    .split(separator)
+    .filter(dir => dir.trim() !== '')
+    .flatMap(dir => EXECUTABLE_NAMES.map(name => joinPath(probe.platform, trimSeparator(dir), name)))
+}
+
+/**
+ * Ask the registry where the installer registered the project handler.
+ *
+ * The extension's default progid is often empty while `OpenWithProgids` lists the
+ * real one, so both are consulted. HKCU wins over HKLM; HKCR is skipped because
+ * it merges the two.
+ */
+export function registryCandidates(probe: LaunchProbe): string[] {
+  if (probe.platform !== 'win32') return []
+  const found: string[] = []
+  for (const hive of ['HKCU', 'HKLM']) {
+    for (const extension of PROJECT_EXTENSIONS) {
+      const base = hive + '\\' + CLASSES + '\\' + extension
+      const defaults = [parseRegStringValue(probe.registryQuery(base, '')), parseRegStringValue(probe.registryQuery(base))]
+      const progids = [
+        ...defaults.filter((value): value is string => value !== undefined),
+        ...parseRegValueNames(probe.registryQuery(base + '\\OpenWithProgids')),
+      ]
+      for (const progid of progids) {
+        if (progid.startsWith('Applications' + '\\')) continue
+        const command = parseRegStringValue(
+          probe.registryQuery(hive + '\\' + CLASSES + '\\' + progid + '\\shell\\open\\command'),
+        )
+        const executable = parseExecutableFromCommand(command)
+        if (executable !== undefined) found.push(executable)
+      }
+    }
+  }
+  return found
+}
+
+/** Resolve the executable, or undefined when nothing on this machine matches. */
+export function resolveExecutable(probe: LaunchProbe, options: ResolveOptions = {}): ResolvedLaunch | undefined {
+  const override = options.executable?.trim()
+  if (override !== undefined && override !== '' && probe.exists(override)) {
+    return { executable: override, source: 'config' }
+  }
+
+  for (const key of EXECUTABLE_ENV_KEYS) {
+    const value = probe.env[key]?.trim()
+    if (value !== undefined && value !== '' && probe.exists(value)) return { executable: value, source: 'env' }
+  }
+
+  const fromRegistry = firstExisting(probe, registryCandidates(probe))
+  if (fromRegistry !== undefined) return { executable: fromRegistry, source: 'registry' }
+
+  const fromInstallDir = firstExisting(probe, envCandidates(probe))
+  if (fromInstallDir !== undefined) return { executable: fromInstallDir, source: 'install-dir' }
+
+  const fromPath = firstExisting(probe, pathCandidates(probe))
+  if (fromPath !== undefined) return { executable: fromPath, source: 'path' }
+
+  return undefined
+}
+
+/** Arguments used to open the app (and optionally a project) on each platform. */
+export function buildLaunchArgs(platform: Platform, executable: string, project?: string): { command: string; args: string[] } {
+  const target = project?.trim()
+  const hasProject = target !== undefined && target !== ''
+  if (platform === 'darwin') {
+    return hasProject
+      ? { command: 'open', args: ['-a', executable, target as string] }
+      : { command: 'open', args: ['-a', executable] }
+  }
+  return hasProject ? { command: executable, args: [target as string] } : { command: executable, args: [] }
+}
+
+/**
+ * Windows script used to hand the launch to the running Explorer shell.
+ *
+ * Spawning `lceda-pro.exe` directly from a host process (or even through
+ * `Start-Process`) makes it start and exit immediately, while double-clicking the
+ * same executable works. Explorer runs in the interactive desktop, so executing a
+ * script through it reproduces the double-click context; the script then starts the
+ * app with the optional project argument.
+ */
+export function buildLaunchScript(executable: string, project?: string): string {
+  const target = project?.trim()
+  const args = target === undefined || target === '' ? '' : ' "' + target + '"'
+  return ['@echo off', 'start "" "' + executable + '"' + args, ''].join(String.fromCharCode(13, 10))
+}