@fabricorg/cli 0.3.3 → 0.3.4

package/dist/fabric.js

@@ -57,7 +57,7 @@ import { Command as Command20 } from "commander";
 // package.json
 var package_default = {
   name: "@fabricorg/cli",
-  version: "0.3.3",
+  version: "0.3.4",
   description: "CLI for the Fabric AI platform",
   keywords: [
     "fabric",
@@ -1371,7 +1371,10 @@ var DRIVE_LETTER = /^[A-Za-z]:/;
 var RESERVED_DEVICE_NAME = /^(?:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)/i;
 var FORBIDDEN_NAME_CHARACTER = /[<>:"|?*]/;
 var RESERVED_ROOTS = [".git", ".fabric"];
-var RESERVED_EXACT_PATHS = [".claude/settings.local.json"];
+var RESERVED_EXACT_PATHS = [
+  ".claude/settings.local.json",
+  ".codex/hooks.json"
+];
 function hasControlCharacter(input) {
   for (let index = 0; index < input.length; index++) {
     const code = input.charCodeAt(index);
@@ -1492,6 +1495,7 @@ function describeRejection(rejection) {
 
 // src/lib/instructions/safe-write.ts
 import { createHash, randomBytes } from "crypto";
+import { constants } from "fs";
 import {
   lstat,
   mkdir,
@@ -1587,24 +1591,79 @@ function assertWritableTarget(root, relativePath) {
     return check;
   });
 }
-function readFileSafely(root, relativePath) {
-  return __async(this, null, function* () {
+function readFileSafely(_0, _1) {
+  return __async(this, arguments, function* (root, relativePath, options = {}) {
     const check = yield assertWritableTarget(root, relativePath);
     if (!check.ok) {
       throw new Error(`Refusing to sync: ${describeRejection(check)}.`);
     }
-    const stats = yield lstatOrNull(check.path);
-    if (stats === null) {
-      return null;
-    }
+    let handle;
     try {
-      return { bytes: yield readFile(check.path), mode: stats.mode };
+      handle = yield open(
+        check.path,
+        constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+      );
     } catch (error) {
       if (error.code === "ENOENT") {
         return null;
       }
       throw error;
     }
+    try {
+      const opened = yield handle.stat();
+      if (!opened.isFile()) {
+        throw new Error(
+          `Refusing to sync: ${relativePath} is not a regular file.`
+        );
+      }
+      const afterOpen = yield assertWritableTarget(root, relativePath);
+      if (!afterOpen.ok) {
+        throw new Error(
+          `Refusing to sync: ${describeRejection(afterOpen)}.`
+        );
+      }
+      const current = yield lstatOrNull(afterOpen.path);
+      if (current === null || !current.isFile() || current.dev !== opened.dev || current.ino !== opened.ino) {
+        throw new Error(
+          `Refusing to sync: ${relativePath} changed while it was being opened.`
+        );
+      }
+      if (options.maxBytes === void 0) {
+        return { bytes: yield handle.readFile(), mode: opened.mode };
+      }
+      if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0) {
+        throw new Error(
+          "A safe file-read limit must be a non-negative integer."
+        );
+      }
+      if (opened.size > options.maxBytes) {
+        throw new Error(
+          `${relativePath} is too large to read safely (maximum ${options.maxBytes} bytes).`
+        );
+      }
+      const buffer = Buffer.allocUnsafe(options.maxBytes + 1);
+      let total = 0;
+      while (total <= options.maxBytes) {
+        const { bytesRead } = yield handle.read(
+          buffer,
+          total,
+          options.maxBytes + 1 - total,
+          total
+        );
+        if (bytesRead === 0) {
+          break;
+        }
+        total += bytesRead;
+      }
+      if (total > options.maxBytes) {
+        throw new Error(
+          `${relativePath} is too large to read safely (maximum ${options.maxBytes} bytes).`
+        );
+      }
+      return { bytes: buffer.subarray(0, total), mode: opened.mode };
+    } finally {
+      yield handle.close();
+    }
   });
 }
 function resolveExistingRoot(destination) {
@@ -2022,14 +2081,16 @@ function extractBundle(archive, wanted) {
 }
 
 // src/lib/instructions/hook.ts
-import { readFile as readFile2 } from "fs/promises";
 import path2 from "path";
 var CLAUDE_SETTINGS_RELATIVE_PATH = path2.join(
   ".claude",
   "settings.local.json"
 );
+var CODEX_HOOKS_RELATIVE_PATH = path2.join(".codex", "hooks.json");
 var CLAUDE_SETTINGS_POSIX_PATH = ".claude/settings.local.json";
+var CODEX_HOOKS_POSIX_PATH = ".codex/hooks.json";
 var HOOK_TIMEOUT_SECONDS = 15;
+var MAX_HOOK_CONFIG_BYTES = 1024 * 1024;
 var HOOK_SUBCOMMANDS = /* @__PURE__ */ new Set(["check", "sync"]);
 function buildHookCommand(projectId, apply, org) {
   const verb = apply ? "sync" : "check";
@@ -2047,17 +2108,25 @@ function assertKeyStaysOutside(destination, configPath) {
 }
 function mergeSessionStartHook(input) {
   return __async(this, null, function* () {
-    const settingsPath = path2.join(input.root, CLAUDE_SETTINGS_RELATIVE_PATH);
-    let existingRaw = null;
+    var _a2;
+    const hookTarget = hookTargetFor((_a2 = input.tool) != null ? _a2 : "claude-code");
+    const settingsPath = path2.join(input.root, hookTarget.relativePath);
+    let existingRaw;
     try {
-      existingRaw = yield readFile2(settingsPath, "utf8");
+      const existing = yield readFileSafely(
+        input.root,
+        hookTarget.posixPath,
+        { maxBytes: MAX_HOOK_CONFIG_BYTES }
+      );
+      existingRaw = existing === null ? null : new TextDecoder().decode(existing.bytes);
     } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `${settingsPath} could not be read safely: ${message}. It was left untouched.`
+      );
     }
     let settings = {};
-    if (existingRaw !== null && existingRaw.trim().length > 0) {
+    if (existingRaw !== null) {
       let parsed;
       try {
         parsed = JSON.parse(existingRaw);
@@ -2124,7 +2193,7 @@ function mergeSessionStartHook(input) {
     });
     yield writeFileSafely({
       root: input.root,
-      relativePath: CLAUDE_SETTINGS_POSIX_PATH,
+      relativePath: hookTarget.posixPath,
       bytes: new TextEncoder().encode(
         `${JSON.stringify(next, null, 2).replace(/\r\n/g, "\n")}
 `
@@ -2138,6 +2207,15 @@ function mergeSessionStartHook(input) {
     };
   });
 }
+function hookTargetFor(tool) {
+  return tool === "codex" ? {
+    relativePath: CODEX_HOOKS_RELATIVE_PATH,
+    posixPath: CODEX_HOOKS_POSIX_PATH
+  } : {
+    relativePath: CLAUDE_SETTINGS_RELATIVE_PATH,
+    posixPath: CLAUDE_SETTINGS_POSIX_PATH
+  };
+}
 function isFabricHookFor(hook, projectId) {
   if (!isRecord(hook) || typeof hook.command !== "string") {
     return false;
@@ -2179,7 +2257,7 @@ function isRecord(value) {
 }
 
 // src/lib/instructions/lock.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import path3 from "path";
 var LOCK_DIRECTORY = ".fabric";
 var LOCK_FILENAME = "instructions.lock";
@@ -2194,7 +2272,7 @@ function readLock(destination) {
     const file = lockPath(destination);
     let raw;
     try {
-      raw = yield readFile3(file, "utf8");
+      raw = yield readFile2(file, "utf8");
     } catch (error) {
       if (error.code === "ENOENT") {
         return null;
@@ -2785,7 +2863,7 @@ function buildInstructionsCommand() {
     "Write a SessionStart hook for a coding tool and take the first copy"
   ).requiredOption("--project <id>", "Project ID").requiredOption(
     "--tool <tool>",
-    "Coding tool to configure: claude-code"
+    "Coding tool to configure: claude-code|codex"
   ).option("--dest <dir>", "Destination directory (default: cwd)").option("--org <slug>", "Organization context").option(
     "--apply",
     "Let the hook apply changes instead of only reporting them"
@@ -3367,12 +3445,13 @@ function reportPush(outcome) {
 }
 function runInit(opts, format) {
   return __async(this, null, function* () {
-    if (opts.tool !== "claude-code") {
+    if (!isInstructionsHookTool(opts.tool)) {
       throw new CliFailure(
-        `Unsupported tool "${opts.tool}". Only --tool claude-code is supported today; other tools follow.`,
+        `Unsupported tool "${opts.tool}". Use --tool claude-code or --tool codex.`,
         2
       );
     }
+    const tool = opts.tool;
     const root = yield resolveDestinationRoot(destinationOf(opts));
     yield readLockForProject(root, opts.project);
     try {
@@ -3403,7 +3482,8 @@ function runInit(opts, format) {
     const merged = yield mergeSessionStartHook({
       root,
       projectId: opts.project,
-      command
+      command,
+      tool
     });
     if (format === "json") {
       printOutput(
@@ -3427,6 +3507,11 @@ function runInit(opts, format) {
     line(
       opts.apply ? "  It applies changes at session start." : "  It only reports changes; add --apply to init to have it apply them."
     );
+    if (tool === "codex") {
+      line(
+        "  Start Codex in this checkout, then use `/hooks` to review and trust the project hook."
+      );
+    }
     if (outcome === null) {
       line(
         "This project has nothing published yet, so there is nothing to copy \u2014 the hook will pick it up once there is."
@@ -3437,10 +3522,16 @@ function runInit(opts, format) {
     }
     line("");
     line(
-      `${CLAUDE_SETTINGS_RELATIVE_PATH} and ${LOCK_DIRECTORY}/ are local to this machine. If this repository does not ignore them already, add them to your own ignore rules \u2014 this command does not edit .gitignore.`
+      `${hookPathFor(tool)} and ${LOCK_DIRECTORY}/ are local to this machine. If this repository does not ignore them already, add them to your own ignore rules \u2014 this command does not edit .gitignore.`
     );
   });
 }
+function isInstructionsHookTool(tool) {
+  return tool === "claude-code" || tool === "codex";
+}
+function hookPathFor(tool) {
+  return tool === "codex" ? CODEX_HOOKS_RELATIVE_PATH : CLAUDE_SETTINGS_RELATIVE_PATH;
+}
 
 // src/commands/mcp/index.ts
 import { Command as Command12 } from "commander";