@fml-inc/fml 0.8.0-rc.1 → 0.8.0-rc.2

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "fml",
-  "version": "0.8.0-rc.1",
+  "version": "0.8.0-rc.2",
   "description": "FML agent tools for Claude Code",
   "mcpServers": {
     "fml": {

package/README.md

@@ -10,25 +10,33 @@ not install or run a second Panopticon package.
 
 ## Install
 
-Node.js 22.15 or newer and pnpm are required.
+Node.js 22.15 or newer and npm are required.
+
+On macOS, Linux, and compatible Bash environments, install with:
 
 ```bash
-pnpm add --global @fml-inc/fml
-fml install
-fml login
-fml org
-fml start
+curl -fsSL https://fml.inc/install.sh | bash
 ```
 
-Installing the package does not change agent configuration. Run `fml install`
-explicitly to register the FML Claude Code plugin, install the agent-native FML
-skill, configure the FML MCP server, and register capture-only lifecycle hooks
-for supported agents. Invoke the skill as `/fml review` in Claude, Gemini, or
-Grok, and as `$fml review` in Codex. Review runs inside the agent from the
-packaged skill; it is not an `fml review` CLI command. Start a new agent session
-after installing so it picks up the integration. FML pre-approves only the
-isolated command hooks it installs for Codex; use `/hooks` to review or disable
-them.
+For Windows or manual installation, run:
+
+```bash
+npm install --global @fml-inc/fml
+fml setup
+```
+
+Run `fml update` to upgrade the global package with npm. Stable releases stay
+on npm's `latest` channel; prerelease versions stay on `next`.
+
+Installing the package does not change agent configuration. Run `fml setup`
+to register every supported FML agent integration, sign in when needed, and
+restart the observer. It installs the agent-native FML skill, configures the
+FML MCP server, and registers capture-only lifecycle hooks for supported
+agents. Invoke the skill as `/fml review` in Claude, Gemini, or Grok, and as
+`$fml review` in Codex. Review runs inside the agent from the packaged skill;
+it is not an `fml review` CLI command. Start a new agent session after setup so
+it picks up the integration. FML pre-approves only the isolated command hooks
+it installs for Codex; use `/hooks` to review or disable them.
 
 The Claude plugin is MCP-only. FML installs the workflow through each host's
 native skill directory so it keeps the bare `fml` name without a second,
@@ -84,6 +92,7 @@ fml sync disable         # Stop discovery and upload
 fml sync enable          # Allow discovery and upload again
 fml sync reset           # Clear watermarks and replay every local artifact from byte zero
 fml start                # Start the observer and continuously run enabled raw sync
+fml restart              # Stop and start the observer
 fml stop                 # Stop the observer and disable raw sync
 ```
 
@@ -262,11 +271,13 @@ fml tools call <tool-name> --args '{"key":"value"}'
 ## CLI overview
 
 ```text
+fml setup                Install integrations, sign in if needed, and start FML
 fml install              Register FML agent integrations and the MCP server
 fml uninstall            Remove agent integration; add --purge to remove local state
-fml update               Update @fml-inc/fml with pnpm
+fml update               Update @fml-inc/fml with npm (stable: latest; prerelease: next)
 
 fml start                Start the local observer and continuous raw sync
+fml restart              Stop and start the local observer
 fml stop                 Stop the local observer and disable raw sync
 
 fml login                Sign in to FML

package/dist/{chunk-CK5MEL5J.js → chunk-3KISRT57.js}

@@ -1,7 +1,7 @@
 import {
   resolvePackageRoot,
   runRawSyncOnce
-} from "./chunk-JXSSPQ5B.js";
+} from "./chunk-YSU5CS2V.js";
 
 // src/observer/sync-cycle.ts
 import { fork } from "child_process";

package/dist/{chunk-DEMVOVVY.js → chunk-56TPYMNK.js}

@@ -1,6 +1,6 @@
 import {
   FML_HOOK_INBOX_DIR
-} from "./chunk-7DR5X7XI.js";
+} from "./chunk-A6HAEVJX.js";
 
 // ../../packages/panopticon/src/observer/auth.ts
 import crypto from "crypto";
@@ -154,6 +154,220 @@ var GROK_HOOK_EVENTS = Object.freeze([
   ...hook_events_default.grok
 ]);
 
+// ../../packages/agent-targets/src/hooks/read-command.ts
+import path2 from "path";
+var SHELL_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "bash",
+  "exec_command",
+  "shell"
+]);
+var COMMAND_SEPARATORS = /* @__PURE__ */ new Set([
+  ";",
+  "&",
+  "&&",
+  "|",
+  "||",
+  "<",
+  "<<",
+  ">",
+  ">>",
+  ">&1",
+  ">&2",
+  "1>",
+  "1>>",
+  "1>&1",
+  "1>&2",
+  "2>",
+  "2>>",
+  "2>&1",
+  "2>&2"
+]);
+function tokenizeShellLikeCommand(command) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  let escaping = false;
+  for (let index = 0; index < command.length; index += 1) {
+    const character = command[index];
+    if (escaping) {
+      current += character;
+      escaping = false;
+      continue;
+    }
+    if (character === "\\") {
+      escaping = true;
+      continue;
+    }
+    if (quote) {
+      if (character === quote) quote = null;
+      else current += character;
+      continue;
+    }
+    if (character === "'" || character === '"') {
+      quote = character;
+      continue;
+    }
+    if (current === "" && (character === "1" || character === "2") && command[index + 1] === ">") {
+      if (command[index + 2] === ">") {
+        tokens.push(`${character}>>`);
+        index += 2;
+      } else if (command[index + 2] === "&" && (command[index + 3] === "1" || command[index + 3] === "2")) {
+        tokens.push(`${character}>&${command[index + 3]}`);
+        index += 3;
+      } else {
+        tokens.push(`${character}>`);
+        index += 1;
+      }
+      continue;
+    }
+    if (/[;&|<>]/.test(character)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      const next = command[index + 1];
+      if (character === ">" && next === "&" && (command[index + 2] === "1" || command[index + 2] === "2")) {
+        tokens.push(`>&${command[index + 2]}`);
+        index += 2;
+        continue;
+      }
+      if (character === "&" && next === "&" || character === "|" && next === "|" || character === "<" && next === "<" || character === ">" && next === ">") {
+        tokens.push(`${character}${next}`);
+        index += 1;
+        continue;
+      }
+      tokens.push(character);
+      continue;
+    }
+    if (/\s/.test(character)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += character;
+  }
+  if (quote || escaping) return [];
+  if (current) tokens.push(current);
+  return tokens;
+}
+function splitCommandSegments(tokens) {
+  const segments = [];
+  let current = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (COMMAND_SEPARATORS.has(token)) {
+      if (current.length > 0) {
+        segments.push(current);
+        current = [];
+      }
+      if (token === "<" || token === "<<") index += 1;
+      continue;
+    }
+    current.push(token);
+  }
+  if (current.length > 0) segments.push(current);
+  return segments;
+}
+function stripSimpleOptions(args, flagsWithValues = /* @__PURE__ */ new Set(), patternFlags = /* @__PURE__ */ new Set()) {
+  const remaining = [];
+  let consumedPatternFlag = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === "--") {
+      remaining.push(...args.slice(index + 1));
+      break;
+    }
+    if (argument.startsWith("-") && argument.length > 1) {
+      if (flagsWithValues.has(argument)) {
+        if (patternFlags.has(argument)) consumedPatternFlag = true;
+        if (!argument.includes("=")) index += 1;
+      }
+      continue;
+    }
+    remaining.push(argument);
+  }
+  return { args: remaining, consumedPatternFlag };
+}
+function readCommandFileArgs(args, flagsWithValues, patternFlags = flagsWithValues) {
+  const stripped = stripSimpleOptions(args, flagsWithValues, patternFlags);
+  return stripped.consumedPatternFlag ? stripped.args : stripped.args.slice(1);
+}
+function isPlausibleReadPath(argument) {
+  if (!argument || argument === "-" || argument.startsWith("-")) return false;
+  if (COMMAND_SEPARATORS.has(argument)) return false;
+  if (/[\0*?[{}`$]/.test(argument)) return false;
+  if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(argument)) return false;
+  return path2.posix.isAbsolute(argument) || path2.win32.isAbsolute(argument) || argument.startsWith("~/") || argument.startsWith("./") || argument.startsWith("../") || argument.includes("/") || /\.[A-Za-z0-9][A-Za-z0-9_-]*$/.test(argument) || /^[A-Z][A-Za-z0-9_.-]*$/.test(argument);
+}
+function filePathFromSegment(tokens) {
+  const commandTokens = [...tokens];
+  while (commandTokens[0]?.includes("=") && /^[A-Za-z_][A-Za-z0-9_]*=/.test(commandTokens[0])) {
+    commandTokens.shift();
+  }
+  const commandName = commandTokens.shift()?.split("/").pop();
+  if (!commandName) return null;
+  let args;
+  switch (commandName) {
+    case "bat":
+    case "batcat":
+    case "cat":
+    case "file":
+    case "less":
+    case "more":
+    case "nl":
+    case "stat":
+    case "wc":
+      args = stripSimpleOptions(commandTokens).args;
+      break;
+    case "head":
+    case "tail":
+      args = stripSimpleOptions(commandTokens, /* @__PURE__ */ new Set(["-n", "-c"])).args;
+      break;
+    case "sed":
+      if (commandTokens.some(
+        (argument) => argument.startsWith("-i") || argument === "--in-place" || argument.startsWith("--in-place=")
+      )) {
+        return null;
+      }
+      args = readCommandFileArgs(commandTokens, /* @__PURE__ */ new Set(["-e", "-f"]));
+      break;
+    case "awk":
+      args = readCommandFileArgs(
+        commandTokens,
+        /* @__PURE__ */ new Set(["-f", "-v"]),
+        /* @__PURE__ */ new Set(["-f"])
+      );
+      break;
+    case "grep":
+    case "rg":
+      args = readCommandFileArgs(
+        commandTokens,
+        /* @__PURE__ */ new Set(["-A", "-B", "-C", "-e", "-f", "-g", "-m", "-t"]),
+        /* @__PURE__ */ new Set(["-e", "-f"])
+      );
+      break;
+    default:
+      return null;
+  }
+  return args.find(isPlausibleReadPath) ?? null;
+}
+function extractReadFilePathFromCommand(command) {
+  const tokens = tokenizeShellLikeCommand(command);
+  if (tokens.length === 0) return null;
+  for (let index = 0; index < tokens.length - 1; index += 1) {
+    if (tokens[index] === "<" && isPlausibleReadPath(tokens[index + 1])) {
+      return tokens[index + 1];
+    }
+  }
+  for (const segment of splitCommandSegments(tokens)) {
+    const filePath = filePathFromSegment(segment);
+    if (filePath) return filePath;
+  }
+  return null;
+}
+
 // ../../packages/agent-targets/src/hooks/normalize.ts
 var MAX_EXTRACTED_TEXT_BYTES = 64 * 1024;
 function isRecord(value) {
@@ -309,12 +523,12 @@ function normalizedEvent(target, payload, context) {
     "workingDirectory",
     "workspaceRoot"
   ]) ?? context.cwd;
-  const filePath = firstString(payload, ["file_path", "filePath", "path"]) ?? (toolInput ? firstString(toolInput, ["file_path", "filePath", "path"]) : void 0);
   const command = boundedExtractedText(
     firstText(payload, ["command"]) ?? (toolInput ? firstText(toolInput, ["command", "cmd"]) : void 0),
     "command"
   );
   const toolName = firstString(payload, ["tool_name", "toolName", "name"]);
+  const filePath = firstString(payload, ["file_path", "filePath", "path"]) ?? (toolInput ? firstString(toolInput, ["file_path", "filePath", "path"]) : void 0) ?? (command && toolName && SHELL_TOOL_NAMES.has(toolName.toLowerCase()) ? extractReadFilePathFromCommand(command) ?? void 0 : void 0);
   const userPrompt = boundedExtractedText(
     firstText(payload, ["prompt", "user_prompt", "userPrompt"]) ?? (target === "gemini" ? geminiUserPrompt(payload) : void 0),
     "user_prompt"
@@ -434,7 +648,7 @@ function normalizeObserverHookCapture(request, options = {}) {
 // ../../packages/panopticon/src/observer/database.ts
 import crypto2 from "crypto";
 import fs2 from "fs";
-import path2 from "path";
+import path3 from "path";
 var ObserverHookSpoolEntryTooLargeError = class extends Error {
   constructor(logicalBytes, maxBytes) {
     super(
@@ -789,7 +1003,7 @@ function openObserverDatabase(databaseFile, options = {}) {
   if (!sqlite?.DatabaseSync) {
     throw new Error("FML observer requires the Node.js built-in SQLite module");
   }
-  const databaseDirectory = path2.dirname(databaseFile);
+  const databaseDirectory = path3.dirname(databaseFile);
   fs2.mkdirSync(databaseDirectory, { recursive: true, mode: 448 });
   if (options.restrictDatabaseDirectory !== false) {
     enforceOwnerOnlyMode(databaseDirectory, 448);
@@ -3068,7 +3282,7 @@ function createObserverHttpServer(opts) {
 // src/hooks/inbox.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import fs3 from "fs";
-import path3 from "path";
+import path4 from "path";
 
 // src/hooks/inbox-config.ts
 var BYTE_SUFFIXES = {
@@ -3210,7 +3424,7 @@ function entryFileName(id) {
   return `${id}.json`;
 }
 function entryPath(inboxDir, id) {
-  return path3.join(inboxDir, entryFileName(id));
+  return path4.join(inboxDir, entryFileName(id));
 }
 function enforceOwnerOnlyDirectory(inboxDir) {
   fs3.mkdirSync(inboxDir, { recursive: true, mode: 448 });
@@ -3320,7 +3534,7 @@ function parseCapacityState(value) {
   };
 }
 function capacityStatePath(inboxDir) {
-  return path3.join(inboxDir, CAPACITY_STATE_FILE);
+  return path4.join(inboxDir, CAPACITY_STATE_FILE);
 }
 function readCapacityStateFile(inboxDir) {
   try {
@@ -3348,7 +3562,7 @@ function writeCapacityState(inboxDir, state, capacityLock) {
   enforceOwnerOnlyDirectory(inboxDir);
   capacityLock.assertOwned();
   const destination = capacityStatePath(inboxDir);
-  const temporary = path3.join(
+  const temporary = path4.join(
     inboxDir,
     `${CAPACITY_STATE_FILE}.${process.pid}.${randomUUID2()}.tmp`
   );
@@ -3457,7 +3671,7 @@ function recoverStaleCapacityLock(lockPath, nowMs) {
       return;
     }
     fs3.rmSync(abandoned, { force: true });
-    fsyncDirectory(path3.dirname(lockPath));
+    fsyncDirectory(path4.dirname(lockPath));
   } catch (error) {
     if (!capacityLockRaceError(error)) throw error;
   }
@@ -3468,7 +3682,7 @@ function sleepSync(milliseconds) {
 }
 function acquireCapacityLock(inboxDir, waitMs = CAPACITY_LOCK_WAIT_MS) {
   enforceOwnerOnlyDirectory(inboxDir);
-  const lockPath = path3.join(inboxDir, CAPACITY_LOCK_FILE);
+  const lockPath = path4.join(inboxDir, CAPACITY_LOCK_FILE);
   const deadlineMs = Date.now() + Math.max(0, waitMs);
   while (true) {
     let descriptor;
@@ -3541,19 +3755,19 @@ function capacityMutationEvidence(inboxDir, pending, includeTemporary) {
   const prefix = `.${id}.`;
   const candidates = [];
   if (includeTemporary && pending.temporaryFileName) {
-    candidates.push(path3.join(inboxDir, pending.temporaryFileName));
+    candidates.push(path4.join(inboxDir, pending.temporaryFileName));
   } else if (includeTemporary) {
     try {
       for (const name of fs3.readdirSync(inboxDir)) {
         if (name.startsWith(prefix) && name.endsWith(".tmp")) {
-          candidates.push(path3.join(inboxDir, name));
+          candidates.push(path4.join(inboxDir, name));
         }
       }
     } catch (error) {
       return error.code === "ENOENT" ? { kind: "missing" } : { kind: "unavailable" };
     }
   }
-  candidates.push(path3.join(inboxDir, fileName));
+  candidates.push(path4.join(inboxDir, fileName));
   let presentBytes;
   for (const candidate of candidates) {
     try {
@@ -3665,7 +3879,7 @@ function removeCapacityTrackedEntry(filePath, inboxDir, expectedBytes, missingIs
     }
     if (bytes === void 0) return false;
     const pendingRemoval = {
-      fileName: path3.basename(filePath),
+      fileName: path4.basename(filePath),
       bytes,
       startedAtMs: Date.now()
     };
@@ -3746,7 +3960,7 @@ function readRetirementState(inboxDir) {
   try {
     return parseRetirementState(
       JSON.parse(
-        fs3.readFileSync(path3.join(inboxDir, RETIREMENT_STATE_FILE), "utf8")
+        fs3.readFileSync(path4.join(inboxDir, RETIREMENT_STATE_FILE), "utf8")
       )
     ) ?? defaultRetirementState();
   } catch {
@@ -3755,8 +3969,8 @@ function readRetirementState(inboxDir) {
 }
 function writeRetirementState(inboxDir, state) {
   enforceOwnerOnlyDirectory(inboxDir);
-  const destination = path3.join(inboxDir, RETIREMENT_STATE_FILE);
-  const temporary = path3.join(
+  const destination = path4.join(inboxDir, RETIREMENT_STATE_FILE);
+  const temporary = path4.join(
     inboxDir,
     `${RETIREMENT_STATE_FILE}.${process.pid}.${randomUUID2()}.tmp`
   );
@@ -3783,7 +3997,7 @@ function completePendingRetirement(inboxDir, state) {
   const pending = state.pending;
   if (!pending) return state;
   if (!removeCapacityTrackedEntry(
-    path3.join(inboxDir, pending.fileName),
+    path4.join(inboxDir, pending.fileName),
     inboxDir,
     pending.bytes,
     true
@@ -3819,7 +4033,7 @@ function retireEntry(filePath, reason, inboxDir) {
   const pending = {
     ...current,
     pending: {
-      fileName: path3.basename(filePath),
+      fileName: path4.basename(filePath),
       bytes,
       reason,
       retiredAtMs: Date.now()
@@ -3870,7 +4084,7 @@ function persistHookInboxEntry(entry, inboxDir = FML_HOOK_INBOX_DIR, limits = ho
     throw new Error("FML hook inbox admission is busy");
   }
   const destination = entryPath(inboxDir, entry.id);
-  const temporary = path3.join(
+  const temporary = path4.join(
     inboxDir,
     `.${entry.id}.${process.pid}.${randomUUID2()}.tmp`
   );
@@ -3900,8 +4114,8 @@ function persistHookInboxEntry(entry, inboxDir = FML_HOOK_INBOX_DIR, limits = ho
   }
   try {
     const pendingPersist = {
-      fileName: path3.basename(destination),
-      temporaryFileName: path3.basename(temporary),
+      fileName: path4.basename(destination),
+      temporaryFileName: path4.basename(temporary),
       bytes: serializedBytes,
       startedAtMs: Date.now()
     };
@@ -4059,7 +4273,7 @@ async function scanDrainEntryNames(inboxDir, maximumEntries, skipThrough, exclud
       const abandonedLockMatch = ABANDONED_CAPACITY_LOCK_PATTERN.exec(name);
       if (INBOX_STATE_TEMP_PATTERN.test(name) || abandonedLockMatch !== null) {
         try {
-          const orphanPath = path3.join(inboxDir, name);
+          const orphanPath = path4.join(inboxDir, name);
           const stat = await fs3.promises.lstat(orphanPath);
           const abandonedAtMs = abandonedLockMatch ? Number(abandonedLockMatch[1]) : void 0;
           const isStale = abandonedLockMatch ? validTimestamp(abandonedAtMs) && abandonedAtMs <= cutoffMs : stat.mtimeMs <= cutoffMs;
@@ -4082,8 +4296,8 @@ async function scanDrainEntryNames(inboxDir, maximumEntries, skipThrough, exclud
       const id = match?.[1];
       if (!id) continue;
       const destination = entryPath(inboxDir, id);
-      const destinationName = path3.basename(destination);
-      const temporary = path3.join(inboxDir, name);
+      const destinationName = path4.basename(destination);
+      const temporary = path4.join(inboxDir, name);
       try {
         const stat = await fs3.promises.lstat(temporary);
         if (!stat.isFile()) continue;
@@ -4136,7 +4350,7 @@ async function scanDrainEntryNames(inboxDir, maximumEntries, skipThrough, exclud
   return { names, failed, resetCursor, blockCursorAdvance };
 }
 function drainCursor(inboxDir) {
-  const key = path3.resolve(inboxDir);
+  const key = path4.resolve(inboxDir);
   const existing = HOOK_INBOX_DRAIN_CURSORS.get(key);
   if (existing) {
     HOOK_INBOX_DRAIN_CURSORS.delete(key);
@@ -4173,7 +4387,7 @@ async function pendingInboxSizeAsync(inboxDir) {
     for (let dirent = await directory.read(); dirent !== null; dirent = await directory.read()) {
       if (!isPendingEntryName(dirent.name)) continue;
       try {
-        const stat = await fs3.promises.lstat(path3.join(inboxDir, dirent.name));
+        const stat = await fs3.promises.lstat(path4.join(inboxDir, dirent.name));
         if (stat.isFile()) {
           pendingEntries += 1;
           pendingBytes += stat.size;
@@ -4197,7 +4411,7 @@ function pendingInboxSize(inboxDir, includeTemporary = false) {
         continue;
       }
       try {
-        const stat = fs3.lstatSync(path3.join(inboxDir, dirent.name));
+        const stat = fs3.lstatSync(path4.join(inboxDir, dirent.name));
         if (stat.isFile()) {
           pendingEntries += 1;
           pendingBytes += stat.size;
@@ -4352,7 +4566,7 @@ async function drainHookInbox(capture, inboxDir = FML_HOOK_INBOX_DIR) {
     safeThrough = name;
   };
   for (const name of names) {
-    const filePath = path3.join(inboxDir, name);
+    const filePath = path4.join(inboxDir, name);
     const readResult = readEntryResult(filePath);
     if (readResult.kind === "missing") {
       markResolved(name, false);
@@ -4422,6 +4636,7 @@ export {
   CODEX_HOOK_EVENTS,
   GEMINI_HOOK_EVENTS,
   GROK_HOOK_EVENTS,
+  SHELL_TOOL_NAMES,
   parseHookCaptureRequest,
   normalizeObserverHookCapture,
   ObserverHookSpoolEntryTooLargeError,

package/dist/{chunk-T5YVLSUC.js → chunk-7V7G7NVF.js}

@@ -99,6 +99,9 @@ function resolveRepositorySlugFromCwd(cwd, timeoutMs = GIT_TIMEOUT_MS) {
   const remote = git(cwd, ["remote", "get-url", "origin"], timeoutMs);
   return remote ? repositorySlug(remote) : null;
 }
+function resolveRepositoryRootFromCwd(cwd, timeoutMs = GIT_TIMEOUT_MS) {
+  return git(cwd, ["rev-parse", "--show-toplevel"], timeoutMs);
+}
 async function resolveRepoFromCwdAsync(cwd, signal) {
   if (signal?.aborted) {
     throw signal.reason ?? new Error("Repository lookup aborted");
@@ -134,5 +137,6 @@ async function resolveRepoFromCwdAsync(cwd, signal) {
 export {
   resolveRepoFromCwd,
   resolveRepositorySlugFromCwd,
+  resolveRepositoryRootFromCwd,
   resolveRepoFromCwdAsync
 };