@staff0rd/assist 0.413.0 → 0.414.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.413.0",
+  version: "0.414.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -134,12 +134,15 @@ import chalk2 from "chalk";
 import { Pool } from "pg";
 
 // src/shared/loadConfig.ts
-import { existsSync as existsSync2, writeFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, join } from "path";
+import { writeFileSync } from "fs";
 import chalk from "chalk";
 import { stringify as stringifyYaml } from "yaml";
 
+// src/shared/loadConfigFrom.ts
+import { existsSync as existsSync2 } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
 // src/commands/backlog/getCurrentOrigin.ts
 import { execFileSync } from "child_process";
 function stripLeadingSlashes(path71) {
@@ -332,7 +335,9 @@ var runConfigSchema = z.strictObject({
   filter: z.string().optional(),
   pre: z.array(z.string()).optional(),
   cwd: z.string().optional(),
-  quiet: z.boolean().optional()
+  quiet: z.boolean().optional(),
+  server: z.boolean().optional(),
+  port: z.number().optional()
 });
 var runLinkSchema = z.strictObject({
   link: z.string(),
@@ -506,7 +511,7 @@ var assistConfigSchema = z2.strictObject({
   })
 });
 
-// src/shared/loadConfig.ts
+// src/shared/loadConfigFrom.ts
 function findConfigUp(startDir) {
   let current = startDir;
   while (current !== dirname(current)) {
@@ -519,31 +524,42 @@ function findConfigUp(startDir) {
   }
   return null;
 }
-function getConfigPath() {
-  const found = findConfigUp(process.cwd());
+function getConfigPathFrom(cwd) {
+  const found = findConfigUp(cwd);
   if (found) return found.configPath;
-  return join(process.cwd(), "assist.yml");
+  return join(cwd, "assist.yml");
 }
 function getGlobalConfigPath() {
   return join(homedir(), ".assist.yml");
 }
-function getConfigDir() {
-  return dirname(getConfigPath());
-}
-function getProjectRoot() {
-  const found = findConfigUp(process.cwd());
-  return found?.rootDir ?? process.cwd();
+function getConfigDirFrom(cwd) {
+  return dirname(getConfigPathFrom(cwd));
 }
-function loadConfig() {
+function loadConfigFrom(cwd) {
   const globalRaw = loadRawYaml(getGlobalConfigPath());
-  const projectRaw = loadRawYaml(getConfigPath());
-  const repoOverride = globalRaw.repos ? resolveRepoOverride(globalRaw, getCurrentOrigin(process.cwd())) : {};
+  const projectRaw = loadRawYaml(getConfigPathFrom(cwd));
+  const repoOverride = globalRaw.repos ? resolveRepoOverride(globalRaw, getCurrentOrigin(cwd)) : {};
   const globalWithRepo = mergeRawConfigs(globalRaw, repoOverride);
   const merged = mergeRawConfigs(globalWithRepo, projectRaw);
   delete merged.repos;
   delete merged.news;
   return assistConfigSchema.parse(merged);
 }
+
+// src/shared/loadConfig.ts
+function getConfigPath() {
+  return getConfigPathFrom(process.cwd());
+}
+function getConfigDir() {
+  return getConfigDirFrom(process.cwd());
+}
+function getProjectRoot() {
+  const found = findConfigUp(process.cwd());
+  return found?.rootDir ?? process.cwd();
+}
+function loadConfig() {
+  return loadConfigFrom(process.cwd());
+}
 function loadProjectConfig() {
   return loadRawYaml(getConfigPath());
 }
@@ -8504,6 +8520,32 @@ function getHtml() {
 </html>`;
 }
 
+// src/commands/sessions/web/getCwdParam.ts
+function getCwdParam(req, res) {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const cwd = url.searchParams.get("cwd");
+  if (!cwd) {
+    respondJson(res, 400, { error: "Missing cwd" });
+    return null;
+  }
+  return cwd;
+}
+
+// src/commands/sessions/web/handleServerRuns.ts
+function getServerRuns(cwd) {
+  try {
+    const { run: run4 } = loadConfigFrom(cwd);
+    return resolveRunConfigs(run4, getConfigDirFrom(cwd)).filter((r) => r.server).map((r) => ({ name: r.name, port: r.port }));
+  } catch {
+    return [];
+  }
+}
+function handleServerRuns(req, res) {
+  const cwd = getCwdParam(req, res);
+  if (!cwd) return;
+  respondJson(res, 200, { runs: getServerRuns(cwd) });
+}
+
 // src/commands/sessions/web/getReviewSynthesis.ts
 import { execFile as execFile2 } from "child_process";
 import { readFileSync as readFileSync19 } from "fs";
@@ -8523,17 +8565,6 @@ function findSynthesisForBranch(repoReviewsDir, branch2) {
   return synthesisFiles[0]?.path ?? null;
 }
 
-// src/commands/sessions/web/getCwdParam.ts
-function getCwdParam(req, res) {
-  const url = new URL(req.url ?? "/", "http://localhost");
-  const cwd = url.searchParams.get("cwd");
-  if (!cwd) {
-    respondJson(res, 400, { error: "Missing cwd" });
-    return null;
-  }
-  return cwd;
-}
-
 // src/commands/sessions/web/windowsCwdToWslPath.ts
 function windowsCwdToWslPath(cwd) {
   const match = /^([A-Za-z]):[\\/](.*)$/.exec(cwd);
@@ -9202,6 +9233,7 @@ var routes2 = {
   "GET /api/jira-site": jiraSite,
   "GET /api/harness": harnessCapabilities,
   "GET /api/pr-status": prStatus,
+  "GET /api/server-runs": handleServerRuns,
   "GET /api/pr-list": prList,
   "GET /api/news/items": listNewsItems,
   "GET /api/usage/history": listUsageHistory,
@@ -24759,6 +24791,8 @@ function toSessionInfo({
   runningSince,
   runName,
   runArgs,
+  server,
+  serverPort,
   assistArgs,
   cwd,
   restored,
@@ -24784,6 +24818,8 @@ function toSessionInfo({
     runningSince,
     runName,
     runArgs,
+    server,
+    port: serverPort,
     assistArgs,
     cwd,
     restored,
@@ -24957,6 +24993,28 @@ function createAssistSession(id, assistArgs, cwd, meta) {
 // src/commands/sessions/daemon/createSession.ts
 import { randomUUID as randomUUID4 } from "crypto";
 
+// src/commands/sessions/daemon/resolveRunConfig.ts
+function resolveRunConfig(name, cwd) {
+  try {
+    const { run: run4 } = loadConfigFrom(cwd);
+    const configs = resolveRunConfigs(run4, getConfigDirFrom(cwd));
+    const exact = configs.find((r) => r.name === name);
+    if (exact) return exact;
+    const suffixMatches = configs.filter((r) => r.name.endsWith(`:${name}`));
+    return suffixMatches.length === 1 ? suffixMatches[0] : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/commands/sessions/daemon/serverRunMeta.ts
+function serverRunMeta(runName, cwd) {
+  const dir = cwd ?? process.cwd();
+  const config = resolveRunConfig(runName, dir);
+  if (!config?.server) return { server: false };
+  return { server: true, port: config.port, origin: getCurrentOrigin(dir) };
+}
+
 // src/commands/sessions/daemon/readDesignSystemPrompt.ts
 import * as fs35 from "fs";
 import * as path59 from "path";
@@ -25037,7 +25095,7 @@ function createPiSession(id, prompt, cwd) {
     initialPrompt: prompt
   };
 }
-function createRunSession(id, runName, runArgs, cwd) {
+function createRunSession(id, runName, runArgs, cwd, meta = serverRunMeta(runName, cwd)) {
   return {
     ...sessionBase(id, "running"),
     name: `run: ${runName}`,
@@ -25045,7 +25103,10 @@ function createRunSession(id, runName, runArgs, cwd) {
     pty: spawnRun({ name: runName, args: runArgs, cwd }),
     runName,
     runArgs,
-    cwd
+    cwd,
+    server: meta.server || void 0,
+    serverPort: meta.port,
+    serverOrigin: meta.origin
   };
 }
 
@@ -25442,6 +25503,18 @@ function errorTail(scrollback) {
   return tail.length > MAX_TAIL_CHARS ? tail.slice(-MAX_TAIL_CHARS) : tail;
 }
 
+// src/commands/sessions/daemon/handleFailedResume.ts
+function handleFailedResume(session, exitCode, onStatusChange) {
+  const failed2 = session.restored === true && exitCode !== 0 && session.scrollback.length === 0;
+  if (!failed2) return false;
+  session.error = `resume process exited with code ${exitCode} before producing any output`;
+  daemonLog(
+    `could not resume restored session "${session.name}" (id ${session.id}): ${session.error}`
+  );
+  onStatusChange(session, "error", exitCode);
+  return true;
+}
+
 // src/commands/sessions/daemon/watchActivity.ts
 import { existsSync as existsSync58, mkdirSync as mkdirSync25, watch } from "fs";
 import { dirname as dirname29 } from "path";
@@ -25535,6 +25608,18 @@ function refreshActivity(session) {
     session.claudeSessionId = activity2.claudeSessionId;
 }
 
+// src/commands/sessions/daemon/handleStoppedExit.ts
+function handleStoppedExit(session, exitCode, onStatusChange) {
+  if (!session.stopping) return false;
+  session.stopping = void 0;
+  refreshActivity(session);
+  daemonLog(
+    `session ${session.id} ("${session.name}") pty exited (code ${exitCode}) after stop request; marking done`
+  );
+  onStatusChange(session, "done", 0);
+  return true;
+}
+
 // src/commands/sessions/daemon/handlePtyExit.ts
 function handlePtyExit(session, exitCode, onStatusChange) {
   if (session.pendingRestart) {
@@ -25546,16 +25631,9 @@ function handlePtyExit(session, exitCode, onStatusChange) {
     resume();
     return;
   }
+  if (handleStoppedExit(session, exitCode, onStatusChange)) return;
   refreshActivity(session);
-  const failedResume = session.restored === true && exitCode !== 0 && session.scrollback.length === 0;
-  if (failedResume) {
-    session.error = `resume process exited with code ${exitCode} before producing any output`;
-    daemonLog(
-      `could not resume restored session "${session.name}" (id ${session.id}): ${session.error}`
-    );
-    onStatusChange(session, "error", exitCode);
-    return;
-  }
+  if (handleFailedResume(session, exitCode, onStatusChange)) return;
   const priorStatus = session.status;
   if (exitCode !== 0) {
     const tail = errorTail(session.scrollback);
@@ -26170,6 +26248,59 @@ function respawnThunk(session) {
   return null;
 }
 
+// src/commands/sessions/daemon/serverConflictInfo.ts
+function serverConflictInfo(session) {
+  return {
+    id: session.id,
+    name: session.name,
+    cwd: session.cwd,
+    port: session.serverPort
+  };
+}
+
+// src/commands/sessions/daemon/liveServerRun.ts
+function liveServerRun(sessions, origin, excludeId) {
+  for (const s of sessions.values()) {
+    if (s.id === excludeId || !s.server || s.serverOrigin !== origin) continue;
+    if (s.status !== "done" && s.status !== "error") return s;
+  }
+  return void 0;
+}
+function stopServerSession(sessions, id) {
+  const s = sessions.get(id);
+  if (!s?.pty || s.status === "done" || s.status === "error") return;
+  s.stopping = true;
+  daemonLog(`session ${id} stopped (${s.name})`);
+  s.pty.kill();
+}
+
+// src/commands/sessions/daemon/runRetry.ts
+function tagServerSession(session, meta) {
+  session.server = meta.server || void 0;
+  session.serverPort = meta.port;
+  session.serverOrigin = meta.origin;
+}
+function findRetryConflict(sessions, session, replace, dismiss) {
+  const meta = serverRunMeta(session.runName ?? "", session.cwd);
+  if (meta.server && meta.origin) {
+    const existing = liveServerRun(sessions, meta.origin, session.id);
+    if (existing && !replace) return serverConflictInfo(existing);
+    if (existing) dismiss(existing.id);
+  }
+  tagServerSession(session, meta);
+  return null;
+}
+function runRetry(sessions, id, replace, deps2) {
+  const s = sessions.get(id);
+  if (!s) return null;
+  if (s.commandType === "run" && s.runName) {
+    const conflict = findRetryConflict(sessions, s, replace, deps2.dismiss);
+    if (conflict) return conflict;
+  }
+  if (retrySession(s, deps2.clients, deps2.onStatusChange)) deps2.notify();
+  return null;
+}
+
 // src/commands/sessions/daemon/reuseSessionForRun.ts
 function reuseSessionForRun(session, itemId2, clients, onStatusChange) {
   const assistArgs = ["backlog", "run", String(itemId2)];
@@ -27044,8 +27175,13 @@ var SessionManager = class {
       (id) => createSession(id, prompt, cwd, design, harness)
     );
   }
-  spawnRun(runName, runArgs, cwd) {
-    return this.spawnWith((id) => createRunSession(id, runName, runArgs, cwd));
+  spawnRun(runName, runArgs, cwd, meta) {
+    return this.spawnWith(
+      (id) => createRunSession(id, runName, runArgs, cwd, meta)
+    );
+  }
+  liveServerRun(origin, excludeId) {
+    return liveServerRun(this.sessions, origin, excludeId);
   }
   spawnAssist(assistArgs, cwd, meta) {
     return this.spawnWith(
@@ -27071,9 +27207,13 @@ var SessionManager = class {
   resizeSession(id, cols, rows) {
     resizeSession(this.sessions, id, cols, rows);
   }
-  retrySession(id) {
-    const s = this.sessions.get(id);
-    if (s && retrySession(s, this.clients, this.onStatusChange)) this.notify();
+  retrySession(id, replace = false) {
+    return runRetry(this.sessions, id, replace, {
+      clients: this.clients,
+      onStatusChange: this.onStatusChange,
+      dismiss: this.dismissSession,
+      notify: this.notify
+    });
   }
   restart(id) {
     const result = restartManagedSession(
@@ -27088,6 +27228,9 @@ var SessionManager = class {
   dismissSession = (id) => {
     if (dismissSession(this.sessions, id)) this.notify();
   };
+  stopSession(id) {
+    stopServerSession(this.sessions, id);
+  }
   setAutoRun(id, enabled) {
     if (setAutoRun(this.sessions, id, enabled)) this.notify();
   }
@@ -27139,6 +27282,41 @@ function creator(isNew, spawn12) {
   };
 }
 
+// src/commands/sessions/daemon/handleCreateRun.ts
+function handleCreateRun(client, m, d) {
+  if (m.windowsProxy.route(client, d)) return;
+  const runName = d.runName;
+  const cwd = d.cwd;
+  const runArgs = d.runArgs ?? [];
+  const meta = serverRunMeta(runName, cwd);
+  if (meta.server && meta.origin) {
+    const existing = m.liveServerRun(meta.origin);
+    if (existing && d.replace !== true) {
+      daemonLog(
+        `create-run ${runName} rejected: server ${existing.id} already live for ${meta.origin}`
+      );
+      sendTo(client, {
+        type: "run-conflict",
+        runName,
+        cwd,
+        existing: serverConflictInfo(existing)
+      });
+      return;
+    }
+    if (existing) {
+      daemonLog(
+        `create-run ${runName} replacing live server ${existing.id} for ${meta.origin}`
+      );
+      m.dismissSession(existing.id);
+    }
+  }
+  sendTo(client, {
+    type: "created",
+    sessionId: m.spawnRun(runName, runArgs, cwd, meta),
+    isNew: true
+  });
+}
+
 // src/commands/sessions/daemon/handleSetStatus.ts
 function handleSetStatus(client, m, d) {
   daemonLog(
@@ -27280,14 +27458,7 @@ var messageHandlers = {
   "subscribe-logs": (client, m, d) => m.clients.subscribeLogs(client, d.replay !== false),
   hello: (client) => sendTo(client, buildHello()),
   create: creator(true, spawnCreate),
-  "create-run": creator(
-    true,
-    (m, d) => m.spawnRun(
-      d.runName,
-      d.runArgs ?? [],
-      d.cwd
-    )
-  ),
+  "create-run": handleCreateRun,
   "create-assist": creator(
     true,
     (m, d) => m.spawnAssist(
@@ -27321,13 +27492,22 @@ var messageHandlers = {
   resize: routed(
     (_client, m, d) => m.resizeSession(d.sessionId, d.cols, d.rows)
   ),
-  retry: routed((_client, m, d) => m.retrySession(d.sessionId)),
+  retry: routed((client, m, d) => {
+    const conflict = m.retrySession(d.sessionId, d.replace === true);
+    if (conflict)
+      sendTo(client, {
+        type: "run-conflict",
+        sessionId: d.sessionId,
+        existing: conflict
+      });
+  }),
   restart: routed((client, m, d) => {
     const result = m.restart(d.sessionId);
     if (!result.ok && result.reason)
       sendTo(client, { type: "error", message: result.reason });
   }),
   dismiss: routed((_client, m, d) => m.dismissSession(d.sessionId)),
+  stop: routed((_client, m, d) => m.stopSession(d.sessionId)),
   "set-autorun": routed(
     (_client, m, d) => m.setAutoRun(d.sessionId, d.enabled)
   ),

package/package.json

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