@tablation/crew 0.123.0 → 0.124.0

package/dist/cli.js

@@ -406,7 +406,7 @@ function registerCodeServer(worktree, url, server = INTEL_SERVER_NAME) {
 
 // src/intel-serena.ts
 import { spawn, spawnSync } from "child_process";
-import { closeSync, cpSync, existsSync as existsSync6, mkdirSync as mkdirSync4, openSync, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { closeSync, cpSync, existsSync as existsSync6, mkdirSync as mkdirSync4, openSync, readFileSync as readFileSync4, rmSync, symlinkSync, writeFileSync as writeFileSync4 } from "fs";
 import { dirname as dirname3, join as join5 } from "path";
 
 // src/ports.ts
@@ -575,6 +575,10 @@ function startSerena(d, s) {
   const p = serenaPaths(s.stateDir, s.route, String(s.ticket));
   try {
     prepareFolder(d, p.home, p.project, s.worktree);
+    if (s.languageServers && d.exists(s.languageServers) && d.link) {
+      const dest = join5(p.home, "language_servers");
+      if (!d.exists(dest)) d.link(s.languageServers, dest);
+    }
     const mainCache = join5(p.mainProject, "cache");
     const cache = join5(p.project, "cache");
     if (!d.exists(cache) && d.exists(mainCache)) d.copyDir(mainCache, cache);
@@ -625,6 +629,7 @@ function realSerenaDeps(onPath2, extraEnv = process.env) {
     spawnDetached: detached,
     // `&&` so the stamp exists only for an index that finished; a killed one is retried next start.
     spawnIndex: (args, env, log, stamp, stampText) => detached("sh", ["-c", 'serena "$@" && printf %s "$STAMP_TEXT" > "$STAMP_FILE"', "serena", ...args], { ...env, STAMP_FILE: stamp, STAMP_TEXT: stampText }, log),
+    link: (target, path) => symlinkSync(target, path),
     alive: (pid) => {
       try {
         process.kill(pid, 0);
@@ -12681,6 +12686,10 @@ var SANDBOX_CLAUDE_SHA256 = {
 };
 var SANDBOX_UID = 1e3;
 var CREW_PREFIX = "/opt/crew";
+var SANDBOX_UV_VERSION = "0.13.6";
+var SANDBOX_SERENA_VERSION = "2.1.0";
+var SERENA_IMAGE_HOME = `${CREW_PREFIX}/serena`;
+var SERENA_LANGUAGE_SERVERS_ENV = "CREW_SERENA_LANGUAGE_SERVERS";
 var SANDBOX_RETRY_AFTER_MS = 60 * 60 * 1e3;
 var KEEP_TAGS = 2;
 var CREDENTIAL_HELPER = `#!/bin/sh
@@ -12717,6 +12726,21 @@ function claudeInstallCommand() {
     `${CREW_PREFIX}/bin/claude --version | grep -F "${SANDBOX_CLAUDE_VERSION}"`
   ].join("; ");
 }
+function serenaInstallCommand() {
+  return [
+    `python3 -m venv ${CREW_PREFIX}/uv-venv`,
+    `${CREW_PREFIX}/uv-venv/bin/pip install --no-cache-dir uv==${SANDBOX_UV_VERSION}`,
+    `ln -sf ${CREW_PREFIX}/uv-venv/bin/uv ${CREW_PREFIX}/bin/uv`,
+    `UV_TOOL_DIR=${CREW_PREFIX}/uv/tools UV_TOOL_BIN_DIR=${CREW_PREFIX}/bin UV_PYTHON_INSTALL_DIR=${CREW_PREFIX}/uv/python UV_CACHE_DIR=${CREW_PREFIX}/cache/uv ${CREW_PREFIX}/bin/uv tool install -p 3.13 serena-agent==${SANDBOX_SERENA_VERSION}`,
+    `${CREW_PREFIX}/bin/serena --help >/dev/null`
+  ].join("; ");
+}
+function serenaWarmCommand() {
+  return [
+    `mkdir -p ${SERENA_IMAGE_HOME}`,
+    `SERENA_HOME=${SERENA_IMAGE_HOME} serena project index ${WARM_DIR}`
+  ].join("; ");
+}
 function baseLayer() {
   const dockerfile = [
     `FROM ${SANDBOX_BASE_IMAGE}`,
@@ -12725,18 +12749,20 @@ function baseLayer() {
   ].join("\n");
   return { name: "base", tag: `crew-sandbox-base:${hash({ SANDBOX_BASE_IMAGE, SANDBOX_OPENSHELL_VERSION })}`, dockerfile, files: {} };
 }
-function crewLayer(base) {
+function crewLayer(base, intel) {
   const files = { "credential-helper": CREDENTIAL_HELPER, "mcp.json": MCP_CONFIG };
   const env = Object.entries(CREW_ENV).map(([k, v]) => `${k}=${v}`).join(" ");
   const dockerfile = [
     `FROM ${base.tag}`,
     "USER root",
-    run2("apt-get update && apt-get install -y --no-install-recommends ca-certificates curl git && rm -rf /var/lib/apt/lists/*"),
+    run2(`apt-get update && apt-get install -y --no-install-recommends ca-certificates curl git${intel ? " python3 python3-venv nodejs" : ""} && rm -rf /var/lib/apt/lists/*`),
     `COPY credential-helper ${CREW_PREFIX}/bin/credential-helper`,
     `COPY mcp.json ${CREW_PREFIX}/mcp/mcp.json`,
     run2(claudeInstallCommand()),
+    ...intel ? [run2(`mkdir -p ${CREW_PREFIX}/cache && ${serenaInstallCommand()}`)] : [],
     run2(`chmod 0755 ${CREW_PREFIX}/bin/credential-helper && git config --system credential.helper ${CREW_PREFIX}/bin/credential-helper`),
     run2(`mkdir -p ${CREW_PREFIX}/cache ${CREW_PREFIX}/pnpm-store ${CREW_PREFIX}/pnpm /sandbox && chown -R ${SANDBOX_UID}:${SANDBOX_UID} ${CREW_PREFIX} /sandbox`),
+    ...intel ? [`ENV ${SERENA_LANGUAGE_SERVERS_ENV}=${SERENA_IMAGE_HOME}/language_servers UV_PYTHON_INSTALL_DIR=${CREW_PREFIX}/uv/python`] : [],
     `ENV ${env} PATH=${CREW_PREFIX}/pnpm:${CREW_PREFIX}/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin`,
     `LABEL io.crew.sandbox.layer="crew" io.crew.sandbox.claude="${SANDBOX_CLAUDE_VERSION}"`,
     ""
@@ -12790,6 +12816,7 @@ function repoLayer(repo, decl, crew, warm) {
     lines2.push(`COPY --chown=${SANDBOX_UID}:${SANDBOX_UID} warm/ ${WARM_DIR}/`, `WORKDIR ${WARM_DIR}`);
   }
   for (const step of decl.setup) lines2.push(run2(step));
+  if (warming && decl.intel) lines2.push(run2(serenaWarmCommand()));
   if (warming) lines2.push("WORKDIR /sandbox", run2(`rm -rf ${WARM_DIR}`));
   lines2.push(`LABEL io.crew.sandbox.layer="repo" io.crew.sandbox.repo=${JSON.stringify(repo)}`, "");
   const dockerfile = lines2.join("\n");
@@ -12797,7 +12824,7 @@ function repoLayer(repo, decl, crew, warm) {
 }
 function planSandbox(repo, decl, warm = {}) {
   const base = baseLayer();
-  const crew = crewLayer(base);
+  const crew = crewLayer(base, decl.intel);
   const layer = repoLayer(repo, decl, crew, warm);
   return { repo, tag: layer.tag, claude: SANDBOX_CLAUDE_VERSION, layers: [base, crew, layer] };
 }
@@ -25400,7 +25427,7 @@ ${changed2.map((c) => `  - ${c}
           warm = readWarmFiles(r.dir, `${r.config.branch.remote}/${r.config.branch.base}`, r.config.sandbox.warm ?? []);
         } catch {
         }
-        out.set(r.name, { name: r.name, decl: r.config.sandbox, warm });
+        out.set(r.name, { name: r.name, decl: intelFlavor(r.config.hooks.intel) === "serena" ? { ...r.config.sandbox, intel: "serena" } : r.config.sandbox, warm });
       }
     }
     return [...out.values()];
@@ -28496,7 +28523,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       }
       const pathWt = applyRunWorktree(repoWt.dir, repoWt.config, planWt);
       emit.emit(describeRunWorktreePlan(planWt));
-      if (pathWt && planIsUsable(planWt) && repoWt.config.hooks.intel) {
+      if (pathWt && planIsUsable(planWt) && wantsCodeBridge(repoWt.config.hooks.intel)) {
         const shellWt = resolveShell(repoWt.config.shell ?? cfg.ship.shell);
         const paragraph = await startWorktreeIntel({
           worktree: pathWt,
@@ -28518,6 +28545,15 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           },
           runHook: async (name, cwd, env) => {
             const script = repoWt.config.hooks[name];
+            if (name === "intel" && intelFlavor(script) === "serena") {
+              return startSerena(realSerenaDeps((bin) => !!findOnPath(bin, pathFor(cfg.ship)), { ...process.env, PATH: pathFor(cfg.ship) }), {
+                stateDir: cfg.ship.stateDir,
+                route: routeWt.route,
+                ticket: Number(nWt),
+                worktree: cwd,
+                mainCheckout: repoWt.dir
+              });
+            }
             return script ? runScript(script, { cwd, env, shell: shellWt, timeoutMs: name === "intel" ? 6e4 : void 0 }) : null;
           }
         });
@@ -28836,7 +28872,8 @@ ${where.join("\n")}`);
                 route: routeP.route,
                 ticket: Number(/(\d+)$/.exec(env.CREW_TICKET ?? "")?.[1] ?? 0),
                 worktree: cwd,
-                mainCheckout: repoP.dir
+                mainCheckout: repoP.dir,
+                languageServers: process.env.CREW_SERENA_LANGUAGE_SERVERS
               });
             }
             if (name === "intel" && lspFlavor(script)) return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.123.0",
+  "version": "0.124.0",
   "description": "A standing team of headless agents that picks work off a Tablation board, does it on a machine you control, and reports back.",
   "type": "module",
   "license": "MIT",