github-issue-tower-defence-management 1.110.0 → 1.111.0

package/src/adapter/repositories/LocalProcessLiveSessionProcessSnapshotProvider.ts

@@ -0,0 +1,93 @@
+import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { LiveSessionProcessSnapshotProvider } from '../../domain/usecases/adapter-interfaces/LiveSessionProcessSnapshotProvider';
+import { ProcessEnvironReader } from '../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
+import {
+  LiveSessionPaneProcess,
+  LiveSessionProcessInfo,
+  LiveSessionProcessSnapshot,
+} from '../../domain/entities/LiveSessionProcessSnapshot';
+
+const SESSION_ID_ENV_KEY = 'CLAUDE_CODE_SESSION_ID';
+const CONFIG_DIR_ENV_KEY = 'CLAUDE_CONFIG_DIR';
+
+/**
+ * Builds a live-session process snapshot from the local host: it lists the live
+ * tmux sessions and each session's pane process ids, lists the full process
+ * tree with command lines, and reads each process environment to expose the
+ * Claude Code session id and config directory. The snapshot is consumed by a
+ * pure resolver, so all host access is contained in this adapter.
+ */
+export class LocalProcessLiveSessionProcessSnapshotProvider implements LiveSessionProcessSnapshotProvider {
+  constructor(
+    private readonly localCommandRunner: LocalCommandRunner,
+    private readonly environReader: ProcessEnvironReader,
+  ) {}
+
+  getSnapshot = async (): Promise<LiveSessionProcessSnapshot> => {
+    const sessionNames = await this.listSessionNames();
+    const sessions: LiveSessionPaneProcess[] = [];
+    for (const sessionName of sessionNames) {
+      const panePids = await this.listPanePids(sessionName);
+      sessions.push({ sessionName, panePids });
+    }
+    const processes = await this.listProcesses();
+    return { sessions, processes };
+  };
+
+  private listSessionNames = async (): Promise<string[]> => {
+    const { stdout, exitCode } = await this.localCommandRunner.runCommand(
+      'tmux',
+      ['list-sessions', '-F', '#{session_name}'],
+    );
+    if (exitCode !== 0) {
+      return [];
+    }
+    return stdout
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0);
+  };
+
+  private listPanePids = async (sessionName: string): Promise<number[]> => {
+    const { stdout, exitCode } = await this.localCommandRunner.runCommand(
+      'tmux',
+      ['list-panes', '-t', sessionName, '-F', '#{pane_pid}'],
+    );
+    if (exitCode !== 0) {
+      return [];
+    }
+    return stdout
+      .split('\n')
+      .map((line) => Number(line.trim()))
+      .filter((pid) => Number.isInteger(pid) && pid > 0);
+  };
+
+  private listProcesses = async (): Promise<LiveSessionProcessInfo[]> => {
+    const { stdout, exitCode } = await this.localCommandRunner.runCommand(
+      'ps',
+      ['-eo', 'pid=,ppid=,args='],
+    );
+    if (exitCode !== 0) {
+      return [];
+    }
+    const processes: LiveSessionProcessInfo[] = [];
+    for (const line of stdout.split('\n')) {
+      const match = line.match(/^\s*(\d+)\s+(\d+)\s+(.*)$/);
+      if (match === null) {
+        continue;
+      }
+      const pid = Number(match[1]);
+      const ppid = Number(match[2]);
+      const commandLine = match[3].trim();
+      const environ = this.environReader.readEnviron(pid);
+      processes.push({
+        pid,
+        ppid,
+        commandLine,
+        sessionId: environ?.[SESSION_ID_ENV_KEY] ?? null,
+        configDir: environ?.[CONFIG_DIR_ENV_KEY] ?? null,
+      });
+    }
+    return processes;
+  };
+}

package/src/adapter/repositories/NoUnansweredOwnerCallStatusProvider.test.ts

@@ -3,10 +3,12 @@ import { NoUnansweredOwnerCallStatusProvider } from './NoUnansweredOwnerCallStat
 describe('NoUnansweredOwnerCallStatusProvider', () => {
   it('always reports no session as having an unanswered owner call', async () => {
     const provider = new NoUnansweredOwnerCallStatusProvider();
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      'session-a',
-      'session-b',
-    ]);
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([
+        ['session-a', '/transcripts/a.jsonl'],
+        ['session-b', '/transcripts/b.jsonl'],
+      ]),
+    );
     expect(result.size).toBe(0);
   });
 });

package/src/adapter/repositories/NoUnansweredOwnerCallStatusProvider.ts

@@ -2,7 +2,7 @@ import { OwnerCallStatusProvider } from '../../domain/usecases/adapter-interface
 
 export class NoUnansweredOwnerCallStatusProvider implements OwnerCallStatusProvider {
   listSessionNamesWithUnansweredOwnerCall = (
-    _sessionNames: string[],
+    _transcriptPathBySessionName: Map<string, string>,
   ): Promise<Set<string>> => {
     return Promise.resolve(new Set<string>());
   };

package/src/adapter/repositories/ProcFsProcessEnvironReader.test.ts

@@ -0,0 +1,60 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { ProcFsProcessEnvironReader } from './ProcFsProcessEnvironReader';
+
+describe('ProcFsProcessEnvironReader', () => {
+  let procDirectory: string;
+
+  beforeEach(() => {
+    procDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'proc-environ-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(procDirectory, { force: true, recursive: true });
+  });
+
+  const writeEnviron = (pid: number, entries: string[]): void => {
+    const pidDirectory = path.join(procDirectory, String(pid));
+    fs.mkdirSync(pidDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(pidDirectory, 'environ'),
+      entries.join('\0') + '\0',
+      'utf8',
+    );
+  };
+
+  it('parses NUL-separated KEY=value pairs from procfs', () => {
+    writeEnviron(123, [
+      'PATH=/usr/bin',
+      'CLAUDE_CODE_SESSION_ID=abc-123',
+      'CLAUDE_CONFIG_DIR=/config/workbench',
+    ]);
+    const reader = new ProcFsProcessEnvironReader(procDirectory);
+
+    const result = reader.readEnviron(123);
+
+    expect(result).toEqual({
+      PATH: '/usr/bin',
+      CLAUDE_CODE_SESSION_ID: 'abc-123',
+      CLAUDE_CONFIG_DIR: '/config/workbench',
+    });
+  });
+
+  it('keeps values that themselves contain an equals sign', () => {
+    writeEnviron(124, ['QUERY=a=b=c']);
+    const reader = new ProcFsProcessEnvironReader(procDirectory);
+
+    const result = reader.readEnviron(124);
+
+    expect(result).toEqual({ QUERY: 'a=b=c' });
+  });
+
+  it('returns null when the process environ cannot be read', () => {
+    const reader = new ProcFsProcessEnvironReader(procDirectory);
+
+    const result = reader.readEnviron(999);
+
+    expect(result).toBeNull();
+  });
+});

package/src/adapter/repositories/ProcFsProcessEnvironReader.ts

@@ -0,0 +1,38 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { ProcessEnvironReader } from '../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
+
+/**
+ * Reads a process environment from the Linux procfs (`/proc/<pid>/environ`),
+ * where entries are NUL-separated `KEY=value` pairs. Returns null when the
+ * environment cannot be read (the process has exited or is not accessible).
+ */
+export class ProcFsProcessEnvironReader implements ProcessEnvironReader {
+  constructor(private readonly procDirectory: string = '/proc') {}
+
+  readEnviron = (pid: number): Record<string, string> | null => {
+    let raw: string;
+    try {
+      raw = fs.readFileSync(
+        path.join(this.procDirectory, String(pid), 'environ'),
+        'utf8',
+      );
+    } catch {
+      return null;
+    }
+    const environ: Record<string, string> = {};
+    for (const entry of raw.split('\0')) {
+      if (entry.length === 0) {
+        continue;
+      }
+      const separatorIndex = entry.indexOf('=');
+      if (separatorIndex === -1) {
+        continue;
+      }
+      const key = entry.slice(0, separatorIndex);
+      const value = entry.slice(separatorIndex + 1);
+      environ[key] = value;
+    }
+    return environ;
+  };
+}

package/src/adapter/repositories/TranscriptOwnerCallStatusProvider.test.ts

@@ -16,14 +16,14 @@ describe('TranscriptOwnerCallStatusProvider', () => {
     fs.rmSync(rootDirectory, { force: true, recursive: true });
   });
 
-  const writeTranscript = (sessionName: string, lines: object[]): void => {
-    const fileName = `${sessionName.replace(/\//g, '_')}.jsonl`;
+  const writeTranscript = (fileName: string, lines: object[]): string => {
     const filePath = path.join(rootDirectory, fileName);
     fs.writeFileSync(
       filePath,
       lines.map((line) => JSON.stringify(line)).join('\n'),
       'utf8',
     );
+    return filePath;
   };
 
   const assistantWithMarker = (timestamp: string): object => ({
@@ -63,141 +63,104 @@ describe('TranscriptOwnerCallStatusProvider', () => {
     },
   });
 
+  const sessionName = 'workbench';
+
   it('reports a session as waiting when the last owner call is newer than the last owner reply', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeTranscript(sessionName, [
+    const transcriptPath = writeTranscript('workbench.jsonl', [
       ownerReply('2026-06-27T10:00:00.000Z'),
       assistantWithMarker('2026-06-27T10:05:00.000Z'),
     ]);
-    const provider = new TranscriptOwnerCallStatusProvider(
-      rootDirectory,
-      '<<OWNER_CALL>>',
-    );
+    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      sessionName,
-    ]);
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, transcriptPath]]),
+    );
 
     expect(result.has(sessionName)).toBe(true);
   });
 
   it('does not report a session as waiting when a later owner reply followed the call', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeTranscript(sessionName, [
+    const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantWithMarker('2026-06-27T10:00:00.000Z'),
       ownerReply('2026-06-27T10:05:00.000Z'),
     ]);
-    const provider = new TranscriptOwnerCallStatusProvider(
-      rootDirectory,
-      '<<OWNER_CALL>>',
-    );
+    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      sessionName,
-    ]);
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, transcriptPath]]),
+    );
 
     expect(result.has(sessionName)).toBe(false);
   });
 
   it('compares full datetimes rather than only the time of day', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeTranscript(sessionName, [
+    const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantWithMarker('2026-06-27T23:00:00.000Z'),
       ownerReply('2026-06-28T01:00:00.000Z'),
     ]);
-    const provider = new TranscriptOwnerCallStatusProvider(
-      rootDirectory,
-      '<<OWNER_CALL>>',
-    );
+    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      sessionName,
-    ]);
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, transcriptPath]]),
+    );
 
     expect(result.has(sessionName)).toBe(false);
   });
 
   it('treats tool results as not being owner replies', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeTranscript(sessionName, [
+    const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantWithMarker('2026-06-27T10:00:00.000Z'),
       toolResult('2026-06-27T10:05:00.000Z'),
     ]);
-    const provider = new TranscriptOwnerCallStatusProvider(
-      rootDirectory,
-      '<<OWNER_CALL>>',
-    );
+    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      sessionName,
-    ]);
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, transcriptPath]]),
+    );
 
     expect(result.has(sessionName)).toBe(true);
   });
 
   it('does not report a session that never raised an owner call', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeTranscript(sessionName, [
+    const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantPlain('2026-06-27T10:00:00.000Z'),
       ownerReply('2026-06-27T10:05:00.000Z'),
     ]);
-    const provider = new TranscriptOwnerCallStatusProvider(
-      rootDirectory,
-      '<<OWNER_CALL>>',
-    );
+    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      sessionName,
-    ]);
-
-    expect(result.has(sessionName)).toBe(false);
-  });
-
-  it('returns an empty set when the root directory is null', async () => {
-    const provider = new TranscriptOwnerCallStatusProvider(
-      null,
-      '<<OWNER_CALL>>',
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, transcriptPath]]),
     );
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      'https_//github_com/owner/repo/issues/9',
-    ]);
-
-    expect(result.size).toBe(0);
+    expect(result.has(sessionName)).toBe(false);
   });
 
   it('returns an empty set when the marker is null', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeTranscript(sessionName, [
+    const transcriptPath = writeTranscript('workbench.jsonl', [
       ownerReply('2026-06-27T10:00:00.000Z'),
       assistantWithMarker('2026-06-27T10:05:00.000Z'),
     ]);
-    const provider = new TranscriptOwnerCallStatusProvider(rootDirectory, null);
+    const provider = new TranscriptOwnerCallStatusProvider(null);
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      sessionName,
-    ]);
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, transcriptPath]]),
+    );
 
     expect(result.size).toBe(0);
   });
 
   it('ignores a session whose transcript file is missing', async () => {
-    const provider = new TranscriptOwnerCallStatusProvider(
-      rootDirectory,
-      '<<OWNER_CALL>>',
-    );
+    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      'https_//github_com/owner/repo/issues/9',
-    ]);
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, path.join(rootDirectory, 'missing.jsonl')]]),
+    );
 
     expect(result.size).toBe(0);
   });
 
   it('ignores malformed transcript lines', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    const fileName = `${sessionName.replace(/\//g, '_')}.jsonl`;
-    const filePath = path.join(rootDirectory, fileName);
+    const filePath = path.join(rootDirectory, 'workbench.jsonl');
     fs.writeFileSync(
       filePath,
       [
@@ -206,14 +169,31 @@ describe('TranscriptOwnerCallStatusProvider', () => {
       ].join('\n'),
       'utf8',
     );
-    const provider = new TranscriptOwnerCallStatusProvider(
-      rootDirectory,
-      '<<OWNER_CALL>>',
+    const provider = new TranscriptOwnerCallStatusProvider('<<OWNER_CALL>>');
+
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, filePath]]),
     );
 
-    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
-      sessionName,
+    expect(result.has(sessionName)).toBe(true);
+  });
+
+  it('uses the canonical call-to-user marker string', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      {
+        type: 'assistant',
+        timestamp: '2026-06-27T10:05:00.000Z',
+        message: {
+          role: 'assistant',
+          content: [{ type: 'text', text: 'Please decide <call-to-user>' }],
+        },
+      },
     ]);
+    const provider = new TranscriptOwnerCallStatusProvider('<call-to-user>');
+
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall(
+      new Map([[sessionName, transcriptPath]]),
+    );
 
     expect(result.has(sessionName)).toBe(true);
   });

package/src/adapter/repositories/TranscriptOwnerCallStatusProvider.ts

@@ -1,5 +1,4 @@
 import * as fs from 'fs';
-import * as path from 'path';
 import { OwnerCallStatusProvider } from '../../domain/usecases/adapter-interfaces/OwnerCallStatusProvider';
 
 const isRecord = (value: unknown): value is Record<string, unknown> =>
@@ -51,24 +50,18 @@ const hasOwnerTextReply = (content: unknown): boolean => {
 };
 
 export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvider {
-  constructor(
-    private readonly rootDirectory: string | null,
-    private readonly ownerCallMarker: string | null,
-  ) {}
+  constructor(private readonly ownerCallMarker: string | null) {}
 
   listSessionNamesWithUnansweredOwnerCall = async (
-    sessionNames: string[],
+    transcriptPathBySessionName: Map<string, string>,
   ): Promise<Set<string>> => {
     const waiting = new Set<string>();
-    if (
-      this.rootDirectory === null ||
-      this.ownerCallMarker === null ||
-      this.ownerCallMarker.length === 0
-    ) {
+    if (this.ownerCallMarker === null || this.ownerCallMarker.length === 0) {
       return waiting;
     }
-    for (const sessionName of sessionNames) {
-      if (this.isWaitingForOwnerReply(sessionName, this.ownerCallMarker)) {
+    const marker = this.ownerCallMarker;
+    for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
+      if (this.isWaitingForOwnerReply(transcriptPath, marker)) {
         waiting.add(sessionName);
       }
     }
@@ -76,19 +69,12 @@ export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvide
   };
 
   private isWaitingForOwnerReply = (
-    sessionName: string,
+    transcriptPath: string,
     marker: string,
   ): boolean => {
-    if (this.rootDirectory === null) {
-      return false;
-    }
-    const filePath = path.join(
-      this.rootDirectory,
-      this.toTranscriptFileName(sessionName),
-    );
     let content: string;
     try {
-      content = fs.readFileSync(filePath, 'utf8');
+      content = fs.readFileSync(transcriptPath, 'utf8');
     } catch {
       return false;
     }
@@ -133,7 +119,4 @@ export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvide
       lastOwnerCallEpochMs > lastOwnerReplyEpochMs
     );
   };
-
-  private toTranscriptFileName = (sessionName: string): string =>
-    `${sessionName.replace(/\//g, '_')}.jsonl`;
 }

package/src/domain/entities/InteractiveLiveSession.ts

@@ -0,0 +1,5 @@
+export type InteractiveLiveSession = {
+  sessionName: string;
+  sessionId: string;
+  configDir: string;
+};

package/src/domain/entities/LiveSessionProcessSnapshot.ts

@@ -0,0 +1,17 @@
+export type LiveSessionPaneProcess = {
+  sessionName: string;
+  panePids: number[];
+};
+
+export type LiveSessionProcessInfo = {
+  pid: number;
+  ppid: number;
+  commandLine: string;
+  sessionId: string | null;
+  configDir: string | null;
+};
+
+export type LiveSessionProcessSnapshot = {
+  sessions: LiveSessionPaneProcess[];
+  processes: LiveSessionProcessInfo[];
+};