dsh-cad 0.12.2 → 0.13.0

package/lib/index.js

@@ -9,6 +9,7 @@ import { createFreeCadTool } from './tools/cad-freecad.js';
 import { createFusionTool } from './tools/cad-fusion.js';
 import { createOnshapeTool } from './tools/cad-onshape.js';
 import { createCadImageTool } from './tools/cad-image.js';
+import { createCadScriptTool } from './tools/cad-script.js';
 export const name = 'dsh-cad';
 /** Hard dependencies: the tool registry. */
 export const inject = ['tools'];
@@ -18,23 +19,39 @@ export function apply(ctx, config = {}) {
     const binStore = new BinarySceneStore(root);
     const registry = new DocumentRegistry(process.cwd());
     const workspaceRoot = process.cwd();
-    let routeRegistered = false;
+    // The routes live on the host's shared webServer, which outlives this
+    // plugin instance: hosts that hot-reload (the desktop runtime) re-run
+    // apply() in the same process, and the server throws on duplicate
+    // (kind, path). Every register disposer must therefore run on disposal —
+    // leaking them makes the next apply() throw and breaks every
+    // viewer-dependent tool call until a process restart.
+    let routeDisposers = [];
     /** Idempotently register the scene routes; returns the JSON base or null. */
     const ensureSceneRoute = () => {
-        if (routeRegistered)
+        if (routeDisposers.length > 0)
             return '/dsh-cad/scene';
         const scope = ctx;
         const server = (scope.get?.('webServer') ?? scope.get?.('httpServer'));
         if (server === undefined)
             return null;
-        registerSceneRoute(server, store);
-        registerBinRoute(server, binStore);
-        registerDemoRoute(server);
-        registerDocsRoute(server, registry, binStore);
-        registerDocsDeleteRoute(server, registry);
-        registerAssemblyRoute(server, registry);
-        registerFeatureTreeRoute(server, registry);
-        routeRegistered = true;
+        const pending = [];
+        try {
+            pending.push(registerSceneRoute(server, store));
+            pending.push(registerBinRoute(server, binStore));
+            pending.push(registerDemoRoute(server));
+            pending.push(registerDocsRoute(server, registry, binStore));
+            pending.push(registerDocsDeleteRoute(server, registry));
+            pending.push(registerAssemblyRoute(server, registry));
+            pending.push(registerFeatureTreeRoute(server, registry));
+        }
+        catch (error) {
+            // Roll back the partial batch, or the next attempt trips the duplicate
+            // guard on the routes that did register.
+            for (const dispose of pending)
+                dispose();
+            throw error;
+        }
+        routeDisposers = pending;
         return '/dsh-cad/scene';
     };
     // The demo route backs the CAD editor's startup fetch (before any tool
@@ -43,7 +60,7 @@ export function apply(ctx, config = {}) {
     // briefly; fiber ordering decides the exact moment.
     let attempts = 0;
     const retry = setInterval(() => {
-        if (routeRegistered || ++attempts > 200) {
+        if (routeDisposers.length > 0 || ++attempts > 200) {
             clearInterval(retry);
             return;
         }
@@ -67,6 +84,7 @@ export function apply(ctx, config = {}) {
     const cadFusion = createFusionTool({ store: binStore, workspaceRoot, ensureSceneRoute });
     const cadOnshape = createOnshapeTool({ store: binStore, workspaceRoot, ensureSceneRoute });
     const cadImage = createCadImageTool({ store, workspaceRoot, ensureSceneRoute });
+    const cadScript = createCadScriptTool({ workspaceRoot });
     const disposers = [
         ctx.tools.register(cadView),
         ctx.tools.register(cadInfo),
@@ -75,12 +93,16 @@ export function apply(ctx, config = {}) {
         ctx.tools.register(cadFusion),
         ctx.tools.register(cadOnshape),
         ctx.tools.register(cadImage),
+        ctx.tools.register(cadScript),
     ];
     ctx.effect(() => {
         return () => {
             clearInterval(retry);
             for (const dispose of disposers)
                 dispose();
+            for (const dispose of routeDisposers)
+                dispose();
+            routeDisposers = [];
         };
     });
 }

package/lib/routes.js

@@ -169,7 +169,26 @@ export function registerDocsRoute(server, registry, binStore) {
                     // Preview URL only when a published scene exists (memory or mirror).
                     ...(await binStore.has(doc.id) ? { sceneUrl: `${BIN_ROUTE_PATH}/${doc.id}` } : {}),
                 })));
-                const body = Buffer.from(JSON.stringify({ docs: entries }));
+                // The panel's host-independent channel: with ?session=<id>, also
+                // report that session's bound (active) document and its versioned
+                // scene URL. The resident panel polls this when the conversation
+                // meta pipeline is unavailable (host version drift, cold start) —
+                // its own route keeps the Part tab live across host UI changes.
+                const sessionId = new URL(req.url ?? '/', 'http://localhost').searchParams.get('session');
+                let active;
+                if (sessionId !== null) {
+                    const bound = await registry.bindingOf(sessionId);
+                    const doc = bound === null ? undefined : docs.find((entry) => entry.id === bound);
+                    if (doc !== undefined) {
+                        active = {
+                            id: doc.id,
+                            name: doc.name,
+                            version: doc.opCount,
+                            ...(await binStore.has(doc.id) ? { sceneUrl: `${BIN_ROUTE_PATH}/${doc.id}?v=${doc.opCount}` } : {}),
+                        };
+                    }
+                }
+                const body = Buffer.from(JSON.stringify({ docs: entries, ...(active !== undefined ? { active } : {}) }));
                 res.writeHead(200, {
                     'content-type': 'application/json',
                     'content-length': body.length,

package/lib/tools/cad-script.js

@@ -0,0 +1,226 @@
+/**
+ * The `cad_script` tool: deterministic script evaluation for geometry math —
+ * generating profile point arrays, arc coordinates, transform matrices —
+ * without a CAD kernel round-trip.
+ *
+ * `language: "js"` runs in-process (Node vm, no child process), which keeps
+ * it usable in hosts whose shell tool is sandboxed or broken — the desktop
+ * runtime's pwsh can fail outright (exit 0xC0000142), leaving this as the
+ * only execution path. `language: "py"` uses a system Python interpreter
+ * when the host permits spawning one.
+ */
+import { spawn, spawnSync } from 'node:child_process';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import vm from 'node:vm';
+import { defineTool } from '@deepseek-ai/dsh-tools';
+const JS_DEFAULT_TIMEOUT = 10_000;
+const PY_DEFAULT_TIMEOUT = 30_000;
+const TIMEOUT_CAP = 120_000;
+const OUTPUT_CAP = 20_000;
+function clampTimeout(value, fallback) {
+    const n = typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+    return Math.min(Math.max(Math.trunc(n), 100), TIMEOUT_CAP);
+}
+function truncate(text) {
+    return text.length > OUTPUT_CAP ? `${text.slice(0, OUTPUT_CAP)}\n… (truncated at ${OUTPUT_CAP} chars)` : text;
+}
+function formatValue(value) {
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+/** Evaluate synchronous JavaScript in a fresh vm realm; no require/process. */
+function evalJs(code, timeoutMs) {
+    const lines = [];
+    const push = (...values) => lines.push(values.map(formatValue).join(' '));
+    const context = vm.createContext({
+        console: { log: push, info: push, warn: push, error: push, debug: push },
+    });
+    let completion;
+    try {
+        completion = vm.runInContext(code, context, { timeout: timeoutMs });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, stdout: truncate(lines.join('\n')), error: message };
+    }
+    // Thenable check instead of instanceof Promise: the vm realm has its own
+    // Promise class, so realm-crossing promises fail instanceof.
+    if (completion !== undefined && completion !== null && typeof completion.then === 'function') {
+        return { ok: false, stdout: truncate(lines.join('\n')), error: 'asynchronous completion value — keep the script synchronous (no await)' };
+    }
+    const outcome = { ok: true, stdout: truncate(lines.join('\n')) };
+    if (completion !== undefined) {
+        try {
+            outcome.resultJson = JSON.stringify(completion);
+        }
+        catch {
+            outcome.resultJson = String(completion);
+        }
+    }
+    return outcome;
+}
+let cachedPython;
+/** Probe for a system Python once; null when none is installed/runnable. */
+function findPython() {
+    if (cachedPython !== undefined)
+        return cachedPython;
+    const candidates = [
+        { cmd: 'python', args: [] },
+        { cmd: 'py', args: ['-3'] },
+        { cmd: 'python3', args: [] },
+    ];
+    for (const candidate of candidates) {
+        try {
+            const probe = spawnSync(candidate.cmd, [...candidate.args, '--version'], { timeout: 5_000 });
+            if (probe.error === undefined && probe.status === 0) {
+                cachedPython = candidate;
+                return candidate;
+            }
+        }
+        catch {
+            /* spawn blocked entirely — try the next candidate */
+        }
+    }
+    cachedPython = null;
+    return null;
+}
+/** Run a Python script file, capturing stdout/stderr with a hard timeout. */
+async function evalPy(code, timeoutMs, workspaceRoot) {
+    const python = findPython();
+    if (python === null) {
+        return {
+            ok: false,
+            stdout: '',
+            error: 'no runnable Python interpreter (python / py / python3 all failed to launch — the host may be blocking process creation). ' +
+                'Retry with language: "js", which runs in-process.',
+        };
+    }
+    const dir = path.join(workspaceRoot, '.dsh-cad', 'tmp');
+    await mkdir(dir, { recursive: true });
+    const file = path.join(dir, `eval-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.py`);
+    await writeFile(file, code, 'utf8');
+    try {
+        return await new Promise((resolve) => {
+            let child;
+            try {
+                child = spawn(python.cmd, [...python.args, file], { cwd: workspaceRoot });
+            }
+            catch (error) {
+                resolve({ ok: false, stdout: '', error: `failed to launch ${python.cmd}: ${error instanceof Error ? error.message : String(error)} — retry with language: "js"` });
+                return;
+            }
+            let stdout = '';
+            let stderr = '';
+            child.stdout.on('data', (chunk) => {
+                if (stdout.length < OUTPUT_CAP)
+                    stdout += chunk.toString('utf8');
+            });
+            child.stderr.on('data', (chunk) => {
+                if (stderr.length < OUTPUT_CAP)
+                    stderr += chunk.toString('utf8');
+            });
+            const timer = setTimeout(() => {
+                child.kill();
+                resolve({ ok: false, stdout: truncate(stdout), stderr: truncate(stderr), error: `python timed out after ${timeoutMs} ms` });
+            }, timeoutMs);
+            child.on('error', (error) => {
+                clearTimeout(timer);
+                resolve({ ok: false, stdout: truncate(stdout), error: `failed to launch ${python.cmd}: ${error.message} — retry with language: "js"` });
+            });
+            child.on('close', (code2, signal) => {
+                clearTimeout(timer);
+                if (code2 === 0) {
+                    resolve({ ok: true, stdout: truncate(stdout), ...(stderr !== '' ? { stderr: truncate(stderr) } : {}) });
+                }
+                else {
+                    resolve({
+                        ok: false,
+                        stdout: truncate(stdout),
+                        stderr: truncate(stderr),
+                        error: `python exited with code ${String(code2)}${signal === null ? '' : ` (signal ${signal})`}`,
+                    });
+                }
+            });
+        });
+    }
+    finally {
+        await rm(file, { force: true });
+    }
+}
+/** Build the cad_script tool definition. */
+export function createCadScriptTool(deps) {
+    return defineTool({
+        name: 'cad_script',
+        description: 'Evaluate a short script for deterministic geometry math (profile point arrays, arc coordinates, transform math) — no CAD ' +
+            'kernel involved. language "js" runs in-process (Node vm; no shell or child process needed, so it works even when the host ' +
+            'shell tool is unavailable); the script must be synchronous, its completion value (last expression) is returned as resultJson, ' +
+            'and console.log output is captured. language "py" runs a system Python interpreter (python / py -3 / python3) and captures ' +
+            'stdout/stderr. Prefer this over the host shell for numeric work.',
+        parameters: {
+            language: {
+                type: 'string',
+                required: true,
+                enum: ['js', 'py'],
+                description: 'Script language: "js" (in-process Node vm, always available) or "py" (system Python).',
+            },
+            code: {
+                type: 'string',
+                required: true,
+                description: 'Script source. js: synchronous, completion value (last expression) becomes resultJson. py: use print() for output.',
+            },
+            timeoutMs: {
+                type: 'number',
+                description: `Execution timeout in ms (default ${JS_DEFAULT_TIMEOUT} for js, ${PY_DEFAULT_TIMEOUT} for py; capped at ${TIMEOUT_CAP}).`,
+            },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    ok: { type: 'boolean', required: true },
+                    language: { type: 'string', required: true },
+                    resultJson: { type: 'string', description: 'JSON-stringified completion value (js only, when defined).' },
+                    stdout: { type: 'string', required: true, description: 'Captured console.log (js) or stdout (py).' },
+                    stderr: { type: 'string', description: 'Captured stderr (py only, when non-empty).' },
+                    error: { type: 'string', description: 'Failure reason when ok is false.' },
+                },
+            },
+            render: (_args, value) => {
+                const lines = [`eval (${value.language}) — ${value.ok ? 'ok' : 'failed'}`];
+                if (value.resultJson !== undefined)
+                    lines.push(`result: ${value.resultJson}`);
+                if (value.stdout !== '')
+                    lines.push(value.stdout);
+                if (value.stderr !== undefined)
+                    lines.push(`stderr: ${value.stderr}`);
+                if (value.error !== undefined)
+                    lines.push(`error: ${value.error}`);
+                return [{ type: 'text', text: lines.join('\n') }];
+            },
+        },
+        timeoutMs: TIMEOUT_CAP + 15_000,
+        isConcurrencySafe: () => true,
+        async execute(args) {
+            const timeoutMs = clampTimeout(args.timeoutMs, args.language === 'py' ? PY_DEFAULT_TIMEOUT : JS_DEFAULT_TIMEOUT);
+            const outcome = args.language === 'py' ? await evalPy(args.code, timeoutMs, deps.workspaceRoot) : evalJs(args.code, timeoutMs);
+            return {
+                ok: outcome.ok,
+                language: args.language,
+                ...(outcome.resultJson === undefined ? {} : { resultJson: outcome.resultJson }),
+                stdout: outcome.stdout,
+                ...(outcome.stderr === undefined ? {} : { stderr: outcome.stderr }),
+                ...(outcome.error === undefined ? {} : { error: outcome.error }),
+            };
+        },
+        presentCall: (args) => ({ card: 'generic', title: `CAD script (${String(args.language)})`, kind: 'other' }),
+        presentResult: () => ({ card: 'generic', title: 'CAD script' }),
+    });
+}

package/lib/types/tools/cad-script.d.ts

@@ -0,0 +1,6 @@
+import type { ToolDefinition } from '@deepseek-ai/dsh-tools';
+export interface CadScriptToolDeps {
+    workspaceRoot: string;
+}
+/** Build the cad_script tool definition. */
+export declare function createCadScriptTool(deps: CadScriptToolDeps): ToolDefinition;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-cad",
   "description": "CAD visualization plugin for DeepSeek Harness: cad_view / cad_info tools with an embedded 3D (STL/OBJ/STEP/IGES) and 2D (DXF/SVG) viewer card in the Web UI",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "type": "module",
   "license": "MIT",
   "author": "LAU-MARS",