@ai-devkit/agent-manager 0.31.0 → 0.33.0

package/dist/providers/codex/CodexAdapter.js

@@ -0,0 +1,162 @@
+import * as fs from "fs";
+import * as path from "path";
+import { captureProcessSnapshot, executableBasename, filterByProcessNames } from "../../utils/process.js";
+import { safeReadFile } from "../../utils/session.js";
+import { AgentRegistry } from "../../utils/AgentRegistry.js";
+import { CodexAgentMapper } from "./CodexAgentMapper.js";
+import { CodexSessionLocator } from "./CodexSessionLocator.js";
+import { CodexSessionMapping } from "./CodexSessionMapping.js";
+import { CodexSessionParser } from "./CodexSessionParser.js";
+export class CodexAdapter {
+    type = "codex";
+    processNames = [
+        "codex"
+    ];
+    registry;
+    parser;
+    mapper;
+    codexSessionsDir;
+    sessionMappingPath;
+    constructor(registry = AgentRegistry.default()){
+        const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+        this.registry = registry;
+        this.parser = new CodexSessionParser();
+        this.mapper = new CodexAgentMapper(this.parser);
+        this.codexSessionsDir = path.join(homeDir, ".codex", "sessions");
+        this.sessionMappingPath = path.join(homeDir, ".codex", "ai-devkit", "sessions.json");
+    }
+    canHandle(processInfo) {
+        const base = executableBasename(processInfo.command);
+        return base === "codex" || base === "codex.exe";
+    }
+    async detectAgents(context) {
+        const processes = await this.getCodexProcesses(context);
+        if (processes.length === 0) return [];
+        const mappingResult = this.mapSessionMappingMatches(processes);
+        const cacheResult = this.mapRegistryCache(mappingResult.fallback);
+        const locatorResult = this.createLocator().matchRunningProcesses(cacheResult.fallback);
+        const directResult = this.mapDirectMatches(locatorResult.direct);
+        const legacyResult = this.mapLegacyMatches(locatorResult.legacyMatches, locatorResult.contentCache);
+        const unmatchedProcesses = this.findUnmatchedProcesses(locatorResult.fallback, [
+            ...directResult.agents,
+            ...legacyResult.agents
+        ]);
+        return [
+            ...mappingResult.agents,
+            ...cacheResult.agents,
+            ...directResult.agents,
+            ...legacyResult.agents,
+            ...directResult.fallback.map((processInfo)=>this.mapper.mapProcessOnlyAgent(processInfo)),
+            ...unmatchedProcesses.map((processInfo)=>this.mapper.mapProcessOnlyAgent(processInfo))
+        ];
+    }
+    getConversation(sessionFilePath, options) {
+        return this.parser.getConversation(sessionFilePath, options);
+    }
+    async listSessions(opts) {
+        const summaries = [];
+        for (const filePath of this.createLocator().discoverHistoricalSessionFiles()){
+            const summary = this.parser.fileToSessionSummary(filePath);
+            if (!summary) continue;
+            if (opts?.cwd !== undefined && summary.cwd !== opts.cwd) continue;
+            summaries.push(summary);
+        }
+        return summaries;
+    }
+    async getCodexProcesses(context) {
+        const snapshot = context?.processes ?? await captureProcessSnapshot(this.processNames);
+        const relevant = filterByProcessNames(snapshot, this.processNames);
+        return relevant.filter((processInfo)=>this.canHandle(processInfo));
+    }
+    createLocator() {
+        return new CodexSessionLocator({
+            sessionsDir: this.codexSessionsDir
+        }, this.parser);
+    }
+    createSessionMapping() {
+        return new CodexSessionMapping({
+            mappingPath: this.sessionMappingPath,
+            sessionsDir: this.codexSessionsDir
+        });
+    }
+    mapSessionMappingMatches(processes) {
+        const { matches, fallback } = this.createSessionMapping().match(processes);
+        const agents = [];
+        for (const match of matches){
+            const session = this.parser.readSession(match.filePath);
+            if (session) {
+                agents.push(this.mapper.mapSessionToAgent(session, match.process, match.filePath));
+            } else {
+                fallback.push(match.process);
+            }
+        }
+        return {
+            agents,
+            fallback
+        };
+    }
+    mapRegistryCache(processes) {
+        const agents = [];
+        const fallback = [];
+        const byPid = new Map(this.registry.list().map((entry)=>[
+                entry.pid,
+                entry
+            ]));
+        for (const processInfo of processes){
+            const entry = byPid.get(processInfo.pid);
+            if (!entry || entry.type !== this.type || !entry.sessionFilePath || !fs.existsSync(entry.sessionFilePath)) {
+                fallback.push(processInfo);
+                continue;
+            }
+            const content = safeReadFile(entry.sessionFilePath);
+            const session = this.parser.readSession(entry.sessionFilePath, content);
+            if (!session) {
+                fallback.push(processInfo);
+                continue;
+            }
+            agents.push(this.mapper.mapSessionToAgent(session, processInfo, entry.sessionFilePath));
+        }
+        return {
+            agents,
+            fallback
+        };
+    }
+    mapDirectMatches(matches) {
+        const agents = [];
+        const fallback = [];
+        for (const match of matches){
+            const session = this.parser.readSession(match.sessionFile.filePath);
+            if (session) {
+                agents.push(this.mapper.mapSessionToAgent(session, match.process, match.sessionFile.filePath));
+            } else {
+                fallback.push(match.process);
+            }
+        }
+        return {
+            agents,
+            fallback
+        };
+    }
+    mapLegacyMatches(matches, contentCache) {
+        const agents = [];
+        const fallback = [];
+        for (const match of matches){
+            const session = this.parser.readSession(match.session.filePath, contentCache.get(match.session.filePath));
+            if (session) {
+                agents.push(this.mapper.mapSessionToAgent(session, match.process, match.session.filePath));
+            } else {
+                fallback.push(match.process);
+            }
+        }
+        return {
+            agents,
+            fallback
+        };
+    }
+    findUnmatchedProcesses(processes, agents) {
+        const matchedPids = new Set(agents.map((agent)=>agent.pid));
+        return processes.filter((processInfo)=>!matchedPids.has(processInfo.pid));
+    }
+}
+
+//# sourceMappingURL=CodexAdapter.js.map

package/dist/providers/codex/CodexAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/providers/codex/CodexAdapter.ts"],"sourcesContent":["import * as fs from \"fs\";\nimport * as path from \"path\";\nimport type {\n  AgentAdapter,\n  AgentInfo,\n  ProcessInfo,\n  ConversationMessage,\n  SessionSummary,\n  ListSessionsOptions,\n  AgentDetectionContext,\n} from \"../../adapters/AgentAdapter.js\";\nimport {\n  captureProcessSnapshot,\n  executableBasename,\n  filterByProcessNames,\n} from \"../../utils/process.js\";\nimport { safeReadFile } from \"../../utils/session.js\";\nimport { AgentRegistry } from \"../../utils/AgentRegistry.js\";\nimport { CodexAgentMapper } from \"./CodexAgentMapper.js\";\nimport { CodexSessionLocator, type CodexDirectMatch } from \"./CodexSessionLocator.js\";\nimport { CodexSessionMapping } from \"./CodexSessionMapping.js\";\nimport { CodexSessionParser } from \"./CodexSessionParser.js\";\n\ninterface MappedAgentResult {\n  agents: AgentInfo[];\n  fallback: ProcessInfo[];\n}\n\nexport class CodexAdapter implements AgentAdapter {\n  readonly type = \"codex\" as const;\n  readonly processNames = [\"codex\"] as const;\n\n  private readonly registry: AgentRegistry;\n  private readonly parser: CodexSessionParser;\n  private readonly mapper: CodexAgentMapper;\n  private readonly codexSessionsDir: string;\n  private readonly sessionMappingPath: string;\n\n  constructor(registry: AgentRegistry = AgentRegistry.default()) {\n    const homeDir = process.env.HOME || process.env.USERPROFILE || \"\";\n    this.registry = registry;\n    this.parser = new CodexSessionParser();\n    this.mapper = new CodexAgentMapper(this.parser);\n    this.codexSessionsDir = path.join(homeDir, \".codex\", \"sessions\");\n    this.sessionMappingPath = path.join(homeDir, \".codex\", \"ai-devkit\", \"sessions.json\");\n  }\n\n  canHandle(processInfo: ProcessInfo): boolean {\n    const base = executableBasename(processInfo.command);\n    return base === \"codex\" || base === \"codex.exe\";\n  }\n\n  async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {\n    const processes = await this.getCodexProcesses(context);\n    if (processes.length === 0) return [];\n\n    const mappingResult = this.mapSessionMappingMatches(processes);\n    const cacheResult = this.mapRegistryCache(mappingResult.fallback);\n    const locatorResult = this.createLocator().matchRunningProcesses(cacheResult.fallback);\n\n    const directResult = this.mapDirectMatches(locatorResult.direct);\n    const legacyResult = this.mapLegacyMatches(\n      locatorResult.legacyMatches,\n      locatorResult.contentCache,\n    );\n    const unmatchedProcesses = this.findUnmatchedProcesses(locatorResult.fallback, [\n      ...directResult.agents,\n      ...legacyResult.agents,\n    ]);\n\n    return [\n      ...mappingResult.agents,\n      ...cacheResult.agents,\n      ...directResult.agents,\n      ...legacyResult.agents,\n      ...directResult.fallback.map((processInfo) => this.mapper.mapProcessOnlyAgent(processInfo)),\n      ...unmatchedProcesses.map((processInfo) => this.mapper.mapProcessOnlyAgent(processInfo)),\n    ];\n  }\n\n  getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {\n    return this.parser.getConversation(sessionFilePath, options);\n  }\n\n  async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {\n    const summaries: SessionSummary[] = [];\n\n    for (const filePath of this.createLocator().discoverHistoricalSessionFiles()) {\n      const summary = this.parser.fileToSessionSummary(filePath);\n      if (!summary) continue;\n      if (opts?.cwd !== undefined && summary.cwd !== opts.cwd) continue;\n      summaries.push(summary);\n    }\n\n    return summaries;\n  }\n\n  private async getCodexProcesses(context?: AgentDetectionContext): Promise<ProcessInfo[]> {\n    const snapshot = context?.processes ?? (await captureProcessSnapshot(this.processNames));\n    const relevant = filterByProcessNames(snapshot, this.processNames);\n    return relevant.filter((processInfo) => this.canHandle(processInfo));\n  }\n\n  private createLocator(): CodexSessionLocator {\n    return new CodexSessionLocator({ sessionsDir: this.codexSessionsDir }, this.parser);\n  }\n\n  private createSessionMapping(): CodexSessionMapping {\n    return new CodexSessionMapping({\n      mappingPath: this.sessionMappingPath,\n      sessionsDir: this.codexSessionsDir,\n    });\n  }\n\n  private mapSessionMappingMatches(processes: ProcessInfo[]): MappedAgentResult {\n    const { matches, fallback } = this.createSessionMapping().match(processes);\n    const agents: AgentInfo[] = [];\n\n    for (const match of matches) {\n      const session = this.parser.readSession(match.filePath);\n      if (session) {\n        agents.push(this.mapper.mapSessionToAgent(session, match.process, match.filePath));\n      } else {\n        fallback.push(match.process);\n      }\n    }\n\n    return { agents, fallback };\n  }\n\n  private mapRegistryCache(processes: ProcessInfo[]): MappedAgentResult {\n    const agents: AgentInfo[] = [];\n    const fallback: ProcessInfo[] = [];\n    const byPid = new Map(this.registry.list().map((entry) => [entry.pid, entry]));\n\n    for (const processInfo of processes) {\n      const entry = byPid.get(processInfo.pid);\n      if (\n        !entry ||\n        entry.type !== this.type ||\n        !entry.sessionFilePath ||\n        !fs.existsSync(entry.sessionFilePath)\n      ) {\n        fallback.push(processInfo);\n        continue;\n      }\n\n      const content = safeReadFile(entry.sessionFilePath);\n      const session = this.parser.readSession(entry.sessionFilePath, content);\n      if (!session) {\n        fallback.push(processInfo);\n        continue;\n      }\n\n      agents.push(this.mapper.mapSessionToAgent(session, processInfo, entry.sessionFilePath));\n    }\n\n    return { agents, fallback };\n  }\n\n  private mapDirectMatches(matches: CodexDirectMatch[]): MappedAgentResult {\n    const agents: AgentInfo[] = [];\n    const fallback: ProcessInfo[] = [];\n\n    for (const match of matches) {\n      const session = this.parser.readSession(match.sessionFile.filePath);\n      if (session) {\n        agents.push(\n          this.mapper.mapSessionToAgent(session, match.process, match.sessionFile.filePath),\n        );\n      } else {\n        fallback.push(match.process);\n      }\n    }\n\n    return { agents, fallback };\n  }\n\n  private mapLegacyMatches(\n    matches: Array<{ process: ProcessInfo; session: { filePath: string } }>,\n    contentCache: Map<string, string>,\n  ): MappedAgentResult {\n    const agents: AgentInfo[] = [];\n    const fallback: ProcessInfo[] = [];\n\n    for (const match of matches) {\n      const session = this.parser.readSession(\n        match.session.filePath,\n        contentCache.get(match.session.filePath),\n      );\n      if (session) {\n        agents.push(this.mapper.mapSessionToAgent(session, match.process, match.session.filePath));\n      } else {\n        fallback.push(match.process);\n      }\n    }\n\n    return { agents, fallback };\n  }\n\n  private findUnmatchedProcesses(processes: ProcessInfo[], agents: AgentInfo[]): ProcessInfo[] {\n    const matchedPids = new Set(agents.map((agent) => agent.pid));\n    return processes.filter((processInfo) => !matchedPids.has(processInfo.pid));\n  }\n}\n"],"names":["fs","path","captureProcessSnapshot","executableBasename","filterByProcessNames","safeReadFile","AgentRegistry","CodexAgentMapper","CodexSessionLocator","CodexSessionMapping","CodexSessionParser","CodexAdapter","type","processNames","registry","parser","mapper","codexSessionsDir","sessionMappingPath","default","homeDir","process","env","HOME","USERPROFILE","join","canHandle","processInfo","base","command","detectAgents","context","processes","getCodexProcesses","length","mappingResult","mapSessionMappingMatches","cacheResult","mapRegistryCache","fallback","locatorResult","createLocator","matchRunningProcesses","directResult","mapDirectMatches","direct","legacyResult","mapLegacyMatches","legacyMatches","contentCache","unmatchedProcesses","findUnmatchedProcesses","agents","map","mapProcessOnlyAgent","getConversation","sessionFilePath","options","listSessions","opts","summaries","filePath","discoverHistoricalSessionFiles","summary","fileToSessionSummary","cwd","undefined","push","snapshot","relevant","filter","sessionsDir","createSessionMapping","mappingPath","matches","match","session","readSession","mapSessionToAgent","byPid","Map","list","entry","pid","get","existsSync","content","sessionFile","matchedPids","Set","agent","has"],"mappings":"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"}

package/dist/providers/codex/CodexAgentMapper.d.ts

@@ -0,0 +1,9 @@
+import type { AgentInfo, ProcessInfo } from "../../adapters/AgentAdapter.js";
+import type { CodexSessionParser, CodexSession } from "./CodexSessionParser.js";
+export declare class CodexAgentMapper {
+    private readonly parser;
+    constructor(parser: CodexSessionParser);
+    mapSessionToAgent(session: CodexSession, processInfo: ProcessInfo, filePath: string): AgentInfo;
+    mapProcessOnlyAgent(processInfo: ProcessInfo): AgentInfo;
+}
+//# sourceMappingURL=CodexAgentMapper.d.ts.map

package/dist/providers/codex/CodexAgentMapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodexAgentMapper.d.ts","sourceRoot":"","sources":["../../../src/providers/codex/CodexAgentMapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAG7E,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEhF,qBAAa,gBAAgB;IACf,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,kBAAkB;IAEvD,iBAAiB,CAAC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS;IAc/F,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,SAAS;CAYzD"}

package/dist/providers/codex/CodexAgentMapper.js

@@ -0,0 +1,35 @@
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { generateAgentName } from "../../utils/matching.js";
+export class CodexAgentMapper {
+    parser;
+    constructor(parser){
+        this.parser = parser;
+    }
+    mapSessionToAgent(session, processInfo, filePath) {
+        return {
+            name: generateAgentName(session.projectPath || processInfo.cwd || "", processInfo.pid),
+            type: "codex",
+            status: this.parser.determineStatus(session),
+            summary: session.summary || "Codex session active",
+            pid: processInfo.pid,
+            projectPath: session.projectPath || processInfo.cwd || "",
+            sessionId: session.sessionId,
+            lastActive: session.lastActive,
+            sessionFilePath: filePath
+        };
+    }
+    mapProcessOnlyAgent(processInfo) {
+        return {
+            name: generateAgentName(processInfo.cwd || "", processInfo.pid),
+            type: "codex",
+            status: AgentStatus.RUNNING,
+            summary: "Codex process running",
+            pid: processInfo.pid,
+            projectPath: processInfo.cwd || "",
+            sessionId: `pid-${processInfo.pid}`,
+            lastActive: new Date()
+        };
+    }
+}
+
+//# sourceMappingURL=CodexAgentMapper.js.map

package/dist/providers/codex/CodexAgentMapper.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/providers/codex/CodexAgentMapper.ts"],"sourcesContent":["import type { AgentInfo, ProcessInfo } from \"../../adapters/AgentAdapter.js\";\nimport { AgentStatus } from \"../../adapters/AgentAdapter.js\";\nimport { generateAgentName } from \"../../utils/matching.js\";\nimport type { CodexSessionParser, CodexSession } from \"./CodexSessionParser.js\";\n\nexport class CodexAgentMapper {\n  constructor(private readonly parser: CodexSessionParser) {}\n\n  mapSessionToAgent(session: CodexSession, processInfo: ProcessInfo, filePath: string): AgentInfo {\n    return {\n      name: generateAgentName(session.projectPath || processInfo.cwd || \"\", processInfo.pid),\n      type: \"codex\",\n      status: this.parser.determineStatus(session),\n      summary: session.summary || \"Codex session active\",\n      pid: processInfo.pid,\n      projectPath: session.projectPath || processInfo.cwd || \"\",\n      sessionId: session.sessionId,\n      lastActive: session.lastActive,\n      sessionFilePath: filePath,\n    };\n  }\n\n  mapProcessOnlyAgent(processInfo: ProcessInfo): AgentInfo {\n    return {\n      name: generateAgentName(processInfo.cwd || \"\", processInfo.pid),\n      type: \"codex\",\n      status: AgentStatus.RUNNING,\n      summary: \"Codex process running\",\n      pid: processInfo.pid,\n      projectPath: processInfo.cwd || \"\",\n      sessionId: `pid-${processInfo.pid}`,\n      lastActive: new Date(),\n    };\n  }\n}\n"],"names":["AgentStatus","generateAgentName","CodexAgentMapper","parser","mapSessionToAgent","session","processInfo","filePath","name","projectPath","cwd","pid","type","status","determineStatus","summary","sessionId","lastActive","sessionFilePath","mapProcessOnlyAgent","RUNNING","Date"],"mappings":"AACA,SAASA,WAAW,QAAQ,iCAAiC;AAC7D,SAASC,iBAAiB,QAAQ,0BAA0B;AAG5D,OAAO,MAAMC;;IACX,YAAY,AAAiBC,MAA0B,CAAE;aAA5BA,SAAAA;IAA6B;IAE1DC,kBAAkBC,OAAqB,EAAEC,WAAwB,EAAEC,QAAgB,EAAa;QAC9F,OAAO;YACLC,MAAMP,kBAAkBI,QAAQI,WAAW,IAAIH,YAAYI,GAAG,IAAI,IAAIJ,YAAYK,GAAG;YACrFC,MAAM;YACNC,QAAQ,IAAI,CAACV,MAAM,CAACW,eAAe,CAACT;YACpCU,SAASV,QAAQU,OAAO,IAAI;YAC5BJ,KAAKL,YAAYK,GAAG;YACpBF,aAAaJ,QAAQI,WAAW,IAAIH,YAAYI,GAAG,IAAI;YACvDM,WAAWX,QAAQW,SAAS;YAC5BC,YAAYZ,QAAQY,UAAU;YAC9BC,iBAAiBX;QACnB;IACF;IAEAY,oBAAoBb,WAAwB,EAAa;QACvD,OAAO;YACLE,MAAMP,kBAAkBK,YAAYI,GAAG,IAAI,IAAIJ,YAAYK,GAAG;YAC9DC,MAAM;YACNC,QAAQb,YAAYoB,OAAO;YAC3BL,SAAS;YACTJ,KAAKL,YAAYK,GAAG;YACpBF,aAAaH,YAAYI,GAAG,IAAI;YAChCM,WAAW,CAAC,IAAI,EAAEV,YAAYK,GAAG,EAAE;YACnCM,YAAY,IAAII;QAClB;IACF;AACF"}

package/dist/providers/codex/CodexSessionLocator.d.ts

@@ -0,0 +1,44 @@
+import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { type MatchResult } from "../../utils/matching.js";
+import { type SessionFile } from "../../utils/session.js";
+import { CodexSessionParser } from "./CodexSessionParser.js";
+export interface CodexDirectMatch {
+    process: ProcessInfo;
+    sessionFile: SessionFile;
+}
+export interface CodexProcessSessionMatches {
+    direct: CodexDirectMatch[];
+    legacyMatches: MatchResult[];
+    fallback: ProcessInfo[];
+    contentCache: Map<string, string>;
+}
+export interface CodexDiscoveredSessions {
+    sessions: SessionFile[];
+    contentCache: Map<string, string>;
+}
+export interface CodexSessionLocatorOptions {
+    sessionsDir?: string;
+}
+export declare class CodexSessionLocator {
+    private readonly parser;
+    private readonly sessionsDir;
+    constructor(options?: CodexSessionLocatorOptions, parser?: CodexSessionParser);
+    matchRunningProcesses(processes: ProcessInfo[]): CodexProcessSessionMatches;
+    tryResumeMatching(processes: ProcessInfo[]): {
+        direct: CodexDirectMatch[];
+        fallback: ProcessInfo[];
+    };
+    discoverLiveSessions(processes: ProcessInfo[]): CodexDiscoveredSessions;
+    discoverSessionFilesInDateDirs(dateDirs: string[]): CodexDiscoveredSessions;
+    discoverHistoricalSessionFiles(): string[];
+    findSessionFileById(sessionId: string): SessionFile | null;
+    collectAllSessionFiles(): string[];
+    private extractResumeSessionId;
+    private getCandidateSessionFiles;
+    private getDateDirs;
+    private getDateDirsAroundDate;
+    private toSessionDayKey;
+    private tryParseUuidV7Date;
+    private collectSessionFilesInDateDirs;
+}
+//# sourceMappingURL=CodexSessionLocator.d.ts.map

package/dist/providers/codex/CodexSessionLocator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodexSessionLocator.d.ts","sourceRoot":"","sources":["../../../src/providers/codex/CodexSessionLocator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAA4B,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACrF,OAAO,EAML,KAAK,WAAW,EACjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,kBAAkB,EAAwB,MAAM,yBAAyB,CAAC;AAEnF,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,WAAW,CAAC;IACrB,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,0BAA0B;IACzC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAID,qBAAa,mBAAmB;IAK5B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJzB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;gBAGnC,OAAO,GAAE,0BAA+B,EACvB,MAAM,GAAE,kBAA6C;IAMxE,qBAAqB,CAAC,SAAS,EAAE,WAAW,EAAE,GAAG,0BAA0B;IAW3E,iBAAiB,CAAC,SAAS,EAAE,WAAW,EAAE,GAAG;QAC3C,MAAM,EAAE,gBAAgB,EAAE,CAAC;QAC3B,QAAQ,EAAE,WAAW,EAAE,CAAC;KACzB;IAuBD,oBAAoB,CAAC,SAAS,EAAE,WAAW,EAAE,GAAG,uBAAuB;IAUvE,8BAA8B,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,uBAAuB;IA4B3E,8BAA8B,IAAI,MAAM,EAAE;IAI1C,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAiC1D,sBAAsB,IAAI,MAAM,EAAE;IA0BlC,OAAO,CAAC,sBAAsB;IAK9B,OAAO,CAAC,wBAAwB;IAShC,OAAO,CAAC,WAAW;IA+BnB,OAAO,CAAC,qBAAqB;IAe7B,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,kBAAkB;IAa1B,OAAO,CAAC,6BAA6B;CAYtC"}

package/dist/providers/codex/CodexSessionLocator.js

@@ -0,0 +1,207 @@
+import * as fs from "fs";
+import * as path from "path";
+import { matchProcessesToSessions } from "../../utils/matching.js";
+import { batchGetSessionFileBirthtimes, isDirectory, safeReadFile, safeReaddir, safeStat } from "../../utils/session.js";
+import { CodexSessionParser } from "./CodexSessionParser.js";
+const PROCESS_START_DAY_WINDOW_DAYS = 1;
+export class CodexSessionLocator {
+    parser;
+    sessionsDir;
+    constructor(options = {}, parser = new CodexSessionParser()){
+        this.parser = parser;
+        const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+        this.sessionsDir = options.sessionsDir ?? path.join(homeDir, ".codex", "sessions");
+    }
+    matchRunningProcesses(processes) {
+        const { direct, fallback } = this.tryResumeMatching(processes);
+        const { sessions, contentCache } = this.discoverLiveSessions(fallback);
+        const legacyMatches = fallback.length > 0 && sessions.length > 0 ? matchProcessesToSessions(fallback, sessions) : [];
+        return {
+            direct,
+            legacyMatches,
+            fallback,
+            contentCache
+        };
+    }
+    tryResumeMatching(processes) {
+        const direct = [];
+        const fallback = [];
+        for (const proc of processes){
+            const sessionId = this.extractResumeSessionId(proc.command);
+            if (!sessionId) {
+                fallback.push(proc);
+                continue;
+            }
+            const sessionFile = this.findSessionFileById(sessionId);
+            if (!sessionFile) {
+                fallback.push(proc);
+                continue;
+            }
+            direct.push({
+                process: proc,
+                sessionFile
+            });
+        }
+        return {
+            direct,
+            fallback
+        };
+    }
+    discoverLiveSessions(processes) {
+        const empty = {
+            sessions: [],
+            contentCache: new Map()
+        };
+        if (!fs.existsSync(this.sessionsDir)) return empty;
+        const dateDirs = this.getDateDirs(processes);
+        if (dateDirs.length === 0) return empty;
+        return this.discoverSessionFilesInDateDirs(dateDirs);
+    }
+    discoverSessionFilesInDateDirs(dateDirs) {
+        const files = batchGetSessionFileBirthtimes(dateDirs);
+        const contentCache = new Map();
+        for (const file of files){
+            try {
+                const content = fs.readFileSync(file.filePath, "utf-8");
+                contentCache.set(file.filePath, content);
+                const firstLine = content.split("\n")[0]?.trim();
+                if (firstLine) {
+                    const parsed = JSON.parse(firstLine);
+                    if (parsed.type === "session_meta") {
+                        file.resolvedCwd = parsed.payload?.cwd || "";
+                        const metaTimestampMs = this.parser.parseMetaTimestampMs(parsed.payload?.timestamp);
+                        if (metaTimestampMs !== null) {
+                            file.birthtimeMs = metaTimestampMs;
+                        }
+                    }
+                }
+            } catch  {
+            // Skip unreadable files
+            }
+        }
+        return {
+            sessions: files,
+            contentCache
+        };
+    }
+    discoverHistoricalSessionFiles() {
+        return this.collectAllSessionFiles();
+    }
+    findSessionFileById(sessionId) {
+        for (const filePath of this.getCandidateSessionFiles(sessionId)){
+            if (!path.basename(filePath).includes(sessionId)) continue;
+            const content = safeReadFile(filePath);
+            const firstLine = content?.split("\n")[0]?.trim();
+            if (!firstLine) continue;
+            try {
+                const parsed = JSON.parse(firstLine);
+                if (parsed.type !== "session_meta" || parsed.payload?.id !== sessionId) {
+                    continue;
+                }
+                const stat = safeStat(filePath);
+                if (!stat) continue;
+                const metaTimestampMs = this.parser.parseMetaTimestampMs(parsed.payload?.timestamp);
+                return {
+                    sessionId,
+                    filePath,
+                    projectDir: path.dirname(filePath),
+                    birthtimeMs: metaTimestampMs ?? stat.birthtimeMs,
+                    resolvedCwd: parsed.payload?.cwd || ""
+                };
+            } catch  {
+                continue;
+            }
+        }
+        return null;
+    }
+    collectAllSessionFiles() {
+        const out = [];
+        for (const yearEntry of safeReaddir(this.sessionsDir)){
+            const yearDir = path.join(this.sessionsDir, yearEntry);
+            if (!isDirectory(yearDir)) continue;
+            for (const monthEntry of safeReaddir(yearDir)){
+                const monthDir = path.join(yearDir, monthEntry);
+                if (!isDirectory(monthDir)) continue;
+                for (const dayEntry of safeReaddir(monthDir)){
+                    const dayDir = path.join(monthDir, dayEntry);
+                    if (!isDirectory(dayDir)) continue;
+                    for (const fileEntry of safeReaddir(dayDir)){
+                        if (!fileEntry.endsWith(".jsonl")) continue;
+                        out.push(path.join(dayDir, fileEntry));
+                    }
+                }
+            }
+        }
+        return out;
+    }
+    extractResumeSessionId(command) {
+        const match = command.match(/(?:^|\s)resume\s+([0-9a-f-]{36})(?:\s|$)/i);
+        return match?.[1] ?? null;
+    }
+    getCandidateSessionFiles(sessionId) {
+        const sessionDate = this.tryParseUuidV7Date(sessionId);
+        if (!sessionDate) return this.collectAllSessionFiles();
+        return this.collectSessionFilesInDateDirs(this.getDateDirsAroundDate(sessionDate, PROCESS_START_DAY_WINDOW_DAYS));
+    }
+    getDateDirs(processes) {
+        const dayKeys = new Set();
+        for (const proc of processes){
+            const startTime = proc.startTime || new Date();
+            for(let offset = -PROCESS_START_DAY_WINDOW_DAYS; offset <= PROCESS_START_DAY_WINDOW_DAYS; offset++){
+                const day = new Date(startTime.getTime());
+                day.setDate(day.getDate() + offset);
+                dayKeys.add(this.toSessionDayKey(day));
+            }
+        }
+        const dirs = [];
+        for (const dayKey of dayKeys){
+            const dayDir = path.join(this.sessionsDir, dayKey);
+            try {
+                if (fs.statSync(dayDir).isDirectory()) {
+                    dirs.push(dayDir);
+                }
+            } catch  {
+                continue;
+            }
+        }
+        return dirs;
+    }
+    getDateDirsAroundDate(date, windowDays) {
+        const dirs = [];
+        for(let offset = -windowDays; offset <= windowDays; offset++){
+            const day = new Date(date.getTime());
+            day.setDate(day.getDate() + offset);
+            const dayDir = path.join(this.sessionsDir, this.toSessionDayKey(day));
+            if (isDirectory(dayDir)) {
+                dirs.push(dayDir);
+            }
+        }
+        return dirs;
+    }
+    toSessionDayKey(date) {
+        const yyyy = String(date.getFullYear()).padStart(4, "0");
+        const mm = String(date.getMonth() + 1).padStart(2, "0");
+        const dd = String(date.getDate()).padStart(2, "0");
+        return path.join(yyyy, mm, dd);
+    }
+    tryParseUuidV7Date(sessionId) {
+        const match = sessionId.match(/^([0-9a-f]{8})-([0-9a-f]{4})-7[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+        if (!match) return null;
+        const timestampMs = Number.parseInt(`${match[1]}${match[2]}`, 16);
+        if (!Number.isSafeInteger(timestampMs) || timestampMs <= 0) return null;
+        const date = new Date(timestampMs);
+        return Number.isNaN(date.getTime()) ? null : date;
+    }
+    collectSessionFilesInDateDirs(dateDirs) {
+        const out = [];
+        for (const dayDir of dateDirs){
+            for (const fileEntry of safeReaddir(dayDir)){
+                if (!fileEntry.endsWith(".jsonl")) continue;
+                out.push(path.join(dayDir, fileEntry));
+            }
+        }
+        return out;
+    }
+}
+
+//# sourceMappingURL=CodexSessionLocator.js.map

package/dist/providers/codex/CodexSessionLocator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/providers/codex/CodexSessionLocator.ts"],"sourcesContent":["import * as fs from \"fs\";\nimport * as path from \"path\";\nimport type { ProcessInfo } from \"../../adapters/AgentAdapter.js\";\nimport { matchProcessesToSessions, type MatchResult } from \"../../utils/matching.js\";\nimport {\n  batchGetSessionFileBirthtimes,\n  isDirectory,\n  safeReadFile,\n  safeReaddir,\n  safeStat,\n  type SessionFile,\n} from \"../../utils/session.js\";\nimport { CodexSessionParser, type CodexEventEntry } from \"./CodexSessionParser.js\";\n\nexport interface CodexDirectMatch {\n  process: ProcessInfo;\n  sessionFile: SessionFile;\n}\n\nexport interface CodexProcessSessionMatches {\n  direct: CodexDirectMatch[];\n  legacyMatches: MatchResult[];\n  fallback: ProcessInfo[];\n  contentCache: Map<string, string>;\n}\n\nexport interface CodexDiscoveredSessions {\n  sessions: SessionFile[];\n  contentCache: Map<string, string>;\n}\n\nexport interface CodexSessionLocatorOptions {\n  sessionsDir?: string;\n}\n\nconst PROCESS_START_DAY_WINDOW_DAYS = 1;\n\nexport class CodexSessionLocator {\n  private readonly sessionsDir: string;\n\n  constructor(\n    options: CodexSessionLocatorOptions = {},\n    private readonly parser: CodexSessionParser = new CodexSessionParser(),\n  ) {\n    const homeDir = process.env.HOME || process.env.USERPROFILE || \"\";\n    this.sessionsDir = options.sessionsDir ?? path.join(homeDir, \".codex\", \"sessions\");\n  }\n\n  matchRunningProcesses(processes: ProcessInfo[]): CodexProcessSessionMatches {\n    const { direct, fallback } = this.tryResumeMatching(processes);\n    const { sessions, contentCache } = this.discoverLiveSessions(fallback);\n    const legacyMatches =\n      fallback.length > 0 && sessions.length > 0\n        ? matchProcessesToSessions(fallback, sessions)\n        : [];\n\n    return { direct, legacyMatches, fallback, contentCache };\n  }\n\n  tryResumeMatching(processes: ProcessInfo[]): {\n    direct: CodexDirectMatch[];\n    fallback: ProcessInfo[];\n  } {\n    const direct: CodexDirectMatch[] = [];\n    const fallback: ProcessInfo[] = [];\n\n    for (const proc of processes) {\n      const sessionId = this.extractResumeSessionId(proc.command);\n      if (!sessionId) {\n        fallback.push(proc);\n        continue;\n      }\n\n      const sessionFile = this.findSessionFileById(sessionId);\n      if (!sessionFile) {\n        fallback.push(proc);\n        continue;\n      }\n\n      direct.push({ process: proc, sessionFile });\n    }\n\n    return { direct, fallback };\n  }\n\n  discoverLiveSessions(processes: ProcessInfo[]): CodexDiscoveredSessions {\n    const empty = { sessions: [], contentCache: new Map<string, string>() };\n    if (!fs.existsSync(this.sessionsDir)) return empty;\n\n    const dateDirs = this.getDateDirs(processes);\n    if (dateDirs.length === 0) return empty;\n\n    return this.discoverSessionFilesInDateDirs(dateDirs);\n  }\n\n  discoverSessionFilesInDateDirs(dateDirs: string[]): CodexDiscoveredSessions {\n    const files = batchGetSessionFileBirthtimes(dateDirs);\n    const contentCache = new Map<string, string>();\n\n    for (const file of files) {\n      try {\n        const content = fs.readFileSync(file.filePath, \"utf-8\");\n        contentCache.set(file.filePath, content);\n\n        const firstLine = content.split(\"\\n\")[0]?.trim();\n        if (firstLine) {\n          const parsed = JSON.parse(firstLine) as CodexEventEntry;\n          if (parsed.type === \"session_meta\") {\n            file.resolvedCwd = parsed.payload?.cwd || \"\";\n            const metaTimestampMs = this.parser.parseMetaTimestampMs(parsed.payload?.timestamp);\n            if (metaTimestampMs !== null) {\n              file.birthtimeMs = metaTimestampMs;\n            }\n          }\n        }\n      } catch {\n        // Skip unreadable files\n      }\n    }\n\n    return { sessions: files, contentCache };\n  }\n\n  discoverHistoricalSessionFiles(): string[] {\n    return this.collectAllSessionFiles();\n  }\n\n  findSessionFileById(sessionId: string): SessionFile | null {\n    for (const filePath of this.getCandidateSessionFiles(sessionId)) {\n      if (!path.basename(filePath).includes(sessionId)) continue;\n\n      const content = safeReadFile(filePath);\n      const firstLine = content?.split(\"\\n\")[0]?.trim();\n      if (!firstLine) continue;\n\n      try {\n        const parsed = JSON.parse(firstLine) as CodexEventEntry;\n        if (parsed.type !== \"session_meta\" || parsed.payload?.id !== sessionId) {\n          continue;\n        }\n\n        const stat = safeStat(filePath);\n        if (!stat) continue;\n        const metaTimestampMs = this.parser.parseMetaTimestampMs(parsed.payload?.timestamp);\n\n        return {\n          sessionId,\n          filePath,\n          projectDir: path.dirname(filePath),\n          birthtimeMs: metaTimestampMs ?? stat.birthtimeMs,\n          resolvedCwd: parsed.payload?.cwd || \"\",\n        };\n      } catch {\n        continue;\n      }\n    }\n\n    return null;\n  }\n\n  collectAllSessionFiles(): string[] {\n    const out: string[] = [];\n\n    for (const yearEntry of safeReaddir(this.sessionsDir)) {\n      const yearDir = path.join(this.sessionsDir, yearEntry);\n      if (!isDirectory(yearDir)) continue;\n\n      for (const monthEntry of safeReaddir(yearDir)) {\n        const monthDir = path.join(yearDir, monthEntry);\n        if (!isDirectory(monthDir)) continue;\n\n        for (const dayEntry of safeReaddir(monthDir)) {\n          const dayDir = path.join(monthDir, dayEntry);\n          if (!isDirectory(dayDir)) continue;\n\n          for (const fileEntry of safeReaddir(dayDir)) {\n            if (!fileEntry.endsWith(\".jsonl\")) continue;\n            out.push(path.join(dayDir, fileEntry));\n          }\n        }\n      }\n    }\n\n    return out;\n  }\n\n  private extractResumeSessionId(command: string): string | null {\n    const match = command.match(/(?:^|\\s)resume\\s+([0-9a-f-]{36})(?:\\s|$)/i);\n    return match?.[1] ?? null;\n  }\n\n  private getCandidateSessionFiles(sessionId: string): string[] {\n    const sessionDate = this.tryParseUuidV7Date(sessionId);\n    if (!sessionDate) return this.collectAllSessionFiles();\n\n    return this.collectSessionFilesInDateDirs(\n      this.getDateDirsAroundDate(sessionDate, PROCESS_START_DAY_WINDOW_DAYS),\n    );\n  }\n\n  private getDateDirs(processes: ProcessInfo[]): string[] {\n    const dayKeys = new Set<string>();\n\n    for (const proc of processes) {\n      const startTime = proc.startTime || new Date();\n      for (\n        let offset = -PROCESS_START_DAY_WINDOW_DAYS;\n        offset <= PROCESS_START_DAY_WINDOW_DAYS;\n        offset++\n      ) {\n        const day = new Date(startTime.getTime());\n        day.setDate(day.getDate() + offset);\n        dayKeys.add(this.toSessionDayKey(day));\n      }\n    }\n\n    const dirs: string[] = [];\n    for (const dayKey of dayKeys) {\n      const dayDir = path.join(this.sessionsDir, dayKey);\n      try {\n        if (fs.statSync(dayDir).isDirectory()) {\n          dirs.push(dayDir);\n        }\n      } catch {\n        continue;\n      }\n    }\n\n    return dirs;\n  }\n\n  private getDateDirsAroundDate(date: Date, windowDays: number): string[] {\n    const dirs: string[] = [];\n\n    for (let offset = -windowDays; offset <= windowDays; offset++) {\n      const day = new Date(date.getTime());\n      day.setDate(day.getDate() + offset);\n      const dayDir = path.join(this.sessionsDir, this.toSessionDayKey(day));\n      if (isDirectory(dayDir)) {\n        dirs.push(dayDir);\n      }\n    }\n\n    return dirs;\n  }\n\n  private toSessionDayKey(date: Date): string {\n    const yyyy = String(date.getFullYear()).padStart(4, \"0\");\n    const mm = String(date.getMonth() + 1).padStart(2, \"0\");\n    const dd = String(date.getDate()).padStart(2, \"0\");\n    return path.join(yyyy, mm, dd);\n  }\n\n  private tryParseUuidV7Date(sessionId: string): Date | null {\n    const match = sessionId.match(\n      /^([0-9a-f]{8})-([0-9a-f]{4})-7[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}$/i,\n    );\n    if (!match) return null;\n\n    const timestampMs = Number.parseInt(`${match[1]}${match[2]}`, 16);\n    if (!Number.isSafeInteger(timestampMs) || timestampMs <= 0) return null;\n\n    const date = new Date(timestampMs);\n    return Number.isNaN(date.getTime()) ? null : date;\n  }\n\n  private collectSessionFilesInDateDirs(dateDirs: string[]): string[] {\n    const out: string[] = [];\n\n    for (const dayDir of dateDirs) {\n      for (const fileEntry of safeReaddir(dayDir)) {\n        if (!fileEntry.endsWith(\".jsonl\")) continue;\n        out.push(path.join(dayDir, fileEntry));\n      }\n    }\n\n    return out;\n  }\n}\n"],"names":["fs","path","matchProcessesToSessions","batchGetSessionFileBirthtimes","isDirectory","safeReadFile","safeReaddir","safeStat","CodexSessionParser","PROCESS_START_DAY_WINDOW_DAYS","CodexSessionLocator","sessionsDir","options","parser","homeDir","process","env","HOME","USERPROFILE","join","matchRunningProcesses","processes","direct","fallback","tryResumeMatching","sessions","contentCache","discoverLiveSessions","legacyMatches","length","proc","sessionId","extractResumeSessionId","command","push","sessionFile","findSessionFileById","empty","Map","existsSync","dateDirs","getDateDirs","discoverSessionFilesInDateDirs","files","file","content","readFileSync","filePath","set","firstLine","split","trim","parsed","JSON","parse","type","resolvedCwd","payload","cwd","metaTimestampMs","parseMetaTimestampMs","timestamp","birthtimeMs","discoverHistoricalSessionFiles","collectAllSessionFiles","getCandidateSessionFiles","basename","includes","id","stat","projectDir","dirname","out","yearEntry","yearDir","monthEntry","monthDir","dayEntry","dayDir","fileEntry","endsWith","match","sessionDate","tryParseUuidV7Date","collectSessionFilesInDateDirs","getDateDirsAroundDate","dayKeys","Set","startTime","Date","offset","day","getTime","setDate","getDate","add","toSessionDayKey","dirs","dayKey","statSync","date","windowDays","yyyy","String","getFullYear","padStart","mm","getMonth","dd","timestampMs","Number","parseInt","isSafeInteger","isNaN"],"mappings":"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"}

package/dist/providers/codex/CodexSessionMapping.d.ts

@@ -0,0 +1,23 @@
+import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
+export interface CodexSessionMappingOptions {
+    mappingPath?: string;
+    sessionsDir?: string;
+}
+export interface CodexSessionMappingMatch {
+    process: ProcessInfo;
+    filePath: string;
+}
+export interface CodexSessionMappingResult {
+    matches: CodexSessionMappingMatch[];
+    fallback: ProcessInfo[];
+}
+export declare class CodexSessionMapping {
+    private readonly mappingPath;
+    private readonly sessionsDir;
+    constructor(options?: CodexSessionMappingOptions);
+    match(processes: ProcessInfo[]): CodexSessionMappingResult;
+    private read;
+    private toPid;
+    private isTrustedSessionPath;
+}
+//# sourceMappingURL=CodexSessionMapping.d.ts.map

package/dist/providers/codex/CodexSessionMapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodexSessionMapping.d.ts","sourceRoot":"","sources":["../../../src/providers/codex/CodexSessionMapping.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAGlE,MAAM,WAAW,0BAA0B;IACzC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,WAAW,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,wBAAwB,EAAE,CAAC;IACpC,QAAQ,EAAE,WAAW,EAAE,CAAC;CACzB;AAED,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;gBAEzB,OAAO,GAAE,0BAA+B;IAOpD,KAAK,CAAC,SAAS,EAAE,WAAW,EAAE,GAAG,yBAAyB;IAoB1D,OAAO,CAAC,IAAI;IAwBZ,OAAO,CAAC,KAAK;IAQb,OAAO,CAAC,oBAAoB;CAK7B"}

package/dist/providers/codex/CodexSessionMapping.js

@@ -0,0 +1,68 @@
+import * as fs from "fs";
+import * as path from "path";
+import { safeReadFile } from "../../utils/session.js";
+export class CodexSessionMapping {
+    mappingPath;
+    sessionsDir;
+    constructor(options = {}){
+        const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+        this.mappingPath = options.mappingPath ?? path.join(homeDir, ".codex", "ai-devkit", "sessions.json");
+        this.sessionsDir = options.sessionsDir ?? path.join(homeDir, ".codex", "sessions");
+    }
+    match(processes) {
+        const mapping = this.read();
+        if (mapping.size === 0) return {
+            matches: [],
+            fallback: processes
+        };
+        const matches = [];
+        const fallback = [];
+        for (const processInfo of processes){
+            const filePath = mapping.get(processInfo.pid);
+            if (!filePath || !this.isTrustedSessionPath(filePath) || !fs.existsSync(filePath)) {
+                fallback.push(processInfo);
+                continue;
+            }
+            matches.push({
+                process: processInfo,
+                filePath
+            });
+        }
+        return {
+            matches,
+            fallback
+        };
+    }
+    read() {
+        const content = safeReadFile(this.mappingPath);
+        if (content === undefined) return new Map();
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        } catch  {
+            return new Map();
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return new Map();
+        const map = new Map();
+        for (const [key, value] of Object.entries(parsed)){
+            const pid = this.toPid(key);
+            if (pid !== null && typeof value === "string" && value) {
+                map.set(pid, value);
+            }
+        }
+        return map;
+    }
+    toPid(value) {
+        if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
+        if (typeof value !== "string" || !/^\d+$/.test(value)) return null;
+        const parsed = Number(value);
+        return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
+    }
+    isTrustedSessionPath(filePath) {
+        const resolvedRoot = path.resolve(this.sessionsDir);
+        const resolvedPath = path.resolve(filePath);
+        return resolvedPath === resolvedRoot || resolvedPath.startsWith(`${resolvedRoot}${path.sep}`);
+    }
+}
+
+//# sourceMappingURL=CodexSessionMapping.js.map