wmdev 0.4.0 → 0.5.0

package/backend/dist/server.js

@@ -7067,7 +7067,8 @@ var DEFAULT_CONFIG = {
   services: [],
   profiles: { default: { name: "default" } },
   autoName: false,
-  linkedRepos: []
+  linkedRepos: [],
+  startupEnvs: {}
 };
 function hasAutoName(dir) {
   try {
@@ -7104,6 +7105,13 @@ function loadConfig(dir) {
       repo: r.repo,
       alias: typeof r.alias === "string" ? r.alias : r.repo.split("/").pop()
     })) : [];
+    let startupEnvs = {};
+    if (parsed.startupEnvs && typeof parsed.startupEnvs === "object" && !Array.isArray(parsed.startupEnvs)) {
+      const raw = parsed.startupEnvs;
+      for (const [k, v] of Object.entries(raw)) {
+        startupEnvs[k] = typeof v === "string" ? v : String(v);
+      }
+    }
     return {
       ...typeof parsed.name === "string" ? { name: parsed.name } : {},
       services: Array.isArray(parsed.services) ? parsed.services : DEFAULT_CONFIG.services,
@@ -7112,7 +7120,8 @@ function loadConfig(dir) {
         ...sandboxProfile?.name && sandboxProfile?.image ? { sandbox: sandboxProfile } : {}
       },
       autoName,
-      linkedRepos
+      linkedRepos,
+      startupEnvs
     };
   } catch {
     return DEFAULT_CONFIG;
@@ -7597,6 +7606,48 @@ function parseBranchFromOutput(output) {
   const match = output.match(/branch:\s*(\S+)/i);
   return match?.[1] ?? null;
 }
+async function initWorktreeEnv(branch, opts) {
+  const profile = opts?.profile ?? "default";
+  const agent = opts?.agent ?? "claude";
+  const porcelainResult = Bun.spawnSync(["git", "worktree", "list", "--porcelain"], { stdout: "pipe", stderr: "pipe" });
+  const worktreeMap = parseWorktreePorcelain(new TextDecoder().decode(porcelainResult.stdout));
+  const wtDir = worktreeMap.get(branch) ?? null;
+  if (!wtDir)
+    return;
+  const existingEnv = await readEnvLocal(wtDir);
+  const allPaths = [...worktreeMap.values()];
+  const existingEnvs = await readAllWorktreeEnvs(allPaths, wtDir);
+  const portAssignments = opts?.services ? allocatePorts(existingEnvs, opts.services) : {};
+  const defaults = { ...portAssignments, PROFILE: profile, AGENT: agent, ...opts?.envOverrides };
+  const toWrite = {};
+  for (const [key, value] of Object.entries(defaults)) {
+    if (!existingEnv[key])
+      toWrite[key] = value;
+  }
+  if (Object.keys(toWrite).length > 0) {
+    await writeEnvLocal(wtDir, toWrite);
+  }
+  const rpcPort = Bun.env.BACKEND_PORT || "5111";
+  const hooksConfig = {
+    hooks: {
+      Stop: [{ hooks: [{ type: "command", command: `WORKMUX_RPC_PORT=${rpcPort} ~/.config/workmux/hooks/notify-stop.sh`, async: true }] }],
+      PostToolUse: [{ matcher: "Bash", hooks: [{ type: "command", command: `WORKMUX_RPC_PORT=${rpcPort} ~/.config/workmux/hooks/notify-pr.sh`, async: true }] }]
+    }
+  };
+  await mkdir2(`${wtDir}/.claude`, { recursive: true });
+  const settingsPath = `${wtDir}/.claude/settings.local.json`;
+  let existing = {};
+  try {
+    const file = Bun.file(settingsPath);
+    if (await file.exists()) {
+      existing = await file.json();
+    }
+  } catch {}
+  const existingHooks = existing.hooks ?? {};
+  const merged = { ...existing, hooks: { ...existingHooks, ...hooksConfig.hooks } };
+  await Bun.write(settingsPath, JSON.stringify(merged, null, 2) + `
+`);
+}
 async function addWorktree(rawBranch, opts) {
   ensureTmux();
   const profile = opts?.profile ?? "default";
@@ -7651,35 +7702,10 @@ async function addWorktree(rawBranch, opts) {
     branch = parsed;
   }
   const windowTarget = `wm-${branch}`;
+  await initWorktreeEnv(branch, { profile, agent, services: opts?.services, envOverrides: opts?.envOverrides });
   const porcelainResult = Bun.spawnSync(["git", "worktree", "list", "--porcelain"], { stdout: "pipe", stderr: "pipe" });
   const worktreeMap = parseWorktreePorcelain(new TextDecoder().decode(porcelainResult.stdout));
   const wtDir = worktreeMap.get(branch) ?? null;
-  if (wtDir) {
-    const allPaths = [...worktreeMap.values()];
-    const existingEnvs = await readAllWorktreeEnvs(allPaths, wtDir);
-    const portAssignments = opts?.services ? allocatePorts(existingEnvs, opts.services) : {};
-    await writeEnvLocal(wtDir, { ...portAssignments, PROFILE: profile, AGENT: agent });
-    const rpcPort = Bun.env.BACKEND_PORT || "5111";
-    const hooksConfig = {
-      hooks: {
-        Stop: [{ hooks: [{ type: "command", command: `WORKMUX_RPC_PORT=${rpcPort} ~/.config/workmux/hooks/notify-stop.sh`, async: true }] }],
-        PostToolUse: [{ matcher: "Bash", hooks: [{ type: "command", command: `WORKMUX_RPC_PORT=${rpcPort} ~/.config/workmux/hooks/notify-pr.sh`, async: true }] }]
-      }
-    };
-    await mkdir2(`${wtDir}/.claude`, { recursive: true });
-    const settingsPath = `${wtDir}/.claude/settings.local.json`;
-    let existing = {};
-    try {
-      const file = Bun.file(settingsPath);
-      if (await file.exists()) {
-        existing = await file.json();
-      }
-    } catch {}
-    const existingHooks = existing.hooks ?? {};
-    const merged = { ...existing, hooks: { ...existingHooks, ...hooksConfig.hooks } };
-    await Bun.write(settingsPath, JSON.stringify(merged, null, 2) + `
-`);
-  }
   const env = wtDir ? await readEnvLocal(wtDir) : {};
   log.debug(`[workmux:add] branch=${branch} dir=${wtDir ?? "(not found)"} env=${JSON.stringify(env)}`);
   if (hasSystemPrompt && profileConfig) {
@@ -7827,6 +7853,52 @@ async function checkDirty(dir) {
   ]);
   return status || ahead;
 }
+async function cleanupStaleWindows(activeBranches, worktreeBaseDir) {
+  try {
+    const proc = Bun.spawn(["tmux", "list-panes", "-a", "-F", "#{session_name}:#{window_name} #{pane_current_path}"], { stdout: "pipe", stderr: "pipe" });
+    if (await proc.exited !== 0)
+      return;
+    const output = (await new Response(proc.stdout).text()).trim();
+    if (!output)
+      return;
+    const toKill = [];
+    const seen = new Set;
+    for (const line of output.split(`
+`)) {
+      const spaceIdx = line.indexOf(" ");
+      if (spaceIdx === -1)
+        continue;
+      const target = line.slice(0, spaceIdx);
+      const panePath = line.slice(spaceIdx + 1);
+      const colonIdx = target.indexOf(":");
+      if (colonIdx === -1)
+        continue;
+      const session = target.slice(0, colonIdx);
+      const windowName = target.slice(colonIdx + 1);
+      if (!windowName.startsWith("wm-"))
+        continue;
+      if (seen.has(windowName))
+        continue;
+      const branch = windowName.slice(3);
+      if (activeBranches.has(branch))
+        continue;
+      if (!panePath.startsWith(worktreeBaseDir))
+        continue;
+      toKill.push({ session, windowName });
+      seen.add(windowName);
+    }
+    await Promise.all(toKill.map(async ({ session, windowName }) => {
+      log.info(`[cleanup] killing stale tmux window "${windowName}" (no matching worktree)`);
+      const kill = Bun.spawn(["tmux", "kill-window", "-t", `${session}:${windowName}`], {
+        stdout: "ignore",
+        stderr: "ignore"
+      });
+      await kill.exited;
+    }));
+  } catch (err) {
+    log.warn(`[cleanup] cleanupStaleWindows failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
 async function mergeWorktree(name) {
   log.debug(`[workmux:merge] running: workmux merge ${name}`);
   await removeContainer(name);
@@ -8027,6 +8099,13 @@ function write(worktreeName, data) {
     log.error(`[term] write(${worktreeName}) stdin closed`, err);
   }
 }
+async function sendKeys(worktreeName, hexBytes) {
+  const session = sessions.get(worktreeName);
+  if (!session)
+    return;
+  const windowTarget = `${session.groupedSessionName}:wm-${worktreeName}`;
+  await asyncTmux(["tmux", "send-keys", "-t", windowTarget, "-H", ...hexBytes]);
+}
 async function resize(worktreeName, cols, rows) {
   const session = sessions.get(worktreeName);
   if (!session)
@@ -8716,6 +8795,8 @@ function parseWsMessage(raw) {
     switch (m.type) {
       case "input":
         return typeof m.data === "string" ? { type: "input", data: m.data } : null;
+      case "sendKeys":
+        return Array.isArray(m.hexBytes) && m.hexBytes.every((b) => typeof b === "string") ? { type: "sendKeys", hexBytes: m.hexBytes } : null;
       case "selectPane":
         return typeof m.pane === "number" ? { type: "selectPane", pane: m.pane } : null;
       case "resize":
@@ -8856,7 +8937,11 @@ async function apiGetWorktrees(req) {
     fetchAssignedIssues()
   ]);
   const linearIssues = linearResult.ok ? linearResult.data : [];
-  const merged = await Promise.all(worktrees.map(async (wt) => {
+  const activeBranches = new Set(worktrees.map((wt) => wt.branch));
+  activeBranches.add("main");
+  cleanupStaleWindows(activeBranches, `${PROJECT_DIR}__worktrees/`);
+  const nonMainWorktrees = worktrees.filter((wt) => wtPaths.has(wt.branch));
+  const merged = await Promise.all(nonMainWorktrees.map(async (wt) => {
     const st = status.find((s) => s.worktree.includes(wt.branch) || s.worktree.startsWith(wt.branch));
     const wtDir = wtPaths.get(wt.branch);
     const env = wtDir ? await readEnvLocal(wtDir) : {};
@@ -8902,6 +8987,17 @@ async function apiCreateWorktree(req) {
   const agent = typeof body.agent === "string" ? body.agent : "claude";
   const isSandbox = config.profiles.sandbox !== undefined && profileName === config.profiles.sandbox.name;
   const profileConfig = isSandbox ? config.profiles.sandbox : config.profiles.default;
+  let envOverrides;
+  if (body.envOverrides && typeof body.envOverrides === "object" && !Array.isArray(body.envOverrides)) {
+    const raw2 = body.envOverrides;
+    const parsed = {};
+    for (const [k, v] of Object.entries(raw2)) {
+      if (typeof v === "string")
+        parsed[k] = v;
+    }
+    if (Object.keys(parsed).length > 0)
+      envOverrides = parsed;
+  }
   log.info(`[worktree:add] agent=${agent} profile=${profileName}${branch ? ` branch=${branch}` : ""}${prompt ? ` prompt="${prompt.slice(0, 80)}"` : ""}`);
   const result = await addWorktree(branch, {
     prompt,
@@ -8912,7 +9008,8 @@ async function apiCreateWorktree(req) {
     isSandbox,
     sandboxConfig: isSandbox ? config.profiles.sandbox : undefined,
     services: config.services,
-    mainRepoDir: PROJECT_DIR
+    mainRepoDir: PROJECT_DIR,
+    envOverrides
   });
   if (!result.ok)
     return errorResponse(result.error, 422);
@@ -8931,9 +9028,24 @@ async function apiDeleteWorktree(name) {
 }
 async function apiOpenWorktree(name) {
   log.info(`[worktree:open] name=${name}`);
+  const wtPaths = await getWorktreePaths();
+  const wtDir = wtPaths.get(name);
+  if (wtDir) {
+    const env = await readEnvLocal(wtDir);
+    if (!env.PROFILE) {
+      log.info(`[worktree:open] initializing env for ${name}`);
+      await initWorktreeEnv(name, {
+        profile: config.profiles.default.name,
+        agent: "claude",
+        services: config.services
+      });
+      wtCache = null;
+    }
+  }
   const result = await openWorktree(name);
   if (!result.ok)
     return errorResponse(result.error, 422);
+  wtCache = null;
   return jsonResponse({ message: result.output });
 }
 async function apiSendPrompt(name, req) {
@@ -9101,6 +9213,9 @@ Bun.serve({
         case "input":
           write(worktree, msg.data);
           break;
+        case "sendKeys":
+          await sendKeys(worktree, msg.hexBytes);
+          break;
         case "selectPane":
           if (ws.data.attached) {
             log.debug(`[ws] selectPane pane=${msg.pane} worktree=${worktree}`);