@makaio/client-codex 1.0.0-dev-1779051654000

package/dist/schemas/config.d.ts

@@ -0,0 +1,306 @@
+/**
+ * Codex config management schemas.
+ *
+ * Defines request/response schema pairs for the `config.hooks.*` subjects in
+ * the Codex client namespace. Public request and response payloads expose a
+ * flat command-hook view, while `CodexNativeHooksFileSchema` models Codex's
+ * nested on-disk `hooks.json` structure for lossless runtime I/O.
+ *
+ * **Subjects:**
+ * - `config.hooks.list` — list effective hooks for a project directory
+ * - `config.hooks.add` — add a new hook entry to a scope's config
+ * - `config.hooks.remove` — remove hook entries matching a command pattern
+ * @packageDocumentation
+ */
+import { z } from 'zod';
+import { AbsolutePathSchema } from '@makaio/framework/clients';
+export { AbsolutePathSchema };
+/**
+ * Scope enum for Codex hook configuration.
+ *
+ * - `global` — applies to all Codex sessions regardless of project directory
+ * - `project` — scoped to a specific project directory
+ */
+export declare const CodexScopeSchema: z.ZodEnum<{
+    global: "global";
+    project: "project";
+}>;
+/**
+ * Inferred TypeScript type for {@link CodexScopeSchema}.
+ */
+export type CodexScope = z.infer<typeof CodexScopeSchema>;
+/**
+ * A single command hook entry in the public config-management API.
+ *
+ * Codex stores command hooks under `hooks[event][].hooks[]` on disk. The bus
+ * API flattens that native shape into `{ event, matcher?, command, timeout? }`
+ * so callers can manage hooks without duplicating file-format details.
+ */
+export declare const CodexHookEntrySchema: z.ZodObject<{
+    event: z.ZodString;
+    matcher: z.ZodOptional<z.ZodString>;
+    command: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Inferred TypeScript type for {@link CodexHookEntrySchema}.
+ */
+export type CodexHookEntry = z.infer<typeof CodexHookEntrySchema>;
+/**
+ * Native Codex command hook handler as stored inside a matcher group.
+ */
+export declare const CodexNativeCommandHookSchema: z.ZodObject<{
+    type: z.ZodLiteral<"command">;
+    command: z.ZodString;
+    statusMessage: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    timeoutSec: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+/**
+ * Inferred TypeScript type for {@link CodexNativeCommandHookSchema}.
+ */
+export type CodexNativeCommandHook = z.infer<typeof CodexNativeCommandHookSchema>;
+/**
+ * Native Codex matcher group as stored under a hook event key.
+ */
+export declare const CodexNativeHookMatcherGroupSchema: z.ZodObject<{
+    matcher: z.ZodOptional<z.ZodString>;
+    hooks: z.ZodArray<z.ZodUnknown>;
+}, z.core.$loose>;
+/**
+ * Inferred TypeScript type for {@link CodexNativeHookMatcherGroupSchema}.
+ */
+export type CodexNativeHookMatcherGroup = z.infer<typeof CodexNativeHookMatcherGroupSchema>;
+/**
+ * Native Codex `hooks.json` file shape.
+ *
+ * Top-level and nested objects are passthrough so runtime writes preserve
+ * fields introduced by newer Codex versions instead of stripping them.
+ */
+export declare const CodexNativeHooksFileSchema: z.ZodObject<{
+    hooks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        matcher: z.ZodOptional<z.ZodString>;
+        hooks: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>>>>;
+}, z.core.$loose>;
+/**
+ * Inferred TypeScript type for {@link CodexNativeHooksFileSchema}.
+ */
+export type CodexNativeHooksFile = z.infer<typeof CodexNativeHooksFileSchema>;
+/**
+ * Per-scope hook configuration record returned by `config.hooks.list`.
+ *
+ * Describes all hooks registered at a single config scope together with
+ * the path to the backing config file and whether it can be written.
+ */
+export declare const CodexScopeHookRecordSchema: z.ZodObject<{
+    scope: z.ZodEnum<{
+        global: "global";
+        project: "project";
+    }>;
+    path: z.ZodString;
+    writable: z.ZodBoolean;
+    hooks: z.ZodArray<z.ZodObject<{
+        event: z.ZodString;
+        matcher: z.ZodOptional<z.ZodString>;
+        command: z.ZodString;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Inferred TypeScript type for {@link CodexScopeHookRecordSchema}.
+ */
+export type CodexScopeHookRecord = z.infer<typeof CodexScopeHookRecordSchema>;
+/**
+ * Request schema for `config.hooks.list`.
+ *
+ * Returns the effective hook configuration for the given project directory,
+ * optionally filtered to a specific event name.
+ */
+export declare const CodexConfigHooksListRequestSchema: z.ZodObject<{
+    projectDir: z.ZodOptional<z.ZodString>;
+    eventName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Response schema for `config.hooks.list`.
+ *
+ * Returns the merged effective hook list alongside the per-scope breakdown so
+ * consumers can determine which config file contributes each hook.
+ */
+export declare const CodexConfigHooksListResponseSchema: z.ZodObject<{
+    effective: z.ZodArray<z.ZodObject<{
+        event: z.ZodString;
+        matcher: z.ZodOptional<z.ZodString>;
+        command: z.ZodString;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    perScope: z.ZodArray<z.ZodObject<{
+        scope: z.ZodEnum<{
+            global: "global";
+            project: "project";
+        }>;
+        path: z.ZodString;
+        writable: z.ZodBoolean;
+        hooks: z.ZodArray<z.ZodObject<{
+            event: z.ZodString;
+            matcher: z.ZodOptional<z.ZodString>;
+            command: z.ZodString;
+            timeout: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Request schema for `config.hooks.add`.
+ *
+ * Adds a new hook entry to the specified scope's configuration.
+ * The hook entry fields (`event`, `matcher`, `command`, `timeout`) are
+ * composed via {@link CodexHookEntrySchema} so any change to the hook shape
+ * propagates here automatically.
+ */
+export declare const CodexConfigHooksAddRequestSchema: z.ZodObject<{
+    event: z.ZodString;
+    matcher: z.ZodOptional<z.ZodString>;
+    command: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    projectDir: z.ZodOptional<z.ZodString>;
+    scope: z.ZodEnum<{
+        global: "global";
+        project: "project";
+    }>;
+}, z.core.$strip>;
+/**
+ * Response schema for `config.hooks.add`.
+ */
+export declare const CodexConfigHooksAddResponseSchema: z.ZodObject<{
+    added: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Request schema for `config.hooks.remove`.
+ *
+ * Removes hook entries from the specified scope's configuration that match
+ * both the `event` and the command substring filter.
+ */
+export declare const CodexConfigHooksRemoveRequestSchema: z.ZodObject<{
+    projectDir: z.ZodOptional<z.ZodString>;
+    scope: z.ZodEnum<{
+        global: "global";
+        project: "project";
+    }>;
+    event: z.ZodString;
+    match: z.ZodObject<{
+        commandContains: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Response schema for `config.hooks.remove`.
+ */
+export declare const CodexConfigHooksRemoveResponseSchema: z.ZodObject<{
+    removed: z.ZodNumber;
+}, z.core.$strip>;
+/** Inferred type for `config.hooks.list` request. */
+export type CodexConfigHooksListRequest = z.infer<typeof CodexConfigHooksListRequestSchema>;
+/** Inferred type for `config.hooks.list` response. */
+export type CodexConfigHooksListResponse = z.infer<typeof CodexConfigHooksListResponseSchema>;
+/** Inferred type for `config.hooks.add` request. */
+export type CodexConfigHooksAddRequest = z.infer<typeof CodexConfigHooksAddRequestSchema>;
+/** Inferred type for `config.hooks.add` response. */
+export type CodexConfigHooksAddResponse = z.infer<typeof CodexConfigHooksAddResponseSchema>;
+/** Inferred type for `config.hooks.remove` request. */
+export type CodexConfigHooksRemoveRequest = z.infer<typeof CodexConfigHooksRemoveRequestSchema>;
+/** Inferred type for `config.hooks.remove` response. */
+export type CodexConfigHooksRemoveResponse = z.infer<typeof CodexConfigHooksRemoveResponseSchema>;
+/**
+ * Schema record for Codex config management subjects.
+ *
+ * Pass this record as the `additionalSchemas` argument to
+ * {@link createClientNamespace} to register these request/response subjects
+ * in the `client:codex.*` namespace.
+ *
+ * Keys use dotted notation matching the bus subject naming convention:
+ * - `config.hooks.list`
+ * - `config.hooks.add`
+ * - `config.hooks.remove`
+ * @example
+ * ```typescript
+ * import { createClientNamespace } from '@makaio/framework/clients';
+ * import { CodexConfigSchemas } from './schemas/index.js';
+ *
+ * const { subjects } = createClientNamespace('codex', CodexConfigSchemas);
+ * // subjects.config.hooks.list → 'client:codex.config.hooks.list'
+ * ```
+ */
+export declare const CodexConfigSchemas: {
+    /**
+     * List effective hook configuration for a project directory.
+     *
+     * Merges global and project-scoped hooks and returns both the effective list
+     * and the per-scope breakdown.
+     */
+    'config.hooks.list': {
+        request: z.ZodObject<{
+            projectDir: z.ZodOptional<z.ZodString>;
+            eventName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        response: z.ZodObject<{
+            effective: z.ZodArray<z.ZodObject<{
+                event: z.ZodString;
+                matcher: z.ZodOptional<z.ZodString>;
+                command: z.ZodString;
+                timeout: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            perScope: z.ZodArray<z.ZodObject<{
+                scope: z.ZodEnum<{
+                    global: "global";
+                    project: "project";
+                }>;
+                path: z.ZodString;
+                writable: z.ZodBoolean;
+                hooks: z.ZodArray<z.ZodObject<{
+                    event: z.ZodString;
+                    matcher: z.ZodOptional<z.ZodString>;
+                    command: z.ZodString;
+                    timeout: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    /**
+     * Add a new hook entry to a config scope.
+     */
+    'config.hooks.add': {
+        request: z.ZodObject<{
+            event: z.ZodString;
+            matcher: z.ZodOptional<z.ZodString>;
+            command: z.ZodString;
+            timeout: z.ZodOptional<z.ZodNumber>;
+            projectDir: z.ZodOptional<z.ZodString>;
+            scope: z.ZodEnum<{
+                global: "global";
+                project: "project";
+            }>;
+        }, z.core.$strip>;
+        response: z.ZodObject<{
+            added: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    /**
+     * Remove hook entries matching an event and command substring from a scope.
+     */
+    'config.hooks.remove': {
+        request: z.ZodObject<{
+            projectDir: z.ZodOptional<z.ZodString>;
+            scope: z.ZodEnum<{
+                global: "global";
+                project: "project";
+            }>;
+            event: z.ZodString;
+            match: z.ZodObject<{
+                commandContains: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        response: z.ZodObject<{
+            removed: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/schemas/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/schemas/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAE9B;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;EAAgC,CAAC;AAE9D;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB;;;;;iBAoB/B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;;iBAazB,CAAC;AAEjB;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF;;GAEG;AACH,eAAO,MAAM,iCAAiC;;;iBAU9B,CAAC;AAEjB;;GAEG;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B;;;;;iBAIvB,CAAC;AAEjB;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;iBAiBrC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAM9E;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC;;;iBAY5C,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;iBAa7C,CAAC;AAMH;;;;;;;GAOG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;iBAiBzC,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,iCAAiC;;iBAK5C,CAAC;AAMH;;;;;GAKG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;iBA8B5C,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,oCAAoC;;iBAK/C,CAAC;AAMH,qDAAqD;AACrD,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F,sDAAsD;AACtD,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAE9F,oDAAoD;AACpD,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE1F,qDAAqD;AACrD,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F,uDAAuD;AACvD,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAEhG,wDAAwD;AACxD,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAC;AAMlG;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,kBAAkB;IAC7B;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAMH;;OAEG;;;;;;;;;;;;;;;;;IAMH;;OAEG;;;;;;;;;;;;;;;;;CAKmB,CAAC"}

package/dist/schemas/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Codex config management schemas and inferred types.
+ * @packageDocumentation
+ */
+export { AbsolutePathSchema, CodexConfigHooksAddRequestSchema, CodexConfigHooksAddResponseSchema, CodexConfigHooksListRequestSchema, CodexConfigHooksListResponseSchema, CodexConfigHooksRemoveRequestSchema, CodexConfigHooksRemoveResponseSchema, CodexConfigSchemas, CodexHookEntrySchema, CodexNativeCommandHookSchema, CodexNativeHookMatcherGroupSchema, CodexNativeHooksFileSchema, CodexScopeHookRecordSchema, CodexScopeSchema, } from './config.js';
+export type { CodexConfigHooksAddRequest, CodexConfigHooksAddResponse, CodexConfigHooksListRequest, CodexConfigHooksListResponse, CodexConfigHooksRemoveRequest, CodexConfigHooksRemoveResponse, CodexHookEntry, CodexNativeCommandHook, CodexNativeHookMatcherGroup, CodexNativeHooksFile, CodexScope, CodexScopeHookRecord, } from './config.js';
+export { CodexWiringSchemas } from './wiring.js';
+export type { CodexWiringApplyRequest, CodexWiringListRequest, CodexWiringRemoveRequest } from './wiring.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACL,kBAAkB,EAClB,gCAAgC,EAChC,iCAAiC,EACjC,iCAAiC,EACjC,kCAAkC,EAClC,mCAAmC,EACnC,oCAAoC,EACpC,kBAAkB,EAClB,oBAAoB,EACpB,4BAA4B,EAC5B,iCAAiC,EACjC,0BAA0B,EAC1B,0BAA0B,EAC1B,gBAAgB,GACjB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,0BAA0B,EAC1B,2BAA2B,EAC3B,2BAA2B,EAC3B,4BAA4B,EAC5B,6BAA6B,EAC7B,8BAA8B,EAC9B,cAAc,EACd,sBAAsB,EACtB,2BAA2B,EAC3B,oBAAoB,EACpB,UAAU,EACV,oBAAoB,GACrB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,YAAY,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC"}

package/dist/schemas/wiring.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Codex wiring management schemas.
+ *
+ * Defines request/response schema pairs for the `wiring.*` subjects in the
+ * Codex client namespace. These schemas are spread into the Codex
+ * {@link createClientNamespace} call alongside {@link CodexConfigSchemas}.
+ *
+ * **Subjects:**
+ * - `wiring.list`   — list all known wiring entries with installation status
+ * - `wiring.apply`  — install all wiring entries into the target scope
+ * - `wiring.remove` — uninstall all wiring entries from the target scope
+ * @packageDocumentation
+ */
+import { z } from 'zod';
+/**
+ * Schema record for Codex wiring management subjects.
+ *
+ * Pass this record (spread) as part of the `additionalSchemas` argument to
+ * {@link createClientNamespace} to register these request/response subjects
+ * in the `client:codex.*` namespace.
+ *
+ * Keys use dotted notation matching the bus subject naming convention:
+ * - `wiring.list`
+ * - `wiring.apply`
+ * - `wiring.remove`
+ * @example
+ * ```typescript
+ * import { createClientNamespace } from '@makaio/framework/clients';
+ * import { CodexConfigSchemas } from './schemas/config.js';
+ * import { CodexWiringSchemas } from './schemas/wiring.js';
+ *
+ * const { subjects } = createClientNamespace('codex', {
+ *   ...CodexConfigSchemas,
+ *   ...CodexWiringSchemas,
+ * });
+ * // subjects.wiring.list → 'client:codex.wiring.list'
+ * ```
+ */
+export declare const CodexWiringSchemas: {
+    /**
+     * List all known wiring entries for the target scope, indicating which are
+     * currently installed in the Codex native config.
+     *
+     * When `projectDir` is absent, only the `global` scope entries are reported.
+     * Callers that need project-scope entries must supply the absolute path to
+     * the project root.
+     */
+    'wiring.list': {
+        request: z.ZodObject<{
+            projectDir: z.ZodOptional<z.ZodString>;
+            makaioCommand: z.ZodString;
+        }, z.core.$strip>;
+        response: z.ZodObject<{
+            entries: z.ZodArray<z.ZodObject<{
+                group: z.ZodString;
+                name: z.ZodString;
+                installed: z.ZodBoolean;
+                command: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    /**
+     * Install all wiring entries into the specified scope.
+     *
+     * Entries already present are skipped (idempotent). The `makaioCommand`
+     * string is written verbatim as the shell command for hook entries.
+     */
+    'wiring.apply': {
+        request: z.ZodObject<{
+            scope: z.ZodEnum<{
+                global: "global";
+                project: "project";
+            }>;
+            projectDir: z.ZodOptional<z.ZodString>;
+            makaioCommand: z.ZodString;
+        }, z.core.$strip>;
+        response: z.ZodObject<{
+            applied: z.ZodNumber;
+            skipped: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    /**
+     * Uninstall all wiring entries from the specified scope.
+     *
+     * Entries that are not present are silently ignored (idempotent). The
+     * `removed` count in the response reflects only entries that were actually
+     * deleted from the config file.
+     */
+    'wiring.remove': {
+        request: z.ZodObject<{
+            scope: z.ZodEnum<{
+                global: "global";
+                project: "project";
+            }>;
+            projectDir: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        response: z.ZodObject<{
+            removed: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+};
+/** Inferred type for `wiring.list` request. */
+export type CodexWiringListRequest = z.infer<(typeof CodexWiringSchemas)['wiring.list']['request']>;
+/** Inferred type for `wiring.apply` request. */
+export type CodexWiringApplyRequest = z.infer<(typeof CodexWiringSchemas)['wiring.apply']['request']>;
+/** Inferred type for `wiring.remove` request. */
+export type CodexWiringRemoveRequest = z.infer<(typeof CodexWiringSchemas)['wiring.remove']['request']>;
+//# sourceMappingURL=wiring.d.ts.map

package/dist/schemas/wiring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wiring.d.ts","sourceRoot":"","sources":["../../src/schemas/wiring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,kBAAkB;IAC7B;;;;;;;OAOG;;;;;;;;;;;;;;;IAiBH;;;;;OAKG;;;;;;;;;;;;;;;IAwBH;;;;;;OAMG;;;;;;;;;;;;;CAkBmB,CAAC;AAMzB,+CAA+C;AAC/C,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,kBAAkB,CAAC,CAAC,aAAa,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;AAEpG,gDAAgD;AAChD,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,kBAAkB,CAAC,CAAC,cAAc,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;AAEtG,iDAAiD;AACjD,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,kBAAkB,CAAC,CAAC,eAAe,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC"}

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@makaio/framework/contracts").MakaioNodeExtension<import("@makaio/framework/bus").IMakaioBus>[];
+export default _default;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":";AAGA,wBAAyD"}

package/dist/server.mjs

@@ -0,0 +1,8 @@
+import { t as codexPackage } from "./src-DkIyzWF3.mjs";
+import { codexClientRuntimePackage } from "./runtime/package.mjs";
+
+//#region src/server.ts
+var server_default = [codexPackage, codexClientRuntimePackage];
+
+//#endregion
+export { server_default as default };

package/dist/src-DkIyzWF3.mjs

@@ -0,0 +1,19 @@
+import { b as clientDefinition } from "./codex-client-session-service-DD2LkxP1.mjs";
+
+//#region src/package.ts
+/**
+* Package descriptor for the Codex client.
+*
+* Declares the OpenAI Codex CLI binary (`codex`) as a first-party agentic
+* coding assistant client with hook and supervisor-launch support and a
+* default `full-access` approval policy.
+*/
+const codexPackage = {
+	name: "codex",
+	displayName: "Codex",
+	version: "0.1.0",
+	clients: [clientDefinition]
+};
+
+//#endregion
+export { codexPackage as t };

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@makaio/client-codex",
+  "version": "1.0.0-dev-1779051654000",
+  "type": "module",
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./runtime": "./src/runtime/package.ts",
+    "./server": "./src/server.ts"
+  },
+  "scripts": {
+    "build": "bun build.ts"
+  },
+  "peerDependencies": {
+    "@makaio/framework": "^0.1.0"
+  },
+  "dependencies": {
+    "@makaio/bus-core": "workspace:*",
+    "@makaio/clients-core": "workspace:*",
+    "@makaio/contracts": "workspace:*",
+    "@makaio/core": "workspace:*",
+    "@makaio/service-base": "workspace:*",
+    "zod": "^4.1.13"
+  },
+  "devDependencies": {
+    "@makaio/build-tooling": "workspace:*",
+    "tsdown": "^0.22.0",
+    "typescript": "^6.0.3"
+  },
+  "files": [
+    "dist",
+    "descriptor.json",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": "./dist/index.mjs",
+      "./runtime": "./dist/runtime/package.mjs",
+      "./server": "./dist/server.mjs"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/makaio-ai/makaio-framework.git",
+    "directory": "clients/codex"
+  }
+}