wmdev 0.3.0 → 0.5.0

package/README.md

@@ -62,6 +62,10 @@ wmdev uses two config files in the project root:
 ### `.wmdev.yaml` schema
 
 ```yaml
+# Project name displayed in the sidebar header and browser tab title.
+# Falls back to "Dashboard" if omitted.
+name: string
+
 # Services to monitor — each maps a display name to a port env var.
 # The dashboard polls these ports and shows health status badges.
 # When portStart is set, wmdev auto-allocates ports for new worktrees
@@ -112,6 +116,8 @@ linkedRepos: []
 ### Example
 
 ```yaml
+name: My Project
+
 services:
   - name: BE
     portEnv: BACKEND_PORT
@@ -149,6 +155,7 @@ linkedRepos:
 
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
+| `name` | string | no | Project name shown in the sidebar header and browser tab title. Defaults to "Dashboard" |
 | `services[].name` | string | yes | Display name shown in the dashboard |
 | `services[].portEnv` | string | yes | Env var containing the service port (read from each worktree's `.env.local`) |
 | `services[].portStart` | number | no | Base port for slot 0. When set, wmdev auto-allocates ports for new worktrees |

package/backend/dist/server.js

@@ -6941,8 +6941,13 @@ async function readEnvLocal(wtDir) {
     for (const line of text.split(`
 `)) {
       const match = line.match(/^(\w+)=(.*)$/);
-      if (match)
-        env[match[1]] = match[2];
+      if (match) {
+        let val = match[2];
+        if (val.length >= 2 && val.startsWith("'") && val.endsWith("'")) {
+          val = val.slice(1, -1);
+        }
+        env[match[1]] = val;
+      }
     }
     return env;
   } catch {
@@ -6959,12 +6964,14 @@ async function writeEnvLocal(wtDir, entries) {
 `);
   } catch {}
   for (const [key, value] of Object.entries(entries)) {
+    const needsQuoting = /[{}"\s$`\\!#|;&()<>]/.test(value);
+    const safe = needsQuoting ? `'${value}'` : value;
     const pattern = new RegExp(`^${key}=`);
     const idx = lines.findIndex((l) => pattern.test(l));
     if (idx >= 0) {
-      lines[idx] = `${key}=${value}`;
+      lines[idx] = `${key}=${safe}`;
     } else {
-      lines.push(`${key}=${value}`);
+      lines.push(`${key}=${safe}`);
     }
   }
   await Bun.write(filePath, lines.join(`
@@ -7060,7 +7067,8 @@ var DEFAULT_CONFIG = {
   services: [],
   profiles: { default: { name: "default" } },
   autoName: false,
-  linkedRepos: []
+  linkedRepos: [],
+  startupEnvs: {}
 };
 function hasAutoName(dir) {
   try {
@@ -7097,14 +7105,23 @@ 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,
       profiles: {
         default: defaultProfile?.name ? defaultProfile : DEFAULT_CONFIG.profiles.default,
         ...sandboxProfile?.name && sandboxProfile?.image ? { sandbox: sandboxProfile } : {}
       },
       autoName,
-      linkedRepos
+      linkedRepos,
+      startupEnvs
     };
   } catch {
     return DEFAULT_CONFIG;
@@ -7589,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";
@@ -7643,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) {
@@ -7819,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);
@@ -8019,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)
@@ -8097,6 +8184,20 @@ function mapChecks(checks) {
     runId: parseRunId(c.detailsUrl)
   }));
 }
+function parseReviewComments(json) {
+  const raw = JSON.parse(json);
+  const sorted = raw.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+  return sorted.slice(0, PR_FETCH_LIMIT).map((c) => ({
+    type: "inline",
+    author: c.user?.login ?? "unknown",
+    body: c.body ?? "",
+    createdAt: c.created_at ?? "",
+    path: c.path ?? "",
+    line: c.line ?? null,
+    diffHunk: c.diff_hunk ?? "",
+    isReply: c.in_reply_to_id !== undefined
+  }));
+}
 function parsePrResponse(json, repoLabel) {
   const prs = new Map;
   const entries = JSON.parse(json);
@@ -8111,6 +8212,7 @@ function parsePrResponse(json, repoLabel) {
       ciStatus: summarizeChecks(entry.statusCheckRollup),
       ciChecks: mapChecks(entry.statusCheckRollup),
       comments: (entry.comments ?? []).map((c) => ({
+        type: "comment",
         author: c.author?.login ?? "unknown",
         body: c.body ?? "",
         createdAt: c.createdAt ?? ""
@@ -8161,6 +8263,45 @@ async function fetchAllPrs(repoSlug, repoLabel, cwd) {
     return { ok: false, error: `failed to parse gh output for ${label}: ${err}` };
   }
 }
+async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  async function worker() {
+    while (next < items.length) {
+      const idx = next++;
+      results[idx] = await fn(items[idx]);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+  return results;
+}
+async function fetchReviewComments(prNumber, repoSlug, cwd) {
+  const repoFlag = repoSlug ? repoSlug : "{owner}/{repo}";
+  const args = [
+    "gh",
+    "api",
+    `repos/${repoFlag}/pulls/${prNumber}/comments`,
+    "--paginate"
+  ];
+  const proc = Bun.spawn(args, {
+    stdout: "pipe",
+    stderr: "pipe",
+    ...cwd ? { cwd } : {}
+  });
+  const timeout = Bun.sleep(GH_TIMEOUT_MS).then(() => {
+    proc.kill();
+    return "timeout";
+  });
+  const raceResult = await Promise.race([proc.exited, timeout]);
+  if (raceResult === "timeout" || raceResult !== 0)
+    return [];
+  try {
+    const json = await new Response(proc.stdout).text();
+    return parseReviewComments(json);
+  } catch {
+    return [];
+  }
+}
 async function fetchPrState(url) {
   const proc = Bun.spawn(["gh", "pr", "view", url, "--json", "state"], {
     stdout: "pipe",
@@ -8217,6 +8358,22 @@ async function syncPrStatus(getWorktreePaths, linkedRepos, projectDir) {
       branchPrs.set(branch, existing);
     }
   }
+  const reviewTuples = [];
+  for (const entries of branchPrs.values()) {
+    for (const entry of entries) {
+      if (entry.state === "open") {
+        const repoSlug = entry.repo ? linkedRepos.find((lr) => lr.alias === entry.repo)?.repo : undefined;
+        reviewTuples.push({ entry, repoSlug });
+      }
+    }
+  }
+  if (reviewTuples.length > 0) {
+    const reviewResults = await mapWithConcurrency(reviewTuples, 5, (t) => fetchReviewComments(t.entry.number, t.repoSlug, projectDir));
+    for (let i = 0;i < reviewTuples.length; i++) {
+      const entry = reviewTuples[i].entry;
+      entry.comments = [...entry.comments, ...reviewResults[i]].sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+    }
+  }
   const wtPaths = await getWorktreePaths();
   const seen = new Set;
   for (const [branch, entries] of branchPrs) {
@@ -8638,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":
@@ -8778,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) : {};
@@ -8824,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,
@@ -8834,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);
@@ -8853,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) {
@@ -9023,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}`);