@nt-ai-lab/deterministic-agent-workflow-codex 0.3.7

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

@@ -0,0 +1,4 @@
+import type { BaseWorkflowState, RehydratableWorkflow } from '@nt-ai-lab/deterministic-agent-workflow-engine';
+import type { CodexWorkflowCliConfig } from '../../../platform/domain/codex-workflow-cli-types';
+/** @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

@@ -0,0 +1,201 @@
+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: () => [] };
+/** @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 engineDeps = {
+        store,
+        getPluginRoot: () => root,
+        getEnvFilePath: () => join(root, '.codex', 'unused.env'),
+        readFile: config.processDeps.readFile,
+        appendToFile: config.processDeps.appendToFile,
+        now,
+        transcriptReader: config.transcriptReader ?? EMPTY_TRANSCRIPT_READER,
+    };
+    const args = config.processDeps.getArgv().slice(2);
+    try {
+        const result = args.length === 0
+            ? handleHookInvocation(config, engineDeps, root, now)
+            : handleWorkflowCommand(config, engineDeps, root, now, args);
+        writeResult(config.processDeps, result);
+    }
+    catch (error) {
+        config.processDeps.writeStderr(`[${now()}] ERROR: ${String(error)}\n`);
+        config.processDeps.exit(1);
+    }
+}
+function handleWorkflowCommand(config, engineDeps, root, now, args) {
+    if (args.length < 2 || args[0] === '' || args[1] === '') {
+        throw new TypeError('Codex workflow commands require <operation> <session-id> [args]');
+    }
+    const [operation, sessionId, ...operationArgs] = args;
+    const workflowDeps = buildWorkflowDeps(config, engineDeps.store, root, now, sessionId);
+    return createWorkflowRunner(config)([operation, ...operationArgs], engineDeps, workflowDeps, { getSessionId: () => sessionId, });
+}
+function buildWorkflowDeps(config, store, root, now, sessionId) {
+    const platform = {
+        getPluginRoot: () => root,
+        now,
+        getSessionId: () => sessionId,
+        store,
+    };
+    return config.buildWorkflowDeps(platform);
+}
+function resolveWorkflowRoot() {
+    return process.cwd();
+}
+function resolveDatabasePath(processDeps) {
+    const configured = processDeps.getEnv('WORKFLOW_EVENTS_DB');
+    if (configured !== undefined && configured !== '')
+        return configured;
+    const home = processDeps.getEnv('HOME');
+    if (home === undefined || home === '')
+        throw new TypeError('Missing required environment variable: HOME');
+    return join(home, '.workflow-events.db');
+}
+function handleHookInvocation(config, engineDeps, root, now) {
+    const raw = config.processDeps.readFile('/dev/stdin');
+    const parsed = codexHookInputSchema.parse(JSON.parse(raw));
+    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 '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) {
+    if (!engine.hasSessionStarted(sessionId)) {
+        const noTranscriptPath = '';
+        const result = engine.startSession(sessionId, transcriptPath ?? noTranscriptPath, getRepositoryName(cwd));
+        if (result.type !== 'success')
+            return toRunnerResult(result);
+    }
+    return {
+        output: formatContextInjection(`Workflow session: ${sessionId}. Use ${config.workflowCommand} transition ${sessionId} <STATE> for transitions, or ${config.workflowCommand} <OPERATION> ${sessionId} <ARGS> for workflow operations.`),
+        exitCode: 0,
+    };
+}
+function checkToolUse(config, engine, raw) {
+    const input = codexPreToolUseInputSchema.parse(JSON.parse(raw));
+    if (!engine.hasSessionStarted(input.session_id))
+        return {
+            output: '',
+            exitCode: 0
+        };
+    const handler = resolvePreToolUseHandler(config);
+    if (handler === undefined)
+        return {
+            output: '',
+            exitCode: 0
+        };
+    if (input.tool_name === 'apply_patch')
+        return checkPatchPaths(handler, engine, input.session_id, input.tool_input);
+    return toHookResult(handler(engine, input.session_id, input.tool_name, input.tool_input));
+}
+function resolvePreToolUseHandler(config) {
+    if (config.bashForbidden === undefined && config.isWriteAllowed === undefined) {
+        if (config.customGates !== undefined) {
+            throw new TypeError('CodexWorkflowCliConfig: customGates requires bashForbidden and isWriteAllowed.');
+        }
+        return undefined;
+    }
+    if (config.bashForbidden === undefined || config.isWriteAllowed === undefined) {
+        throw new TypeError('CodexWorkflowCliConfig: bashForbidden and isWriteAllowed must be provided together.');
+    }
+    return createPreToolUseHandler({
+        bashForbidden: config.bashForbidden,
+        isWriteAllowed: config.isWriteAllowed,
+        customGates: config.customGates,
+    });
+}
+function checkPatchPaths(handler, engine, sessionId, toolInput) {
+    const command = toolInput.command;
+    if (typeof command !== 'string')
+        return deny('Codex apply_patch hook is missing tool_input.command');
+    const paths = extractPatchPaths(command);
+    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 });
+        if (result.type === 'blocked')
+            return toHookResult(result);
+    }
+    return {
+        output: '',
+        exitCode: 0
+    };
+}
+function extractPatchPaths(command) {
+    const paths = new Set();
+    for (const line of command.split('\n')) {
+        const match = /^\*\*\* Update File: (.+)$|^\*\*\* Add File: (.+)$|^\*\*\* Delete File: (.+)$/.exec(line);
+        const path = match?.[1] ?? match?.[2] ?? match?.[3];
+        if (path !== undefined && path !== '')
+            paths.add(path);
+    }
+    return [...paths];
+}
+function registerSubagent(engine, raw) {
+    const input = codexSubagentStartInputSchema.parse(JSON.parse(raw));
+    if (!engine.hasSessionStarted(input.session_id))
+        return {
+            output: '',
+            exitCode: 0
+        };
+    const result = engine.transaction(input.session_id, 'register-agent', (workflow) => workflow.registerAgent(input.agent_type, input.agent_id));
+    return {
+        output: formatContextInjection(result.type === 'success' ? result.output : ''),
+        exitCode: 0,
+    };
+}
+function preventUnsupportedStop(config, engineDeps, sessionId) {
+    const stored = engineDeps.store.readEvents(sessionId);
+    if (!engineDeps.store.hasSessionStarted(sessionId))
+        return {
+            output: '',
+            exitCode: 0
+        };
+    const state = reduceWorkflowStateFromStoredEvents(config.workflowDefinition, stored);
+    if (config.workflowDefinition.getRegistry()[state.currentStateMachineState].allowIdle === true)
+        return {
+            output: '',
+            exitCode: 0
+        };
+    return {
+        output: JSON.stringify({
+            continue: false,
+            stopReason: `Workflow state ${state.currentStateMachineState} does not allow stopping.`
+        }),
+        exitCode: 0,
+    };
+}
+function toHookResult(result) {
+    if (result.type === 'blocked')
+        return deny(result.output);
+    return toRunnerResult(result);
+}
+function toRunnerResult(result) {
+    return {
+        output: result.output,
+        exitCode: result.type === 'success' ? 0 : 1
+    };
+}
+function deny(reason) {
+    return {
+        output: formatDenyDecision(reason),
+        exitCode: 0
+    };
+}
+function writeResult(processDeps, result) {
+    if (result.output !== '')
+        processDeps.writeStdout(result.output);
+    processDeps.exit(result.exitCode);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createCodexWorkflowCli } from './features/codex-code-cli/entrypoint/codex-code-workflow-cli';
+export type { CodexWorkflowCliConfig } from './platform/domain/codex-workflow-cli-types';

package/dist/index.js

@@ -0,0 +1 @@
+export { createCodexWorkflowCli } from './features/codex-code-cli/entrypoint/codex-code-workflow-cli.js';

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

@@ -0,0 +1,10 @@
+import type { BaseWorkflowState, RehydratableWorkflow, TranscriptReader } from '@nt-ai-lab/deterministic-agent-workflow-engine';
+import type { PlatformContext, ProcessDeps, WorkflowRunnerConfig } from '@nt-ai-lab/deterministic-agent-workflow-cli';
+/** @riviere-role value-object */
+export type CodexWorkflowCliConfig<TWorkflow extends RehydratableWorkflow<TState>, TState extends BaseWorkflowState<TStateName>, TDeps, TStateName extends string = string, TOperation extends string = string> = WorkflowRunnerConfig<TWorkflow, TState, TDeps, TStateName, TOperation> & {
+    readonly buildWorkflowDeps: (platform: PlatformContext) => TDeps;
+    readonly processDeps: ProcessDeps;
+    readonly workflowCommand: string;
+    readonly workflowRoot?: string;
+    readonly transcriptReader?: TranscriptReader;
+};

package/dist/platform/domain/codex-workflow-cli-types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+export declare const codexHookInputSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    transcript_path: z.ZodNullable<z.ZodString>;
+    cwd: z.ZodString;
+    hook_event_name: z.ZodEnum<["SessionStart", "PreToolUse", "SubagentStart", "Stop"]>;
+}, "strip", z.ZodTypeAny, {
+    session_id: string;
+    transcript_path: string | null;
+    cwd: string;
+    hook_event_name: "SessionStart" | "PreToolUse" | "SubagentStart" | "Stop";
+}, {
+    session_id: string;
+    transcript_path: string | null;
+    cwd: string;
+    hook_event_name: "SessionStart" | "PreToolUse" | "SubagentStart" | "Stop";
+}>;
+export declare const codexPreToolUseInputSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    transcript_path: z.ZodNullable<z.ZodString>;
+    cwd: z.ZodString;
+} & {
+    hook_event_name: z.ZodLiteral<"PreToolUse">;
+    tool_name: z.ZodString;
+    tool_input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    session_id: string;
+    transcript_path: string | null;
+    cwd: string;
+    hook_event_name: "PreToolUse";
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+}, {
+    session_id: string;
+    transcript_path: string | null;
+    cwd: string;
+    hook_event_name: "PreToolUse";
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+}>;
+export declare const codexSubagentStartInputSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    transcript_path: z.ZodNullable<z.ZodString>;
+    cwd: z.ZodString;
+} & {
+    hook_event_name: z.ZodLiteral<"SubagentStart">;
+    agent_id: z.ZodString;
+    agent_type: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    session_id: string;
+    transcript_path: string | null;
+    cwd: string;
+    hook_event_name: "SubagentStart";
+    agent_id: string;
+    agent_type: string;
+}, {
+    session_id: string;
+    transcript_path: string | null;
+    cwd: string;
+    hook_event_name: "SubagentStart";
+    agent_id: string;
+    agent_type: string;
+}>;
+export type CodexHookInput = z.infer<typeof codexHookInputSchema>;

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

@@ -0,0 +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),
+    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_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),
+});

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@nt-ai-lab/deterministic-agent-workflow-codex",
+  "version": "0.3.7",
+  "private": false,
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NTCoding/deterministic-agent-workflows.git",
+    "directory": "packages/deterministic-agent-workflows-codex"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "zod": "^3.25.76",
+    "@nt-ai-lab/deterministic-agent-workflow-cli": "0.3.7",
+    "@nt-ai-lab/deterministic-agent-workflow-engine": "0.3.6",
+    "@nt-ai-lab/deterministic-agent-workflow-event-store": "0.3.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}