dsh-plugin-blender-3d 0.1.1 → 0.2.0

package/lib/bridge-client.js

@@ -8,14 +8,38 @@
  * geometry stays in Python and is written to disk (OOM-safe, see SKILL.md).
  */
 
-import { spawn } from "node:child_process";
+import { spawn, execFile } from "node:child_process";
 import http from "node:http";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const BRIDGE_PATH = path.join(__dirname, "runtime", "headless_bridge.py");
 
+// Persisted setup config (written by lib/setup.js). Read here directly to keep
+// setup.js an optional import and avoid a circular dependency.
+const _DATA_DIR = process.env.DSH_HOME
+  ? path.join(process.env.DSH_HOME, ".blender-plugin")
+  : path.join(os.homedir(), ".blender-plugin");
+const _CONFIG_PATH = path.join(_DATA_DIR, "config.json");
+
+/** Return the configured python binary path, or null. Never throws. */
+function readConfigPython() {
+  try {
+    const cfg = JSON.parse(fs.readFileSync(_CONFIG_PATH, "utf8"));
+    return cfg && typeof cfg.pythonPath === "string" ? cfg.pythonPath : null;
+  } catch { return null; }
+}
+
+/** Quick `python -c "import trimesh"` probe. Never throws. */
+function hasTrimesh(python) {
+  return new Promise((resolve) => {
+    execFile(python, ["-c", "import trimesh"], { timeout: 8000 }, (err) => resolve(!err));
+  });
+}
+
 // Module-level handle so we don't double-spawn within one harness process.
 let _child = null;
 
@@ -38,11 +62,7 @@ function healthCheck(host, port, timeoutMs = 2000) {
   });
 }
 
-export async function ensureBridge(opts = {}) {
-  const host = opts.host || "127.0.0.1";
-  const port = Number(opts.port || process.env.AIB_PORT || 13082);
-  const python = opts.python || process.env.AIB_PYTHON || "python3";
-
+async function tryStart(python, host, port, startupMs) {
   // Already up?
   const up = await healthCheck(host, port);
   if (up && up.ok) return { host, port, spawned: false, health: up };
@@ -59,13 +79,42 @@ export async function ensureBridge(opts = {}) {
   }
 
   // Poll for readiness.
-  const deadline = Date.now() + (opts.startupMs || 20000);
+  const deadline = Date.now() + (startupMs || 20000);
   while (Date.now() < deadline) {
     await new Promise((r) => setTimeout(r, 300));
     const h = await healthCheck(host, port);
     if (h && h.ok) return { host, port, spawned: true, health: h };
   }
-  throw new Error(`blender bridge did not come up on http://${host}:${port}`);
+  return null; // did not come up
+}
+
+export async function ensureBridge(opts = {}) {
+  const host = opts.host || "127.0.0.1";
+  const port = Number(opts.port || process.env.AIB_PORT || 13082);
+  const startupMs = opts.startupMs || 20000;
+  let python = opts.python || readConfigPython() || process.env.AIB_PYTHON || "python3";
+
+  let r = await tryStart(python, host, port, startupMs);
+  if (r) return r;
+
+  // Bounded auto-setup: if the bridge failed to start and trimesh is missing in
+  // the chosen python, create the deps venv once and retry with that python.
+  if (opts.autoSetup !== false) {
+    const ok = await hasTrimesh(python);
+    if (!ok) {
+      try {
+        const setup = await import("./setup.js");
+        const deps = await setup.ensurePythonDeps({ python, force: false });
+        if (deps.ok && deps.pythonPath) {
+          python = deps.pythonPath;
+          r = await tryStart(python, host, port, startupMs);
+          if (r) return r;
+        }
+      } catch { /* best-effort; fall through to error */ }
+    }
+  }
+
+  throw new Error(`blender bridge did not come up on http://${host}:${port} (python=${python})`);
 }
 
 export function sendCommand({ host, port, command, args = {}, id = 1, timeoutMs = 60000 }) {

package/lib/index.js

@@ -17,6 +17,7 @@
  */
 
 import { call, ensureBridge, stopBridge } from "./bridge-client.js";
+import { setup as runSetup } from "./setup.js";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 import fs from "node:fs";
@@ -108,6 +109,38 @@ export function apply(ctx, config = {}) {
     },
   });
 
+  // Auto environment setup: detect → install deps (venv) → optional Blender → verify.
+  ctx.tools.register({
+    name: "blender_setup",
+    description:
+      "Auto-detect, install, configure, and verify the Blender 3D modeling " +
+      "environment. Creates an isolated Python venv with numpy/trimesh/manifold3d " +
+      "(no Blender needed for headless modeling/export). Set install_blender=true " +
+      "to also fetch a portable Blender (linux x64; other platforms get instructions). " +
+      "Returns a JSON report with detected paths, actions taken, and verification results.",
+    parameters: schema({
+      install_blender: { type: "boolean", description: "also download+install Blender (linux x64; default false)" },
+      blender_version: { type: "string", description: "Blender version to fetch, e.g. 4.2.0" },
+      force: { type: "boolean", description: "recreate the venv even if it exists" },
+    }),
+    output: {
+      schema: { type: "object", additionalProperties: false, properties: { text: { type: "string" } }, required: ["text"] },
+      render: (_a, v) => [{ type: "text", text: v.text }],
+    },
+    async execute(args, _exec) {
+      try {
+        const report = await runSetup({
+          installBlender: args?.install_blender === true,
+          blenderVersion: args?.blender_version,
+          force: args?.force === true,
+        });
+        return { text: JSON.stringify(report, null, 2) };
+      } catch (e) {
+        return { text: JSON.stringify({ ok: false, error: e.message }, null, 2) };
+      }
+    },
+  });
+
   // Stop the spawned bridge when the harness tears down this composition.
   try {
     ctx.effect(function* () { yield async () => stopBridge(); }, "blender-3d-bridge");

package/lib/setup.js

@@ -0,0 +1,280 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Environment bootstrap for dsh-plugin-blender-3d — detect, install,
+ * configure, verify. Node stdlib only; ESM. No function throws: failures are
+ * returned as `{ ok: false, detail }` so a tool caller always gets a report.
+ *
+ * Two runtimes:
+ *  - headless: pure-Python `headless_bridge.py` (trimesh + manifold3d). Needs
+ *    `pip install numpy trimesh manifold3d`. This is the default and needs no
+ *    Blender. `ensurePythonDeps` creates an isolated venv for it.
+ *  - bpy add-on: needs a real Blender install. `ensureBlender` can fetch a
+ *    portable Blender (linux tar.xz) on request; mac/win return instructions.
+ */
+
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import https from "node:https";
+import { createWriteStream } from "node:fs";
+
+const DATA_DIR = process.env.DSH_HOME
+  ? path.join(process.env.DSH_HOME, ".blender-plugin")
+  : path.join(os.homedir(), ".blender-plugin");
+const CONFIG_PATH = path.join(DATA_DIR, "config.json");
+
+export function getConfigPath() { return CONFIG_PATH; }
+
+/** Read persisted config (pythonPath/blenderPath/...). Never throws. */
+export function readConfig() {
+  try {
+    const raw = fs.readFileSync(CONFIG_PATH, "utf8");
+    return JSON.parse(raw);
+  } catch { return null; }
+}
+
+function mkdirp(p) { try { fs.mkdirSync(p, { recursive: true }); } catch { /* ignore */ } }
+
+/** Run a command, return {ok, stdout, stderr, code}. Never throws. */
+function run(cmd, args = [], { timeout = 10000 } = {}) {
+  return new Promise((resolve) => {
+    execFile(cmd, args, { timeout, maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
+      if (err) resolve({ ok: false, stdout: stdout || "", stderr: (stderr || "") + (err.message || ""), code: err.code ?? null });
+      else resolve({ ok: true, stdout: stdout || "", stderr: stderr || "", code: 0 });
+    });
+  });
+}
+
+function venvBin(venvPath) {
+  return process.platform === "win32"
+    ? { python: path.join(venvPath, "Scripts", "python.exe"), pip: path.join(venvPath, "Scripts", "pip.exe") }
+    : { python: path.join(venvPath, "bin", "python"), pip: path.join(venvPath, "bin", "pip") };
+}
+
+// ---------------------------------------------------------------------------
+// detect
+// ---------------------------------------------------------------------------
+
+async function findPython() {
+  for (const c of ["python3", "python"]) {
+    const v = await run(c, ["--version"]);
+    if (v.ok) {
+      const version = (v.stdout || v.stderr).trim().split(/\s+/)[1] || null;
+      return { path: c, version, ok: true };
+    }
+  }
+  return null;
+}
+
+async function checkDeps(python) {
+  const out = { numpy: false, trimesh: false, manifold3d: false };
+  if (!python) return out;
+  for (const mod of ["numpy", "trimesh", "manifold3d"]) {
+    const r = await run(python, ["-c", `import ${mod}`], { timeout: 8000 });
+    out[mod] = r.ok;
+  }
+  return out;
+}
+
+async function findBlender() {
+  const cands = [];
+  if (process.platform === "win32") {
+    cands.push("blender.exe");
+    for (const d of ["C:\\Program Files\\Blender Foundation", "C:\\Program Files (x86)\\Blender Foundation"]) {
+      try {
+        for (const sub of fs.readdirSync(d)) cands.push(path.join(d, sub, "blender.exe"));
+      } catch { /* ignore */ }
+    }
+  } else if (process.platform === "darwin") {
+    cands.push("/Applications/Blender.app/Contents/MacOS/blender", "blender");
+  } else {
+    cands.push("blender", "/usr/bin/blender", "/usr/local/bin/blender", "/opt/blender/blender",
+      path.join(os.homedir(), ".local", "share", "blender", "blender"));
+  }
+  for (const c of cands) {
+    const v = await run(c, ["--version"], { timeout: 8000 });
+    if (v.ok) {
+      const version = (v.stdout || v.stderr).trim().split(/\s+/)[1] || null;
+      return { path: c, version, ok: true };
+    }
+  }
+  return null;
+}
+
+/** Detect the environment. Never throws. */
+export async function detect() {
+  const python = await findPython();
+  const deps = await checkDeps(python ? python.path : null);
+  const blender = await findBlender();
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    python,
+    deps,
+    blender,
+    inBlender: false, // node context; the bpy add-on sets this inside Blender
+  };
+}
+
+// ---------------------------------------------------------------------------
+// install
+// ---------------------------------------------------------------------------
+
+/** Create/refresh a venv with numpy/trimesh/manifold3d. Returns venv python path. */
+export async function ensurePythonDeps({ python, force = false } = {}) {
+  mkdirp(DATA_DIR);
+  const basePython = python || (await findPython())?.path || "python3";
+  const venvPath = path.join(DATA_DIR, "venv");
+  const bin = venvBin(venvPath);
+  const actions = [];
+
+  const needCreate = force || !fs.existsSync(bin.python);
+  if (needCreate) {
+    let r = await run(basePython, ["-m", "venv", venvPath], { timeout: 30000 });
+    if (!r.ok) r = await run(basePython, ["-m", "venv", "--system-site-packages", venvPath], { timeout: 30000 });
+    actions.push(`venv create: ${r.ok ? "ok" : "failed"}`);
+    if (!r.ok) return { ok: false, venvPath, pythonPath: bin.python, detail: r.stderr.slice(0, 500), actions };
+  }
+
+  const deps = ["numpy>=1.26", "trimesh>=4.0", "manifold3d>=2.2"];
+  const inst = await run(bin.python, ["-m", "pip", "install", "-q", "--disable-pip-version-check", ...deps], { timeout: 180000 });
+  actions.push(`pip install: ${inst.ok ? "ok" : "failed"}`);
+  if (!inst.ok) return { ok: false, venvPath, pythonPath: bin.python, detail: inst.stderr.slice(0, 500), actions };
+
+  return { ok: true, venvPath, pythonPath: bin.python, actions };
+}
+
+function download(url, dest) {
+  return new Promise((resolve) => {
+    const file = createWriteStream(dest);
+    const req = https.get(url, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        file.close(); try { fs.unlinkSync(dest); } catch { /* ignore */ }
+        return download(res.headers.location, dest).then(resolve);
+      }
+      if (res.statusCode !== 200) { file.close(); return resolve({ ok: false, detail: `HTTP ${res.statusCode}` }); }
+      res.pipe(file);
+      file.on("finish", () => file.close(() => resolve({ ok: true })));
+    });
+    req.on("error", (e) => { file.close(); resolve({ ok: false, detail: e.message }); });
+    req.setTimeout(300000, () => req.destroy(new Error("download timeout")));
+  });
+}
+
+/** Fetch + extract a portable Blender (linux x64 tar.xz). mac/win: instructions only. */
+export async function ensureBlender({ version = "4.2.0", dir } = {}) {
+  mkdirp(DATA_DIR);
+  const destDir = dir || path.join(DATA_DIR, "blender");
+  const major = version.split(".").slice(0, 2).join(".");
+  const base = `https://download.blender.org/release/Blender${major}/`;
+
+  if (process.platform === "linux" && process.arch === "x64") {
+    const url = `${base}blender-${version}-linux-x64.tar.xz`;
+    mkdirp(destDir);
+    const archive = path.join(DATA_DIR, `blender-${version}.tar.xz`);
+    const dl = await download(url, archive);
+    if (!dl.ok) return { ok: false, detail: `download failed: ${dl.detail}`, url };
+    const ex = await run("tar", ["-xJf", archive, "-C", destDir], { timeout: 120000 });
+    if (!ex.ok) return { ok: false, detail: `extract failed: ${ex.stderr.slice(0, 300)}`, url };
+    // find the blender binary
+    let blenderPath = null;
+    const walk = (d, depth = 0) => {
+      if (depth > 3 || blenderPath) return;
+      try {
+        for (const e of fs.readdirSync(d)) {
+          const p = path.join(d, e);
+          if (e === "blender" && fs.statSync(p).isFile() && fs.statSync(p).mode & 0o111) { blenderPath = p; return; }
+          try { if (fs.statSync(p).isDirectory()) walk(p, depth + 1); } catch { /* ignore */ }
+        }
+      } catch { /* ignore */ }
+    };
+    walk(destDir);
+    return { ok: !!blenderPath, blenderPath, dir: destDir, url };
+  }
+
+  // mac / win / other: don't half-extract; give the user the URL + instructions.
+  const url = process.platform === "darwin"
+    ? `${base}blender-${version}-macos-arm64.dmg`
+    : process.platform === "win32"
+      ? `${base}blender-${version}-windows-x64.zip`
+      : `${base}blender-${version}-linux-x64.tar.xz`;
+  return {
+    ok: false,
+    detail: `auto-extract unsupported on ${process.platform}/${process.arch}; download and install manually, then run blender_setup again to detect it.`,
+    url,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// verify
+// ---------------------------------------------------------------------------
+
+/** Smoke-test the runtimes. Never throws. */
+export async function verify({ pythonPath, blenderPath } = {}) {
+  const out = { trimesh: null, blender: null };
+
+  if (pythonPath) {
+    const r = await run(pythonPath, ["-c",
+      "import trimesh,numpy,manifold3d; m=trimesh.creation.box(extents=[1,2,3]); assert len(m.faces)==12; print('trimesh_ok', len(m.vertices))"],
+      { timeout: 20000 });
+    out.trimesh = { ok: r.ok, detail: (r.ok ? r.stdout.trim() : r.stderr.slice(0, 300)) };
+  }
+
+  if (blenderPath) {
+    const r = await run(blenderPath, ["--background", "--python-expr",
+      "import bpy; print('blender_ok', bpy.app.version_string)"], { timeout: 30000 });
+    out.blender = { ok: r.ok, detail: (r.ok ? r.stdout.trim().split("\n").pop() : r.stderr.slice(0, 300)) };
+  }
+
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// orchestrate
+// ---------------------------------------------------------------------------
+
+/** Full bootstrap: detect → install deps → (optional) blender → verify → persist config. */
+export async function setup({ installBlender = false, blenderVersion, force = false } = {}) {
+  const actions = [];
+  const detected = await detect();
+  actions.push(`detected python=${detected.python ? detected.python.path : "none"}, blender=${detected.blender ? detected.blender.path : "none"}`);
+
+  if (!detected.python) {
+    return { ok: false, stage: "detect", detected, actions, config: null, verify: null,
+      detail: "no python3/python found; install Python 3.10+ first." };
+  }
+
+  // 1) Python deps in an isolated venv.
+  const deps = await ensurePythonDeps({ python: detected.python.path, force });
+  actions.push(...(deps.actions || []));
+  let pythonPath = deps.ok ? deps.pythonPath : detected.python.path;
+  if (!deps.ok) actions.push(`deps install failed: ${deps.detail}`);
+
+  // 2) Optional Blender.
+  let blenderPath = detected.blender ? detected.blender.path : null;
+  if (installBlender && !blenderPath) {
+    const b = await ensureBlender({ version: blenderVersion || "4.2.0" });
+    actions.push(`blender install: ${b.ok ? "ok" : "skipped — " + (b.detail || "")}`);
+    if (b.ok && b.blenderPath) blenderPath = b.blenderPath;
+  }
+
+  // 3) Verify.
+  const verifyResult = await verify({ pythonPath, blenderPath });
+
+  // 4) Persist config.
+  const config = {
+    pythonPath,
+    blenderPath: blenderPath || undefined,
+    venvPath: deps.ok ? deps.venvPath : undefined,
+    updatedAt: new Date().toISOString(),
+    versions: {
+      python: detected.python?.version,
+      blender: detected.blender?.version,
+    },
+  };
+  try { mkdirp(DATA_DIR); fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2)); } catch { /* best-effort */ }
+
+  const ok = !!(verifyResult.trimesh && verifyResult.trimesh.ok);
+  return { ok, stage: "done", detected, actions, config, verify: verifyResult };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-blender-3d",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "DeepSeek Harness plugin: drive Blender 3D modeling (primitives, boolean CSG, transform, material, modifier, scene, export STL/OBJ/PLY/GLTF) via a JSON bridge. Bundles a headless trimesh+manifold3d runtime and a Blender bpy add-on. · DSH 插件：通过 JSON 桥接驱动 Blender 3D 建模。",
   "type": "module",
   "main": "lib/index.js",
@@ -16,6 +16,7 @@
   "files": [
     "lib/index.js",
     "lib/bridge-client.js",
+    "lib/setup.js",
     "lib/runtime/**/*",
     "skill/**/*",
     "cordis.patch.yml",

package/skill/blender-3d-modeling/SKILL.md

@@ -116,3 +116,33 @@ sleep 1
 node /workspace/blender_harness/blender_driver.js --url http://127.0.0.1:13082 demo
 # expect: DEMO OK  +  /workspace/demo_cli.stl written
 ```
+
+## Auto environment setup (`blender_setup`)
+
+On a fresh machine, call the **`blender_setup`** tool first — it auto-detects,
+installs, configures, and verifies the environment with no manual steps:
+
+- **Detect**: finds `python3`/`python`, probes `numpy`/`trimesh`/`manifold3d`,
+  and looks for an installed Blender (common paths + `blender --version`).
+- **Install**: creates an isolated venv at `$DSH_HOME/.blender-plugin/venv` (or
+  `~/.blender-plugin/venv`) and `pip install`s `numpy>=1.26 trimesh>=4.0
+  manifold3d>=2.2`. No Blender needed for headless modeling/export.
+- **Configure** (optional): pass `install_blender: true` to also fetch a
+  portable Blender (linux x64 `tar.xz`; mac/win get a download URL + manual
+  instructions instead of half-extracting).
+- **Verify**: smoke-tests trimesh (builds a box, asserts 12 faces) and, if
+  Blender was installed, `blender --background` import `bpy`.
+- **Persist**: writes `~/.blender-plugin/config.json` (`pythonPath`,
+  `blenderPath`, versions) so the bridge auto-uses the venv python on later
+  calls. If a `blender_model` call finds trimesh missing, the bridge also
+  self-heals once (creates the venv, retries).
+
+```jsonc
+// blender_setup({ "install_blender": false })  →
+{ "ok": true, "stage": "done",
+  "detected": { "platform": "linux", "python": { "path": "python3", "version": "3.11.6" },
+                "deps": { "numpy": true, "trimesh": true, "manifold3d": true },
+                "blender": null },
+  "config": { "pythonPath": "~/.blender-plugin/venv/bin/python" },
+  "verify": { "trimesh": { "ok": true, "detail": "trimesh_ok 8" }, "blender": null } }
+```