@nt-ai-lab/deterministic-agent-workflow-codex 0.4.1 → 0.4.3

package/dist/features/codex-code-cli/entrypoint/codex-code-workflow-cli.d.ts

@@ -1,4 +1,5 @@
 import type { BaseWorkflowState, RehydratableWorkflow } from '@nt-ai-lab/deterministic-agent-workflow-engine';
 import type { CodexWorkflowCliConfig } from '../../../platform/domain/codex-workflow-cli-types';
+export declare function resolveTranscriptPath(sessionId: string, suppliedPath: string | null, now: () => string): string;
 /** @riviere-role cli-entrypoint */
 export declare function createCodexWorkflowCli<TWorkflow extends RehydratableWorkflow<TState>, TState extends BaseWorkflowState<TStateName>, TDeps, TStateName extends string = string, TOperation extends string = string>(config: CodexWorkflowCliConfig<TWorkflow, TState, TDeps, TStateName, TOperation>): void;

package/dist/features/codex-code-cli/entrypoint/codex-code-workflow-cli.js

@@ -1,14 +1,62 @@
+import { accessSync, constants, readdirSync, statSync, } from 'node:fs';
+import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { reduceWorkflowStateFromStoredEvents, WorkflowEngine, } from '@nt-ai-lab/deterministic-agent-workflow-engine';
 import { createPreToolUseHandler, createWorkflowRunner, formatContextInjection, formatDenyDecision, getRepositoryName, } from '@nt-ai-lab/deterministic-agent-workflow-cli';
 import { codexHookInputSchema, codexPreToolUseInputSchema, codexSubagentStartInputSchema, } from '../../../platform/infra/external-clients/codex/codex-hook-schemas.js';
 const EMPTY_TRANSCRIPT_READER = { readMessages: () => [] };
+function requireNonEmptyString(value, name) {
+    if (value === undefined)
+        throw new TypeError(`${name} must be a non-empty string.`);
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        throw new TypeError(`${name} must be a non-empty string.`);
+    return trimmed;
+}
+export function resolveTranscriptPath(sessionId, suppliedPath, now) {
+    const candidate = suppliedPath === null ? '' : suppliedPath.trim();
+    if (candidate.length > 0) {
+        try {
+            accessSync(candidate, constants.R_OK);
+            if (!statSync(candidate).isFile())
+                throw new TypeError('not a file');
+        }
+        catch {
+            throw new TypeError(`Codex transcript is not a readable file: ${candidate}`);
+        }
+        return candidate;
+    }
+    const startedAt = new Date(now());
+    const directory = join(homedir(), '.codex', 'sessions', String(startedAt.getUTCFullYear()), String(startedAt.getUTCMonth() + 1).padStart(2, '0'), String(startedAt.getUTCDate()).padStart(2, '0'));
+    const suffix = `-${sessionId}.jsonl`;
+    const matches = (() => {
+        try {
+            return readdirSync(directory).filter((name) => name.startsWith('rollout-') && name.endsWith(suffix)).map((name) => join(directory, name));
+        }
+        catch {
+            throw new TypeError(`Unable to resolve exactly one readable Codex transcript for session ${sessionId} in ${directory}.`);
+        }
+    })();
+    if (matches.length !== 1) {
+        throw new TypeError(`Unable to resolve exactly one readable Codex transcript for session ${sessionId} in ${directory}.`);
+    }
+    const transcriptPath = requireNonEmptyString(matches[0], 'transcriptPath');
+    try {
+        accessSync(transcriptPath, constants.R_OK);
+        if (!statSync(transcriptPath).isFile())
+            throw new TypeError('not a file');
+    }
+    catch {
+        throw new TypeError(`Unable to resolve exactly one readable Codex transcript for session ${sessionId} in ${directory}.`);
+    }
+    return transcriptPath;
+}
 /** @riviere-role cli-entrypoint */
 export function createCodexWorkflowCli(config) {
     const root = config.workflowRoot ?? resolveWorkflowRoot();
     const databasePath = resolveDatabasePath(config.processDeps);
     const store = config.processDeps.buildStore(databasePath);
-    const now = () => new Date().toISOString();
+    const now = config.now ?? (() => new Date().toISOString());
     const engineDeps = {
         store,
         getPluginRoot: () => root,
@@ -36,7 +84,12 @@ function handleWorkflowCommand(config, engineDeps, root, now, args) {
     }
     const [operation, sessionId, ...operationArgs] = args;
     const workflowDeps = buildWorkflowDeps(config, engineDeps.store, root, now, sessionId);
-    return createWorkflowRunner(config)([operation, ...operationArgs], engineDeps, workflowDeps, { getSessionId: () => sessionId, });
+    return createWorkflowRunner(config)([operation, ...operationArgs], engineDeps, workflowDeps, {
+        getSessionId: () => sessionId,
+        getSessionTranscriptPath: () => resolveTranscriptPath(sessionId, null, now),
+        getSessionRepository: () => getRepositoryName(process.cwd()),
+        getRepositoryRoot: () => process.cwd(),
+    });
 }
 function buildWorkflowDeps(config, store, root, now, sessionId) {
     const platform = {
@@ -65,16 +118,19 @@ function handleHookInvocation(config, engineDeps, root, now) {
     const workflowDeps = buildWorkflowDeps(config, engineDeps.store, root, now, parsed.session_id);
     const engine = new WorkflowEngine(config.workflowDefinition, engineDeps, workflowDeps);
     switch (parsed.hook_event_name) {
-        case 'SessionStart': return startSession(config, engine, parsed.session_id, parsed.transcript_path, parsed.cwd);
+        case 'SessionStart': return startSession(config, engine, parsed.session_id, parsed.transcript_path, parsed.cwd, now);
         case 'PreToolUse': return checkToolUse(config, engine, raw);
         case 'SubagentStart': return registerSubagent(engine, raw);
         case 'Stop': return preventUnsupportedStop(config, engineDeps, parsed.session_id);
     }
 }
-function startSession(config, engine, sessionId, transcriptPath, cwd) {
+function startSession(config, engine, sessionId, transcriptPath, cwd, now) {
     if (!engine.hasSessionStarted(sessionId)) {
-        const noTranscriptPath = '';
-        const result = engine.startSession(sessionId, transcriptPath ?? noTranscriptPath, getRepositoryName(cwd));
+        const transcriptFile = resolveTranscriptPath(sessionId, transcriptPath, now);
+        const repository = getRepositoryName(cwd);
+        if (repository === undefined)
+            throw new TypeError('repository must be a non-empty string.');
+        const result = engine.startSession(sessionId, transcriptFile, repository);
         if (result.type !== 'success')
             return toRunnerResult(result);
     }
@@ -124,7 +180,10 @@ function checkPatchPaths(handler, engine, sessionId, toolInput) {
     if (paths.length === 0)
         return deny('Cannot determine every file edited by Codex apply_patch');
     for (const path of paths) {
-        const result = handler(engine, sessionId, 'Write', { file_path: path });
+        const result = handler(engine, sessionId, 'Write', {
+            file_path: path,
+            command
+        });
         if (result.type === 'blocked')
             return toHookResult(result);
     }

package/dist/platform/domain/codex-workflow-cli-types.d.ts

@@ -7,4 +7,5 @@ export type CodexWorkflowCliConfig<TWorkflow extends RehydratableWorkflow<TState
     readonly workflowCommand: string;
     readonly workflowRoot?: string;
     readonly transcriptReader?: TranscriptReader;
+    readonly now?: () => string;
 };

package/dist/platform/infra/external-clients/codex/codex-hook-schemas.js

@@ -1,17 +1,17 @@
 import { z } from 'zod';
 export const codexHookInputSchema = z.object({
-    session_id: z.string().min(1),
-    transcript_path: z.string().nullable(),
-    cwd: z.string().min(1),
+    session_id: z.string().trim().min(1),
+    transcript_path: z.string().trim().min(1).nullable(),
+    cwd: z.string().trim().min(1),
     hook_event_name: z.enum(['SessionStart', 'PreToolUse', 'SubagentStart', 'Stop']),
 });
 export const codexPreToolUseInputSchema = codexHookInputSchema.extend({
     hook_event_name: z.literal('PreToolUse'),
-    tool_name: z.string().min(1),
+    tool_name: z.string().trim().min(1),
     tool_input: z.record(z.unknown()),
 });
 export const codexSubagentStartInputSchema = codexHookInputSchema.extend({
     hook_event_name: z.literal('SubagentStart'),
-    agent_id: z.string().min(1),
-    agent_type: z.string().min(1),
+    agent_id: z.string().trim().min(1),
+    agent_type: z.string().trim().min(1),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nt-ai-lab/deterministic-agent-workflow-codex",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "private": false,
   "type": "module",
   "repository": {
@@ -17,9 +17,9 @@
   ],
   "dependencies": {
     "zod": "^3.25.76",
-    "@nt-ai-lab/deterministic-agent-workflow-cli": "0.4.0",
-    "@nt-ai-lab/deterministic-agent-workflow-event-store": "0.4.0",
-    "@nt-ai-lab/deterministic-agent-workflow-engine": "0.4.0"
+    "@nt-ai-lab/deterministic-agent-workflow-cli": "0.4.1",
+    "@nt-ai-lab/deterministic-agent-workflow-engine": "0.4.1",
+    "@nt-ai-lab/deterministic-agent-workflow-event-store": "0.4.1"
   },
   "publishConfig": {
     "access": "public"