fix(server): macOS support for the idle gjc lane + live detection — remove comm/lsof/proc/locale Linux assumptions

server/modules/providers/provider.routes.ts

@@ -9,8 +9,8 @@ import { sessionConversationsSearchService } from '@/modules/providers/services/
 import { sessionsService } from '@/modules/providers/services/sessions.service.js';
 import { getLiveGjcSessions, IDLE_GJC_ID_PREFIX } from '@/modules/providers/services/live-sessions.service.js';
 import { getExternalCliSessions } from '@/modules/providers/services/external-cli-sessions.service.js';
-import { getHomeDir, getHomeDirSuggestions } from '@/modules/providers/services/home-dirs.service.js';
-import { isValidTmuxName, sendToLiveSession, isValidSpawnName, spawnLiveSession, killLiveSession } from '@/modules/providers/services/live-send.service.js';
+import { getHomeDir, getHomeDirSuggestions, getSpawnDirSuggestions } from '@/modules/providers/services/home-dirs.service.js';
+import { isValidTmuxName, sendToLiveSession, isValidSpawnName, spawnLiveSession, killLiveSession, answerLiveSession } from '@/modules/providers/services/live-send.service.js';
 import type {
   LLMProvider,
   McpScope,
@@ -600,10 +600,14 @@ router.get(
 router.get(
   '/fs/dir-suggestions',
   asyncHandler(async (req: Request, res: Response) => {
-    // Home-relative directory autocomplete (spawn form cwd + files panel root).
-    // Read-only readdir under $HOME, traversal-guarded in the service.
+    // Directory autocomplete. Default scope stays $HOME-relative (files panel
+    // joins home + suggestion, so extra roots would break it); scope=spawn adds
+    // the tower's TOWER_ALLOWED_ROOTS children first — the strings it returns
+    // are exactly what the tower's /spawn cwd resolution accepts.
     const prefix = typeof req.query.prefix === 'string' ? req.query.prefix : '';
-    const suggestions = await getHomeDirSuggestions(prefix);
+    const suggestions = req.query.scope === 'spawn'
+      ? await getSpawnDirSuggestions(prefix)
+      : await getHomeDirSuggestions(prefix);
     res.json(createApiSuccessResponse({ home: getHomeDir(), suggestions }));
   }),
 );
@@ -624,7 +628,7 @@ router.get(
  */
 const TMUX_ID_RE = /^\$\d+$/;
 
-async function assertLineageTmuxTarget(tmuxName: string, tmuxId: string | null): Promise<void> {
+async function assertLineageTmuxTarget(tmuxName: string, tmuxId: string): Promise<void> {
   const live = await getLiveGjcSessions();
   const matches = live.filter((session) => session.tmuxName === tmuxName && session.claim === 'lineage');
   if (matches.length === 0) {
@@ -633,23 +637,25 @@ async function assertLineageTmuxTarget(tmuxName: string, tmuxId: string | null):
       statusCode: 403,
     });
   }
-  if (tmuxId !== null && !matches.some((session) => session.tmuxId === tmuxId)) {
+  if (!matches.some((session) => session.tmuxId === tmuxId)) {
     throw new AppError('tmux 세션이 그 사이 교체되었습니다 — 같은 이름의 다른 세션입니다. 목록을 새로고침한 뒤 다시 시도하세요.', {
       code: 'TMUX_GENERATION_MISMATCH',
       statusCode: 409,
     });
   }
 }
 
-/** Optional `$N` generation token from the request body; malformed values are rejected. */
-function readTmuxIdParam(value: unknown): string | null {
-  if (value === undefined || value === null || value === '') {
-    return null;
-  }
+/**
+ * REQUIRED `$N` generation token from the request body. A missing token is a
+ * 400, not a skipped check — otherwise any authenticated caller could omit it
+ * and bypass the same-name replacement guard entirely (리뷰 HIGH: fail-closed
+ * means the generation comparison must be unavoidable).
+ */
+function readTmuxIdParam(value: unknown): string {
   if (typeof value === 'string' && TMUX_ID_RE.test(value)) {
     return value;
   }
-  throw new AppError('tmuxId must look like "$<number>".', { code: 'INVALID_TMUX_ID', statusCode: 400 });
+  throw new AppError('tmuxId is required and must look like "$<number>".', { code: 'INVALID_TMUX_ID', statusCode: 400 });
 }
 
 router.post(
@@ -702,6 +708,27 @@ router.post(
   }),
 );
 
+router.post(
+  '/sessions/live/answer',
+  asyncHandler(async (req: Request, res: Response) => {
+    // Answer a live session's ask-TUI menu: the tower navigates to the exact
+    // option label and commits only after verifying the cursor row. Same
+    // lineage + generation-token gate as send/kill — a stale UI must not drive
+    // keystrokes into a same-named session that replaced the one it saw.
+    const body = (req.body ?? {}) as { tmuxName?: unknown; tmuxId?: unknown; label?: unknown };
+    if (!isValidTmuxName(body.tmuxName)) {
+      throw new AppError('A valid tmuxName is required.', { code: 'INVALID_TMUX_NAME', statusCode: 400 });
+    }
+    const label = typeof body.label === 'string' ? body.label : '';
+    if (!label.trim()) {
+      throw new AppError('label is required.', { code: 'EMPTY_LABEL', statusCode: 400 });
+    }
+    await assertLineageTmuxTarget(body.tmuxName, readTmuxIdParam(body.tmuxId));
+    const result = await answerLiveSession(body.tmuxName, label);
+    res.json(createApiSuccessResponse(result));
+  }),
+);
+
 router.delete(
   '/sessions/:sessionId',
   asyncHandler(async (req: Request, res: Response) => {

server/modules/providers/services/external-cli-sessions.service.ts

@@ -25,6 +25,16 @@ export type ExternalCliSession = { tmuxName: string; kind: ExternalCliKind };
 /** Matches the tower/live-send tmux-name discipline; also safe to embed in a shell command. */
 export const EXTERNAL_TMUX_NAME_RE = /^[A-Za-z0-9._-]{1,64}$/;
 
+/**
+ * macOS `ps -eo comm` prints the executable's FULL PATH (e.g.
+ * /Applications/ChatGPT.app/Contents/Resources/codex) while Linux prints the
+ * bare name — classification compares bare names, so normalize to basename.
+ */
+function commBasename(comm: string): string {
+  const slash = comm.lastIndexOf('/');
+  return slash < 0 ? comm : comm.slice(slash + 1);
+}
+
 /** Parses `#{session_name}\t#{pane_pid}\t#{pane_current_command}` lines. */
 export function parseExternalPanes(output: string): Array<{ name: string; pid: number; command: string }> {
   const panes: Array<{ name: string; pid: number; command: string }> = [];
@@ -39,15 +49,15 @@ export function parseExternalPanes(output: string): Array<{ name: string; pid: n
     }
     const name = raw.slice(0, first).trim();
     const pid = Number.parseInt(raw.slice(first + 1, second).trim(), 10);
-    const command = raw.slice(second + 1).trim();
+    const command = commBasename(raw.slice(second + 1).trim());
     if (name && Number.isFinite(pid)) {
       panes.push({ name, pid, command });
     }
   }
   return panes;
 }
 
-/** Parses `ps -eo pid,ppid,comm` output into {pid, ppid, comm} rows (header tolerated). */
+/** Parses `ps -eo pid,ppid,comm` into {pid, ppid, comm} rows (header tolerated, comm → basename). */
 export function parsePsTree(output: string): Array<{ pid: number; ppid: number; comm: string }> {
   const rows: Array<{ pid: number; ppid: number; comm: string }> = [];
   for (const raw of output.split(/\r?\n/)) {
@@ -59,11 +69,84 @@ export function parsePsTree(output: string): Array<{ pid: number; ppid: number;
     if (!match) {
       continue; // header or malformed line
     }
-    rows.push({ pid: Number.parseInt(match[1], 10), ppid: Number.parseInt(match[2], 10), comm: match[3].trim() });
+    rows.push({ pid: Number.parseInt(match[1], 10), ppid: Number.parseInt(match[2], 10), comm: commBasename(match[3].trim()) });
   }
   return rows;
 }
 
+/**
+ * Pids whose COMMAND LINE identifies gjc, from `ps -eo pid=,args=` output.
+ * comm alone cannot see script installs — macOS 실측: gjc runs as
+ * `bun /…/.bun/bin/gjc`, so comm is `bun`. A pid counts only when argv[0]'s
+ * basename is `gjc`, or argv[0] is bun/node and its first argument's basename
+ * is `gjc`/`gjc.js`. Later command-line tokens are never evidence.
+ */
+function hasGjcArgvEvidence(commandLine: string): boolean {
+  const firstSpace = commandLine.search(/\s/);
+  const argv0 = firstSpace < 0 ? commandLine : commandLine.slice(0, firstSpace);
+  const basename = (value: string) => value.slice(value.lastIndexOf('/') + 1);
+
+  if (basename(argv0) === 'gjc' || /^\/.*\/gjc(?=\s|$)/.test(commandLine)) {
+    return true;
+  }
+
+  let runtime = basename(argv0);
+  let firstArgument = firstSpace < 0 ? '' : commandLine.slice(firstSpace).trimStart();
+  if (runtime !== 'bun' && runtime !== 'node') {
+    // `ps args` flattens paths with spaces. Keep the runtime at argv[0] by
+    // accepting only a command line that starts with its absolute path.
+    const spacedRuntime = /^(\/.*\/(bun|node))\s+(.+)$/.exec(commandLine);
+    if (!spacedRuntime) {
+      return false;
+    }
+    runtime = spacedRuntime[2];
+    firstArgument = spacedRuntime[3];
+  }
+
+  if ((runtime !== 'bun' && runtime !== 'node') || firstArgument.startsWith('-')) {
+    return false;
+  }
+
+  const firstToken = firstArgument.split(/\s+/, 1)[0];
+  if (basename(firstToken) === 'gjc' || basename(firstToken) === 'gjc.js') {
+    return true;
+  }
+
+  // macOS `ps args` removes argv boundaries from space-containing path names.
+  // This remains anchored immediately after the bun/node executable.
+  return firstArgument.startsWith('/') && /^\/.*\/gjc(?:\.js)?(?=\s|$)/.test(firstArgument);
+}
+
+/** Pids with gjc argv evidence from `ps -eo pid=,args=` (TWO-column) output. */
+export function parseGjcPidsFromPsArgs(output: string): Set<number> {
+  const pids = new Set<number>();
+  for (const raw of output.split(/\r?\n/)) {
+    const match = /^\s*(\d+)\s+(.+)$/.exec(raw);
+    if (match && hasGjcArgvEvidence(match[2].trim())) {
+      pids.add(Number.parseInt(match[1], 10));
+    }
+  }
+  return pids;
+}
+
+/**
+ * Same evidence over already-parsed process records (pid + full command line).
+ * Use this with the shared `ps -eo pid=,ppid=,args=` snapshot — feeding that
+ * THREE-column raw output into `parseGjcPidsFromPsArgs` silently treats the
+ * ppid as argv[0] and finds nothing (실사고: 감지 전멸 회귀).
+ */
+export function gjcPidsFromProcessRecords(
+  records: ReadonlyArray<{ pid: number; args: string }>,
+): Set<number> {
+  const pids = new Set<number>();
+  for (const record of records) {
+    if (hasGjcArgvEvidence(record.args.trim())) {
+      pids.add(record.pid);
+    }
+  }
+  return pids;
+}
+
 /**
  * Pure classification: tmux panes + a ps snapshot → external CLI sessions.
  *
@@ -79,6 +162,8 @@ export function parsePsTree(output: string): Array<{ pid: number; ppid: number;
 export function classifyExternalSessions(args: {
   panes: Array<{ name: string; pid: number; command: string }>;
   procs: Array<{ pid: number; ppid: number; comm: string }>;
+  /** Pids proven gjc by argv (script installs whose comm is the runtime). */
+  gjcPids?: ReadonlySet<number>;
 }): ExternalCliSession[] {
   const children = new Map<number, number[]>();
   for (const proc of args.procs) {
@@ -89,6 +174,13 @@ export function classifyExternalSessions(args: {
       children.set(proc.ppid, [proc.pid]);
     }
   }
+
+  /**
+   * gjc evidence beyond comm: script installs run under their runtime (macOS
+   * 실측: comm은 `bun`), so pids proven gjc by ARGV (parseGjcPidsFromPsArgs)
+   * inject a synthetic 'gjc' comm — the exclusion contract stays comm-based.
+   */
+  const gjcPids = args.gjcPids ?? new Set<number>();
   const commByPid = new Map<number, string>();
   for (const proc of args.procs) {
     commByPid.set(proc.pid, proc.comm);
@@ -108,6 +200,9 @@ export function classifyExternalSessions(args: {
       if (comm) {
         comms.add(comm);
       }
+      if (gjcPids.has(pid)) {
+        comms.add('gjc');
+      }
       for (const child of children.get(pid) ?? []) {
         queue.push(child);
       }
@@ -156,7 +251,13 @@ export function classifyExternalSessions(args: {
 
 function runCommand(command: string, cmdArgs: string[], timeoutMs = 4000): Promise<string> {
   return new Promise((resolve, reject) => {
-    const child = spawn(command, cmdArgs, { stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
+    const child = spawn(command, cmdArgs, {
+      stdio: ['ignore', 'pipe', 'ignore'],
+      windowsHide: true,
+      // Service managers ship no locale; non-UTF-8 tmux output sanitizes \t
+      // separators to `_` (see live-sessions.service.ts). Force UTF-8.
+      env: { ...process.env, LANG: process.env.LANG || 'en_US.UTF-8' },
+    });
     let stdout = '';
     let settled = false;
     const timer = setTimeout(() => {
@@ -183,14 +284,17 @@ function runCommand(command: string, cmdArgs: string[], timeoutMs = 4000): Promi
 export async function getExternalCliSessions(): Promise<ExternalCliSession[]> {
   let tmuxOutput: string;
   let psOutput: string;
+  let psArgsOutput: string;
   try {
     tmuxOutput = await runCommand('tmux', ['list-panes', '-a', '-F', `#{session_name}${TMUX_FIELD_SEP}#{pane_pid}${TMUX_FIELD_SEP}#{pane_current_command}`]);
     psOutput = await runCommand('ps', ['-eo', 'pid,ppid,comm']);
+    psArgsOutput = await runCommand('ps', ['-eo', 'pid=,args=']);
   } catch {
     return [];
   }
   return classifyExternalSessions({
     panes: parseExternalPanes(tmuxOutput),
     procs: parsePsTree(psOutput),
+    gjcPids: parseGjcPidsFromPsArgs(psArgsOutput),
   });
 }