@fml-inc/fml 0.8.3 → 0.8.4-rc.2

package/.claude-plugin/plugin.json

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

package/README.md

@@ -240,6 +240,25 @@ directories request owner-only permissions, and the SQLite database and
 sidecars are tightened to owner-only modes on platforms that support POSIX
 modes. An existing caller-supplied state directory retains its directory mode.
 
+## Automatic updates
+
+While the observer is running it checks npm for a newer FML release about once
+an hour (with jitter) and, when one exists, applies it by running `fml update`
+in the background: `npm install --global` followed by `fml setup`, which
+restarts the observer onto the new version. Output from that background update
+is written to `update.log` in the FML log directory.
+
+Auto-update is on by default. To disable it, set `FML_AUTO_UPDATE=off` and
+restart the observer so it picks up the change:
+
+```bash
+FML_AUTO_UPDATE=off fml restart
+```
+
+The variable is read from the observer's environment at startup, so exporting
+it in a shell has no effect until the observer is relaunched. Development
+builds and non-release versions never auto-update.
+
 ## MCP tools
 
 The MCP server exposes FML tools for session analytics, cost tracking,

package/dist/{chunk-F4A2POJX.js → chunk-732O7ISN.js}

@@ -1,6 +1,6 @@
 import {
   FML_HOOK_INBOX_DIR
-} from "./chunk-TNJVAET3.js";
+} from "./chunk-ZBSC57CW.js";
 
 // ../../packages/panopticon/src/observer/auth.ts
 import crypto from "crypto";

package/dist/{chunk-UZG65JUB.js → chunk-IIGTUGO5.js}

@@ -1,6 +1,6 @@
 import {
   FML_HOOK_CAPTURE_DISABLED_FILE
-} from "./chunk-TNJVAET3.js";
+} from "./chunk-ZBSC57CW.js";
 
 // src/json-file.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-IZH4MDS4.js → chunk-LWOINL4K.js}

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

package/dist/{chunk-3WDAKM5B.js → chunk-NP7HI4UC.js}

@@ -1,11 +1,12 @@
 import {
   OBSERVER_SERVICE_NAME
-} from "./chunk-F4A2POJX.js";
+} from "./chunk-732O7ISN.js";
 import {
   FML_OBSERVER_LOCK_FILE,
   FML_OBSERVER_PORT,
-  FML_OBSERVER_STATE_FILE
-} from "./chunk-TNJVAET3.js";
+  FML_OBSERVER_STATE_FILE,
+  Sentry
+} from "./chunk-ZBSC57CW.js";
 
 // src/observer/state.ts
 import { randomUUID } from "crypto";
@@ -938,6 +939,270 @@ function removeObserverStateIfOwned(instanceId, opts = {}) {
   }
 }
 
+// src/bin-utils.ts
+import fs2 from "fs";
+import path2 from "path";
+import { execFileSync as execFileSync2, execSync } from "child_process";
+var IS_WIN = process.platform === "win32";
+var DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD";
+function resolveBin(name) {
+  const pathDirs = (process.env.PATH ?? "").split(path2.delimiter).filter(Boolean);
+  const hasExt = path2.extname(name) !== "";
+  const exts = !IS_WIN || hasExt ? [""] : (process.env.PATHEXT ?? DEFAULT_PATHEXT).split(";").filter(Boolean);
+  for (const dir of pathDirs) {
+    for (const ext of exts) {
+      const candidate = path2.join(dir, name + ext);
+      try {
+        if (fs2.statSync(candidate).isFile()) return candidate;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function isWinShim(bin) {
+  return IS_WIN && /\.(cmd|bat)$/i.test(bin);
+}
+function quoteWinArg(arg) {
+  if (arg.length === 0) return '""';
+  if (/^[A-Za-z0-9@\-_+=:/.,]+$/.test(arg)) return arg;
+  const crt = arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, "$1$1");
+  const quoted = `"${crt}"`;
+  return quoted.replace(/([()%!^<>&|"])/g, "^$1");
+}
+function execBinSync(bin, args, opts = {}) {
+  const {
+    timeout = 1e4,
+    encoding = "utf-8",
+    stdio = "pipe",
+    env = process.env
+  } = opts;
+  if (isWinShim(bin)) {
+    const command = [bin, ...args].map(quoteWinArg).join(" ");
+    return execSync(command, { timeout, encoding, stdio, env });
+  }
+  return execFileSync2(bin, args, { timeout, encoding, stdio, env });
+}
+
+// src/commands/update.ts
+var SEMVER_PATTERN = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(?:-((?:0|[1-9][0-9]*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9][0-9]*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+var PACKAGE_NAME = "@fml-inc/fml";
+var UPDATE_TIMEOUT_MS = 12e4;
+var SETUP_TIMEOUT_MS = 3e5;
+function getCurrentVersion() {
+  return true ? "0.8.4-rc.2+f282df41" : "unknown";
+}
+function parseVersion(version) {
+  const match = SEMVER_PATTERN.exec(version);
+  if (!match) return null;
+  return {
+    major: match[1],
+    minor: match[2],
+    patch: match[3],
+    prerelease: match[4]?.split(".") ?? []
+  };
+}
+function compareNumericIdentifiers(left, right) {
+  if (left.length !== right.length) return left.length - right.length;
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+function compareIdentifiers(left, right) {
+  const leftIsNumeric = /^[0-9]+$/u.test(left);
+  const rightIsNumeric = /^[0-9]+$/u.test(right);
+  if (leftIsNumeric && rightIsNumeric) {
+    return compareNumericIdentifiers(left, right);
+  }
+  if (leftIsNumeric) return -1;
+  if (rightIsNumeric) return 1;
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+function compareVersions(left, right) {
+  const leftVersion = parseVersion(left);
+  const rightVersion = parseVersion(right);
+  if (!leftVersion || !rightVersion) {
+    throw new Error("FML update requires valid semantic versions.");
+  }
+  for (const part of ["major", "minor", "patch"]) {
+    const difference = compareNumericIdentifiers(
+      leftVersion[part],
+      rightVersion[part]
+    );
+    if (difference) return difference;
+  }
+  if (!leftVersion.prerelease.length && !rightVersion.prerelease.length) {
+    return 0;
+  }
+  if (!leftVersion.prerelease.length) return 1;
+  if (!rightVersion.prerelease.length) return -1;
+  const length = Math.max(
+    leftVersion.prerelease.length,
+    rightVersion.prerelease.length
+  );
+  for (let index = 0; index < length; index += 1) {
+    const leftIdentifier = leftVersion.prerelease[index];
+    const rightIdentifier = rightVersion.prerelease[index];
+    if (leftIdentifier === void 0) return -1;
+    if (rightIdentifier === void 0) return 1;
+    const difference = compareIdentifiers(leftIdentifier, rightIdentifier);
+    if (difference) return difference;
+  }
+  return 0;
+}
+function isUpdatableVersion(version) {
+  if (version === "dev" || version === "unknown") return false;
+  const parsed = parseVersion(version);
+  if (!parsed) return false;
+  if (parsed.prerelease.includes("dev")) return false;
+  return true;
+}
+function resolveUpdateChannel(version) {
+  const match = SEMVER_PATTERN.exec(version);
+  if (!match) return "latest";
+  const prerelease = match[4];
+  if (!prerelease) return "latest";
+  return prerelease.split(".").every((identifier) => {
+    return !(identifier.length > 1 && identifier.startsWith("0") && /^[0-9]+$/u.test(identifier));
+  }) ? "next" : "latest";
+}
+function resolveUpdateTarget(version) {
+  return `${PACKAGE_NAME}@${resolveUpdateChannel(version)}`;
+}
+function createUpdateEnvironment(env) {
+  const updateEnv = { ...env };
+  for (const key of Object.keys(updateEnv)) {
+    if (key.toLowerCase() === "npm_config_registry") {
+      delete updateEnv[key];
+    }
+  }
+  return updateEnv;
+}
+function parseAvailableVersion(output) {
+  let response;
+  try {
+    response = JSON.parse(output);
+  } catch {
+    throw new Error("Could not read the available FML version from npm.");
+  }
+  const version = Array.isArray(response) && response.length === 1 ? response[0] : response;
+  if (typeof version !== "string" || !parseVersion(version)) {
+    throw new Error("Could not read the available FML version from npm.");
+  }
+  return version;
+}
+async function checkForUpdate(dependencies) {
+  if (!isUpdatableVersion(dependencies.currentVersion)) {
+    throw new Error("FML update requires a released semantic version.");
+  }
+  const channel = resolveUpdateChannel(dependencies.currentVersion);
+  const target = resolveUpdateTarget(dependencies.currentVersion);
+  const updateEnv = createUpdateEnvironment(dependencies.env);
+  let output;
+  if (dependencies.runNpmView) {
+    output = await dependencies.runNpmView(target, updateEnv);
+  } else {
+    const npm = dependencies.resolveBin?.("npm");
+    if (!npm) throw new Error("npm was not found on PATH");
+    if (!dependencies.execBinSync) {
+      throw new Error("FML update check requires an npm view runner.");
+    }
+    output = dependencies.execBinSync(
+      npm,
+      ["view", target, "version", "--json"],
+      {
+        timeout: UPDATE_TIMEOUT_MS,
+        env: updateEnv
+      }
+    );
+  }
+  const latest = parseAvailableVersion(output);
+  return {
+    current: dependencies.currentVersion,
+    latest,
+    channel,
+    newer: compareVersions(latest, dependencies.currentVersion) > 0
+  };
+}
+function formatUpdateError(err) {
+  if (!(err instanceof Error)) return String(err);
+  const stderr = err.stderr;
+  if (typeof stderr === "string") return stderr;
+  if (Buffer.isBuffer(stderr)) return stderr.toString();
+  return err.message;
+}
+async function handleUpdate(overrides = {}) {
+  const dependencies = {
+    currentVersion: getCurrentVersion(),
+    env: process.env,
+    resolveBin,
+    execBinSync,
+    captureException: Sentry.captureException,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+    nonInteractive: false,
+    ...overrides
+  };
+  dependencies.log(`Current version: ${dependencies.currentVersion}`);
+  if (!isUpdatableVersion(dependencies.currentVersion)) {
+    dependencies.log("This is a development build; `fml update` is disabled.");
+    return;
+  }
+  try {
+    const npm = dependencies.resolveBin("npm");
+    if (!npm) throw new Error("npm was not found on PATH");
+    const check = await checkForUpdate({
+      ...dependencies,
+      resolveBin: () => npm
+    });
+    if (!check.newer) {
+      dependencies.log(
+        `FML is already up to date (${dependencies.currentVersion}).`
+      );
+      return;
+    }
+    const updateEnv = createUpdateEnvironment(dependencies.env);
+    const availableVersion = check.latest;
+    const channel = check.channel;
+    dependencies.log(
+      `Updating FML from ${dependencies.currentVersion} to ${availableVersion} on the ${channel} channel...
+`
+    );
+    dependencies.execBinSync(
+      npm,
+      ["install", "--global", `${PACKAGE_NAME}@${availableVersion}`],
+      { timeout: UPDATE_TIMEOUT_MS, env: updateEnv }
+    );
+    dependencies.log(
+      `
+FML updated from ${dependencies.currentVersion} to ${availableVersion}. Refreshing setup...`
+    );
+    try {
+      const fml = dependencies.resolveBin("fml");
+      if (!fml) throw new Error("Updated FML was not found on PATH");
+      dependencies.execBinSync(
+        fml,
+        dependencies.nonInteractive ? ["setup", "--non-interactive"] : ["setup"],
+        { timeout: SETUP_TIMEOUT_MS, stdio: "inherit" }
+      );
+      dependencies.log("FML setup complete.");
+    } catch (err) {
+      dependencies.captureException(err);
+      dependencies.error(
+        "FML updated, but setup failed:",
+        formatUpdateError(err)
+      );
+      dependencies.error("Run `fml setup` to finish refreshing FML.");
+      dependencies.exit(1);
+    }
+  } catch (err) {
+    dependencies.captureException(err);
+    dependencies.error("Update failed:", formatUpdateError(err));
+    dependencies.exit(1);
+  }
+}
+
 export {
   OBSERVER_HEARTBEAT_STALE_MS,
   isPidAlive,
@@ -949,5 +1214,12 @@ export {
   getProcessIdentity,
   claimObserverState,
   updateObserverState,
-  removeObserverStateIfOwned
+  removeObserverStateIfOwned,
+  resolveBin,
+  isWinShim,
+  quoteWinArg,
+  execBinSync,
+  isUpdatableVersion,
+  checkForUpdate,
+  handleUpdate
 };

package/dist/{chunk-26RJC76L.js → chunk-P4HOUZXC.js}

@@ -7,7 +7,7 @@ import {
   getSelectedOrg,
   getSiteUrlForConvexUrl,
   getValidToken
-} from "./chunk-TNJVAET3.js";
+} from "./chunk-ZBSC57CW.js";
 
 // src/fml-client.ts
 var LOGIN_EXPIRED_MESSAGE = "Authentication expired. Run `fml login` to sign in again, then restart Claude Code.";
@@ -79,7 +79,7 @@ function createFmlClient(token, options = {}) {
         const repo = resolveRepoFromCwd(process.cwd());
         if (repo) body.repo = repo.repo;
         if (isServiceToken) {
-          const { readTokens, SERVICE_TOKEN_LOGIN_USER_ID } = await import("./token-store-7OI3CMM4.js");
+          const { readTokens, SERVICE_TOKEN_LOGIN_USER_ID } = await import("./token-store-QYXUL4NG.js");
           const stored = readTokens(options.envName);
           const storedUserExternalId = stored?.tokenType === "service" && stored.user.id !== SERVICE_TOKEN_LOGIN_USER_ID ? stored.user.id : void 0;
           const userExternalId = process.env.FML_USER_EXTERNAL_ID ?? storedUserExternalId;

package/dist/{chunk-UGUYQVUW.js → chunk-T3ZFT3QP.js}

@@ -6,7 +6,7 @@ import {
   getSiteUrlForConvexUrl,
   getSyncDestinationIdentity,
   getValidToken
-} from "./chunk-TNJVAET3.js";
+} from "./chunk-ZBSC57CW.js";
 
 // ../../packages/panopticon/src/artifact.ts
 import {
@@ -235,7 +235,7 @@ function walkFiles(input) {
   const root = normalizeFilePath(input.root);
   const files = [];
   const seen = /* @__PURE__ */ new Set();
-  const skipDirs = input.skipDirs ?? DEFAULT_SKIP_DIRS;
+  const skipDirs = /* @__PURE__ */ new Set([...DEFAULT_SKIP_DIRS, ...input.skipDirs ?? []]);
   function walk(dir, depth) {
     if (depth > input.maxDepth) return;
     for (const entry of safeReaddir(dir)) {
@@ -741,6 +741,7 @@ var grokArtifactDiscovery = Object.freeze({
 
 // ../../packages/agent-targets/src/artifacts/targets/pi.ts
 import path15 from "path";
+var PI_SKIP_DIRS = /* @__PURE__ */ new Set(["subagent-artifacts"]);
 function piTranscriptCandidate(sourcePath, context) {
   const fallbackObservedAtMs = (context.nowMs ?? Date.now)();
   for (const record of readJsonlContextRecords(sourcePath)) {
@@ -779,7 +780,8 @@ var piArtifactDiscovery = Object.freeze({
     return walkFiles({
       root: path15.join(homeDir, ".pi", "agent", "sessions"),
       maxDepth: 8,
-      includeFile: (filePath) => filePath.endsWith(".jsonl")
+      includeFile: (filePath) => filePath.endsWith(".jsonl"),
+      skipDirs: PI_SKIP_DIRS
     }).map((sourcePath) => piTranscriptCandidate(sourcePath, context));
   }
 });

package/dist/{chunk-TNJVAET3.js → chunk-ZBSC57CW.js}

@@ -150,6 +150,7 @@ var FML_OBSERVER_ENDPOINT_FILE = path.join(
   "endpoint.json"
 );
 var FML_OBSERVER_LOG_FILE = path.join(FML_LOG_DIR, "observer.log");
+var FML_UPDATE_LOG_FILE = path.join(FML_LOG_DIR, "update.log");
 var FML_INSTALLATION_ID_FILE = path.join(
   FML_STATE_DIR,
   "installation_id"
@@ -1572,6 +1573,7 @@ export {
   FML_OBSERVER_AUTH_TOKEN_FILE,
   FML_OBSERVER_ENDPOINT_FILE,
   FML_OBSERVER_LOG_FILE,
+  FML_UPDATE_LOG_FILE,
   FML_INSTALLATION_ID_FILE,
   FML_PANOPTICON_DB_FILE,
   FML_PANOPTICON_DB_OBSERVER_STATE_FILE,

package/dist/{chunk-E6YIJCIE.js → chunk-ZGA57JPY.js}

@@ -6,7 +6,7 @@ import {
   getSiteUrlForConvexUrl,
   getSyncDestinationIdentity,
   getValidToken
-} from "./chunk-TNJVAET3.js";
+} from "./chunk-ZBSC57CW.js";
 
 // src/hooks/sync-loop.ts
 import { createHash } from "crypto";
@@ -449,17 +449,27 @@ function hookSessionRow(events) {
   const cwds = [...cwdsByPath.values()].sort(
     (left, right) => left.firstSeenMs - right.firstSeenMs || left.order - right.order
   ).map(({ order: _order, ...relationship }) => relationship);
+  const timezone = machineTimezone();
   return {
     sessionId: first.sessionId,
     target: first.target,
     startedAtMs,
     createdAt: startedAtMs,
     machine: "local",
+    ...timezone ? { timezone } : {},
     ...firstPrompt ? { firstPrompt } : {},
     ...repositories.length > 0 ? { repositories } : {},
     ...cwds.length > 0 ? { cwds } : {}
   };
 }
+function machineTimezone() {
+  try {
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    return timezone && timezone.length > 0 ? timezone : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function batchesForSession(events) {
   const batches = [];
   let batch = [];