@staff0rd/assist 0.284.1 → 0.285.0

package/README.md

@@ -253,6 +253,10 @@ The first backlog command in a repository that still has a local `.assist/backlo
 
 Web sessions are owned by a long-lived daemon process, not the web server: the server is a thin client that relays WebSocket traffic to the daemon over a local IPC socket (unix domain socket at `~/.assist/daemon/daemon.sock`; named pipe `\\.\pipe\assist-sessions-daemon` on Windows). Restarting the web server leaves sessions running with scrollback intact. The daemon logs to `~/.assist/daemon/daemon.log` (timestamped lines tagged with the daemon's pid, including why it spawned and which sessions it restored) and auto-exits once no sessions remain and no client has been connected for 60 seconds (it is respawned on demand by the web server). Daemon spawning is arbitrated by an `O_EXCL` lockfile so racing clients start at most one daemon; sessions are only restored after the daemon owns the IPC socket, and a daemon that loses ownership of `daemon.pid` shuts down its sessions and exits rather than running orphaned.
 
+Set `sessions.windowsProjectsRoot` in config to the Windows `.claude/projects` directory as seen from WSL (e.g. `/mnt/c/Users/<user>/.claude/projects`) to surface Windows-host repos in the selector. Their transcripts are discovered alongside local ones and tagged as windows-origin (the project name is derived with Windows path rules so `C:\…` cwds name correctly).
+
+Selecting a windows-origin repo (cwd like `C:\…`) from the WSL UI runs an interactive session natively on Windows: the WSL daemon launches a second assist daemon on the Windows host on demand via interop (`cmd.exe /c start "" assist daemon run`), connects to it over TCP (the WSL daemon cannot reach the Windows named pipe directly), and proxies create/resume and I/O to the Windows daemon's native PTY. Windows sessions appear in the same list as local ones (their ids are namespaced internally to avoid collisions) with live output, scrollback, and resume. The TCP connection performs a version handshake on connect; a mismatch is logged (auto-healing comes later). A native Windows daemon listens for the WSL bridge on `sessions.windowsDaemonPort` (default `51764`); the WSL daemon dials `sessions.windowsDaemonHost` (default `127.0.0.1`, which works under WSL2 mirrored networking — NAT-mode setups should set it to the Windows host IP).
+
 When iterating on assist itself: web server changes only need the `assist sessions` process restarted — sessions survive. Daemon/session-core changes need `assist daemon restart` to load the new code; this kills the PTYs, then claude sessions — including assist sessions that wrap claude, like `assist draft` — are auto-respawned via `claude --resume` with scrollback starting fresh, while run sessions (and assist sessions whose claude sessionId was never discovered) reappear as not-restored tiles that can be retried.
 - `assist next [id] [--once]` - Alias for `backlog next [id]`; `--once` exits after the first completed item run instead of prompting for another
 - `assist draft [description] [--once]` (alias: `feat`) - Launch Claude in `/draft` mode, chain into next on `/next` signal; an optional `description` is forwarded as `/draft <description>`; `--once` exits when the done signal arrives after the initial draft completes

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.284.1",
+  version: "0.285.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -275,6 +275,14 @@ var assistConfigSchema = z2.strictObject({
   screenshot: z2.strictObject({
     outputDir: z2.string().default("./screenshots")
   }).default({ outputDir: "./screenshots" }),
+  sessions: z2.strictObject({
+    // why: Windows .claude/projects root as seen from WSL (e.g. /mnt/c/Users/<user>/.claude/projects); when set its transcripts are discovered and tagged windows-origin
+    windowsProjectsRoot: z2.string().optional(),
+    // why: host the WSL daemon dials to reach the native Windows daemon over TCP (WSL can't use the Windows named pipe); defaults to 127.0.0.1 (WSL2 mirrored networking). NAT-mode users set the Windows host IP.
+    windowsDaemonHost: z2.string().optional(),
+    // why: TCP port the native Windows daemon listens on for the WSL bridge; defaults to 51764
+    windowsDaemonPort: z2.number().optional()
+  }).optional(),
   backlog: z2.strictObject({
     databaseUrl: z2.string().optional()
   }).default({}),
@@ -12069,10 +12077,10 @@ async function getAccessToken(apiKey) {
     }
   });
   if (!response.ok) {
-    const errorText = await response.text();
+    const errorText2 = await response.text();
     throw new Error(
       `Failed to get access token: ${response.status} ${response.statusText}
-${errorText}`
+${errorText2}`
     );
   }
   const tokenData = await response.json();
@@ -18100,11 +18108,11 @@ function toSessionInfo({
 }
 
 // src/commands/sessions/daemon/broadcastSessions.ts
-function broadcastSessions(sessions, clients) {
+function broadcastSessions(sessions, clients, windowsSessions = []) {
   persistLiveSessions(sessions);
   broadcast(clients, {
     type: "sessions",
-    sessions: [...sessions.values()].map(toSessionInfo)
+    sessions: [...sessions.values()].map(toSessionInfo).concat(windowsSessions)
   });
 }
 
@@ -18228,9 +18236,10 @@ function replayScrollback(sessions, client) {
 }
 
 // src/commands/sessions/daemon/greetClient.ts
-function greetClient(client, sessions, list4) {
+function greetClient(client, sessions, list4, windowsProxy) {
   sendTo(client, { type: "sessions", sessions: list4() });
   replayScrollback(sessions, client);
+  windowsProxy.replayScrollback(client);
 }
 
 // src/commands/sessions/daemon/shouldAutoDismiss.ts
@@ -18470,6 +18479,308 @@ function shutdownSessions(sessions) {
   }
 }
 
+// src/commands/sessions/daemon/connectToWindowsDaemon.ts
+import * as net2 from "net";
+
+// src/commands/sessions/daemon/windowsDaemonPort.ts
+var DEFAULT_PORT = 51764;
+var DEFAULT_HOST = "127.0.0.1";
+function windowsDaemonPort() {
+  return loadConfig().sessions?.windowsDaemonPort ?? DEFAULT_PORT;
+}
+function windowsDaemonHost() {
+  return loadConfig().sessions?.windowsDaemonHost ?? DEFAULT_HOST;
+}
+
+// src/commands/sessions/daemon/connectToWindowsDaemon.ts
+function connectToWindowsDaemon() {
+  return new Promise((resolve16, reject) => {
+    const socket = net2.connect(windowsDaemonPort(), windowsDaemonHost());
+    socket.once("connect", () => resolve16(socket));
+    socket.once("error", reject);
+  });
+}
+async function isWindowsDaemonRunning() {
+  try {
+    (await connectToWindowsDaemon()).destroy();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/sessions/daemon/ensureWindowsDaemonRunning.ts
+import { spawn as spawn10 } from "child_process";
+var SPAWN_TIMEOUT_MS2 = 3e4;
+var RETRY_DELAY_MS2 = 300;
+async function ensureWindowsDaemonRunning() {
+  if (await isWindowsDaemonRunning()) return;
+  launchWindowsDaemon();
+  await waitForWindowsDaemon();
+}
+function launchWindowsDaemon() {
+  const child = spawn10(
+    "cmd.exe",
+    ["/c", "start", "", "assist", "daemon", "run"],
+    { detached: true, stdio: "ignore" }
+  );
+  child.on(
+    "error",
+    (e) => daemonLog(`failed to launch windows daemon: ${e.message}`)
+  );
+  child.unref();
+}
+async function waitForWindowsDaemon() {
+  const deadline = Date.now() + SPAWN_TIMEOUT_MS2;
+  while (Date.now() < deadline) {
+    await delay2(RETRY_DELAY_MS2);
+    if (await isWindowsDaemonRunning()) return;
+  }
+  throw new Error(
+    "Windows daemon did not start; is assist installed on the Windows host?"
+  );
+}
+function delay2(ms) {
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
+}
+
+// src/commands/sessions/daemon/buildHello.ts
+var ASSIST_VERSION = package_default.version;
+function buildHello() {
+  return { type: "hello", version: ASSIST_VERSION };
+}
+function isHello(msg) {
+  return msg.type === "hello" && typeof msg.version === "string";
+}
+function versionsMatch(a, b) {
+  return a === b;
+}
+
+// src/commands/sessions/daemon/toWindowsSessionId.ts
+var PREFIX = "w-";
+function toWindowsSessionId(id) {
+  return `${PREFIX}${id}`;
+}
+function isWindowsSessionId(id) {
+  return id.startsWith(PREFIX);
+}
+function stripWindowsSessionId(id) {
+  return id.startsWith(PREFIX) ? id.slice(PREFIX.length) : id;
+}
+
+// src/commands/sessions/daemon/WindowsProxyState.ts
+var MAX_SCROLLBACK2 = 256 * 1024;
+function createState(broadcast2, onSessionsChanged) {
+  return {
+    windowsSessions: [],
+    scrollback: /* @__PURE__ */ new Map(),
+    pendingCreators: [],
+    broadcast: broadcast2,
+    onSessionsChanged
+  };
+}
+function resetState(state) {
+  state.windowsSessions = [];
+  state.scrollback.clear();
+  state.pendingCreators = [];
+}
+function replayScrollback2(state, client) {
+  for (const [sessionId, data] of state.scrollback)
+    if (data) sendTo(client, { type: "output", sessionId, data });
+}
+function appendScrollback2(state, sessionId, data) {
+  const next3 = (state.scrollback.get(sessionId) ?? "") + data;
+  state.scrollback.set(
+    sessionId,
+    next3.length > MAX_SCROLLBACK2 ? next3.slice(-MAX_SCROLLBACK2) : next3
+  );
+}
+
+// src/commands/sessions/daemon/handleInbound.ts
+function handleInbound(state, line) {
+  let msg;
+  try {
+    msg = JSON.parse(line);
+  } catch {
+    return;
+  }
+  inbound[msg.type]?.(state, msg);
+}
+var inbound = {
+  hello: (_state, msg) => handleHello(msg),
+  created: handleCreated,
+  sessions: handleSessions,
+  output: handleOutput,
+  clear: relayWithSessionId,
+  error: (state, msg) => state.broadcast(msg)
+};
+function handleHello(msg) {
+  if (isHello(msg) && !versionsMatch(msg.version, ASSIST_VERSION))
+    daemonLog(
+      `windows daemon version mismatch: ${msg.version} (wsl ${ASSIST_VERSION})`
+    );
+}
+function handleCreated(state, msg) {
+  const client = state.pendingCreators.shift();
+  if (client) sendTo(client, { type: "created", sessionId: nsId(msg) });
+}
+function handleSessions(state, msg) {
+  state.windowsSessions = msg.sessions.map((s) => ({
+    ...s,
+    id: toWindowsSessionId(s.id)
+  }));
+  const live = new Set(state.windowsSessions.map((s) => s.id));
+  for (const id of state.scrollback.keys())
+    if (!live.has(id)) state.scrollback.delete(id);
+  state.onSessionsChanged();
+}
+function handleOutput(state, msg) {
+  const sessionId = nsId(msg);
+  const data = msg.data;
+  appendScrollback2(state, sessionId, data);
+  state.broadcast({ type: "output", sessionId, data });
+}
+function relayWithSessionId(state, msg) {
+  state.broadcast({ ...msg, sessionId: nsId(msg) });
+}
+function nsId(msg) {
+  return toWindowsSessionId(msg.sessionId);
+}
+
+// src/commands/sessions/daemon/isWindowsCwd.ts
+function isWindowsCwd(cwd) {
+  return /^[A-Za-z]:[\\/]/.test(cwd);
+}
+function shouldProxyToWindows(cwd) {
+  return detectPlatform() === "wsl" && isWindowsCwd(cwd);
+}
+
+// src/commands/sessions/daemon/WindowsConnection.ts
+import { createInterface as createInterface5 } from "readline";
+var WindowsConnection = class {
+  constructor(deps2) {
+    this.deps = deps2;
+  }
+  connection = null;
+  socket = null;
+  ensure() {
+    if (this.connection) return this.connection;
+    const connection = this.open();
+    this.connection = connection;
+    connection.catch(() => {
+      if (this.connection === connection) this.connection = null;
+    });
+    return connection;
+  }
+  write(msg) {
+    this.socket?.write(`${JSON.stringify(msg)}
+`);
+  }
+  trySend(msg) {
+    if (!this.socket?.writable) return false;
+    this.write(msg);
+    return true;
+  }
+  dispose() {
+    this.socket?.destroy();
+    this.reset();
+  }
+  async open() {
+    const socket = await this.deps.connect();
+    this.socket = socket;
+    const lines = createInterface5({ input: socket });
+    lines.on("error", () => {
+    });
+    lines.on("line", (line) => this.deps.onLine(line));
+    socket.on("error", () => {
+    });
+    socket.on("close", () => {
+      this.reset();
+      this.deps.onClose();
+    });
+    this.write(buildHello());
+    return socket;
+  }
+  reset() {
+    this.socket = null;
+    this.connection = null;
+  }
+};
+
+// src/commands/sessions/daemon/WindowsProxy.ts
+var WindowsProxy = class {
+  state;
+  conn;
+  constructor(clients, onSessionsChanged, connect3 = defaultConnect) {
+    this.state = createState(
+      (msg) => broadcast(clients, msg),
+      onSessionsChanged
+    );
+    this.conn = new WindowsConnection({
+      connect: connect3,
+      onLine: (line) => handleInbound(this.state, line),
+      onClose: () => this.handleClose()
+    });
+  }
+  sessions() {
+    return this.state.windowsSessions;
+  }
+  replayScrollback(client) {
+    replayScrollback2(this.state, client);
+  }
+  // Returns true when the message targets Windows: a create/resume in a
+  // windows-origin cwd is forwarded, as is I/O for a namespaced session id.
+  route(client, data) {
+    if (isWindowsCreate(data)) {
+      void this.forwardCreate(client, data);
+      return true;
+    }
+    if (isWindowsIo(data)) {
+      const sessionId = stripWindowsSessionId(data.sessionId);
+      this.conn.trySend({ ...data, sessionId });
+      return true;
+    }
+    return false;
+  }
+  dispose() {
+    this.conn.dispose();
+  }
+  async forwardCreate(client, data) {
+    try {
+      await this.conn.ensure();
+      this.state.pendingCreators.push(client);
+      this.conn.write(data);
+    } catch (e) {
+      sendTo(client, {
+        type: "error",
+        message: `Windows session unavailable: ${errorText(e)}`
+      });
+    }
+  }
+  handleClose() {
+    for (const client of this.state.pendingCreators)
+      sendTo(client, {
+        type: "error",
+        message: "Windows daemon connection closed"
+      });
+    resetState(this.state);
+    this.state.onSessionsChanged();
+  }
+};
+function isWindowsCreate(data) {
+  return typeof data.cwd === "string" && shouldProxyToWindows(data.cwd);
+}
+function isWindowsIo(data) {
+  return typeof data.sessionId === "string" && isWindowsSessionId(data.sessionId);
+}
+async function defaultConnect() {
+  await ensureWindowsDaemonRunning();
+  return connectToWindowsDaemon();
+}
+function errorText(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+
 // src/commands/sessions/daemon/watchClaudeSessionId.ts
 import * as fs27 from "fs";
 import * as path48 from "path";
@@ -18753,10 +19064,12 @@ var SessionManager = class {
   clients = /* @__PURE__ */ new Set();
   nextId = 1;
   shuttingDown = false;
+  // why: dispatch calls windowsProxy.route() to forward windows-origin sessions
+  windowsProxy = new WindowsProxy(this.clients, () => this.notify());
   addClient(client) {
     this.clients.add(client);
     this.onIdleChange?.(this.isIdle());
-    greetClient(client, this.sessions, () => this.listSessions());
+    greetClient(client, this.sessions, this.listSessions, this.windowsProxy);
   }
   removeClient(client) {
     this.clients.delete(client);
@@ -18825,22 +19138,24 @@ var SessionManager = class {
   setAutoAdvance(id, enabled) {
     if (setAutoAdvance(this.sessions, id, enabled)) this.notify();
   }
-  listSessions() {
-    return [...this.sessions.values()].map(toSessionInfo);
-  }
+  listSessions = () => {
+    const local = [...this.sessions.values()].map(toSessionInfo);
+    return local.concat(this.windowsProxy.sessions());
+  };
   notify = () => {
     if (this.shuttingDown) return;
-    broadcastSessions(this.sessions, this.clients);
+    const windows = this.windowsProxy.sessions();
+    broadcastSessions(this.sessions, this.clients, windows);
     this.onIdleChange?.(this.isIdle());
   };
 };
 
 // src/commands/sessions/daemon/startDaemonServer.ts
 import { unlinkSync as unlinkSync19 } from "fs";
-import * as net2 from "net";
+import * as net3 from "net";
 
 // src/commands/sessions/daemon/handleConnection.ts
-import { createInterface as createInterface5 } from "readline";
+import { createInterface as createInterface6 } from "readline";
 
 // src/commands/sessions/shared/parseTranscript.ts
 import * as fs28 from "fs";
@@ -18932,46 +19247,11 @@ function safeParse2(line) {
 }
 
 // src/commands/sessions/daemon/dispatchMessage.ts
-function sendCreated(client, id) {
-  sendTo(client, { type: "created", sessionId: id });
-}
-function handleCreate(client, manager, data) {
-  sendCreated(
-    client,
-    manager.spawn(
-      data.prompt,
-      data.cwd
-    )
-  );
-}
-function handleCreateRun(client, manager, data) {
-  sendCreated(
-    client,
-    manager.spawnRun(
-      data.runName,
-      data.runArgs ?? [],
-      data.cwd
-    )
-  );
-}
-function handleCreateAssist(client, manager, data) {
-  sendCreated(
-    client,
-    manager.spawnAssist(
-      data.assistArgs ?? [],
-      data.cwd
-    )
-  );
-}
-function handleResume(client, manager, data) {
-  sendCreated(
-    client,
-    manager.resume(
-      data.sessionId,
-      data.cwd,
-      data.name
-    )
-  );
+function creator(spawn11) {
+  return (client, m, d) => {
+    if (m.windowsProxy.route(client, d)) return;
+    sendTo(client, { type: "created", sessionId: spawn11(m, d) });
+  };
 }
 function handleHistory(client) {
   discoverSessions().then(
@@ -18989,21 +19269,54 @@ function handleShutdown(client, manager) {
   sendTo(client, { type: "shutting-down" });
   setImmediate(() => process.exit(0));
 }
+function routed(local) {
+  return (client, m, d) => {
+    if (!m.windowsProxy.route(client, d)) local(client, m, d);
+  };
+}
 var handlers = {
   ping: (client) => sendTo(client, { type: "pong", pid: process.pid }),
-  create: handleCreate,
-  "create-run": handleCreateRun,
-  "create-assist": handleCreateAssist,
-  resume: handleResume,
+  hello: (client) => sendTo(client, buildHello()),
+  create: creator(
+    (m, d) => m.spawn(d.prompt, d.cwd)
+  ),
+  "create-run": creator(
+    (m, d) => m.spawnRun(
+      d.runName,
+      d.runArgs ?? [],
+      d.cwd
+    )
+  ),
+  "create-assist": creator(
+    (m, d) => m.spawnAssist(
+      d.assistArgs ?? [],
+      d.cwd
+    )
+  ),
+  resume: creator(
+    (m, d) => m.resume(
+      d.sessionId,
+      d.cwd,
+      d.name
+    )
+  ),
   history: handleHistory,
   "fetch-transcript": handleFetchTranscript,
   shutdown: handleShutdown,
-  input: (_client, m, d) => m.writeToSession(d.sessionId, d.data),
-  resize: (_client, m, d) => m.resizeSession(d.sessionId, d.cols, d.rows),
-  retry: (_client, m, d) => m.retrySession(d.sessionId),
-  dismiss: (_client, m, d) => m.dismissSession(d.sessionId),
-  "set-autorun": (_client, m, d) => m.setAutoRun(d.sessionId, d.enabled),
-  "set-autoadvance": (_client, m, d) => m.setAutoAdvance(d.sessionId, d.enabled)
+  input: routed(
+    (_client, m, d) => m.writeToSession(d.sessionId, d.data)
+  ),
+  resize: routed(
+    (_client, m, d) => m.resizeSession(d.sessionId, d.cols, d.rows)
+  ),
+  retry: routed((_client, m, d) => m.retrySession(d.sessionId)),
+  dismiss: routed((_client, m, d) => m.dismissSession(d.sessionId)),
+  "set-autorun": routed(
+    (_client, m, d) => m.setAutoRun(d.sessionId, d.enabled)
+  ),
+  "set-autoadvance": routed(
+    (_client, m, d) => m.setAutoAdvance(d.sessionId, d.enabled)
+  )
 };
 function dispatchMessage(client, manager, data) {
   handlers[data.type]?.(client, manager, data);
@@ -19018,7 +19331,7 @@ function handleConnection(socket, manager) {
     }
   };
   manager.addClient(client);
-  const lines = createInterface5({ input: socket });
+  const lines = createInterface6({ input: socket });
   lines.on("error", () => {
   });
   lines.on("line", (line) => {
@@ -19095,9 +19408,10 @@ function cleanupOwnedFiles() {
 
 // src/commands/sessions/daemon/startDaemonServer.ts
 function startDaemonServer(manager, checkAutoExit) {
-  const server = net2.createServer(
+  const server = net3.createServer(
     (socket) => handleConnection(socket, manager)
   );
+  if (process.platform === "win32") startWindowsBridge(manager);
   let retried = false;
   server.on("error", (e) => {
     if (e.code !== "EADDRINUSE" || retried) {
@@ -19109,6 +19423,17 @@ function startDaemonServer(manager, checkAutoExit) {
   });
   server.listen(daemonPaths.socket, () => onListening(manager, checkAutoExit));
 }
+function startWindowsBridge(manager) {
+  const port = windowsDaemonPort();
+  const bridge = net3.createServer(
+    (socket) => handleConnection(socket, manager)
+  );
+  bridge.on(
+    "error",
+    (e) => daemonLog(`windows bridge error: ${e.message}`)
+  );
+  bridge.listen(port, () => daemonLog(`windows bridge listening on :${port}`));
+}
 async function recoverFromAddrInUse(server, manager, checkAutoExit) {
   if (await isDaemonRunning()) {
     daemonLog("another daemon owns the socket; exiting");

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@staff0rd/assist",
-	"version": "0.284.1",
+	"version": "0.285.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {