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

package/dist/pi/extension.js

@@ -0,0 +1,350 @@
+// src/pi/extension.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import fs2 from "node:fs";
+import os from "node:os";
+import path2 from "node:path";
+
+// ../../packages/agent-targets/src/install/pi/index.ts
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+var FML_PI_EXTENSION_MARKER = "__FML_PI_EXTENSION_V1__";
+var LEGACY_PI_EXTENSION_MARKER = "__panopticonPiExtensionTest";
+var LEGACY_PI_EXTENSION_SIGNATURES = Object.freeze([
+  "PANOPTICON_PORT",
+  '"/hooks"',
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "SessionEnd"
+]);
+function pathApiFor(platform) {
+  return platform === "win32" ? path.win32 : path.posix;
+}
+function resolvePiAgentDir(context, pathApi) {
+  const configured = context.env.PI_CODING_AGENT_DIR?.trim();
+  if (!configured) {
+    return pathApi.join(context.homeDir, ".pi", "agent");
+  }
+  if (configured === "~") return context.homeDir;
+  if (configured.startsWith("~/") || configured.startsWith("~\\")) {
+    return pathApi.join(context.homeDir, configured.slice(2));
+  }
+  return pathApi.normalize(configured);
+}
+function readFileIfPresent(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function isOwnedExtension(source, legacy = false) {
+  return source.includes(FML_PI_EXTENSION_MARKER) || legacy && (source.includes(LEGACY_PI_EXTENSION_MARKER) || LEGACY_PI_EXTENSION_SIGNATURES.every(
+    (signature) => source.includes(signature)
+  ));
+}
+function removeLegacyExtension(filePath) {
+  const source = readFileIfPresent(filePath);
+  if (source === null) return { removed: false, preserved: false };
+  if (!isOwnedExtension(source, true)) {
+    return { removed: false, preserved: true };
+  }
+  fs.rmSync(filePath);
+  return { removed: true, preserved: false };
+}
+function writeExtensionAtomically(filePath, source) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 448 });
+  const temporaryPath = path.join(
+    path.dirname(filePath),
+    `.${path.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`
+  );
+  try {
+    fs.writeFileSync(temporaryPath, source, { encoding: "utf8", mode: 384 });
+    if (process.platform === "win32" && fs.existsSync(filePath)) {
+      fs.rmSync(filePath);
+    }
+    fs.renameSync(temporaryPath, filePath);
+  } finally {
+    fs.rmSync(temporaryPath, { force: true });
+  }
+}
+var PI_EXTENSION_INSTALLER = Object.freeze({
+  resolvePaths(context) {
+    const pathApi = pathApiFor(context.platform);
+    const extensionsDir = pathApi.join(
+      resolvePiAgentDir(context, pathApi),
+      "extensions"
+    );
+    return {
+      sourcePath: pathApi.join(
+        context.packageRoot,
+        "dist",
+        "pi",
+        "extension.js"
+      ),
+      extensionsDir,
+      destinationPath: pathApi.join(extensionsDir, "fml.js"),
+      legacyDestinationPath: pathApi.join(extensionsDir, "panopticon.js")
+    };
+  },
+  install(paths) {
+    const source = fs.readFileSync(paths.sourcePath, "utf8");
+    if (!source.includes(FML_PI_EXTENSION_MARKER)) {
+      throw new Error(
+        `Packaged Pi extension is invalid: ${paths.sourcePath} does not contain the FML ownership marker`
+      );
+    }
+    const existing = readFileIfPresent(paths.destinationPath);
+    if (existing !== null && !isOwnedExtension(existing)) {
+      const legacy2 = removeLegacyExtension(paths.legacyDestinationPath);
+      return {
+        status: "preserved",
+        destinationPath: paths.destinationPath,
+        reason: "an extension not managed by FML already exists at this path",
+        legacyRemoved: legacy2.removed,
+        legacyPreserved: legacy2.preserved
+      };
+    }
+    const status = existing === null ? "installed" : existing === source ? "unchanged" : "updated";
+    if (status !== "unchanged") {
+      writeExtensionAtomically(paths.destinationPath, source);
+    }
+    const legacy = removeLegacyExtension(paths.legacyDestinationPath);
+    return {
+      status,
+      destinationPath: paths.destinationPath,
+      legacyRemoved: legacy.removed,
+      legacyPreserved: legacy.preserved
+    };
+  },
+  uninstall(paths) {
+    const existing = readFileIfPresent(paths.destinationPath);
+    const legacy = removeLegacyExtension(paths.legacyDestinationPath);
+    if (existing === null) {
+      return {
+        status: "absent",
+        destinationPath: paths.destinationPath,
+        legacyRemoved: legacy.removed,
+        legacyPreserved: legacy.preserved
+      };
+    }
+    if (!isOwnedExtension(existing)) {
+      return {
+        status: "preserved",
+        destinationPath: paths.destinationPath,
+        reason: "the existing extension is not managed by FML",
+        legacyRemoved: legacy.removed,
+        legacyPreserved: legacy.preserved
+      };
+    }
+    fs.rmSync(paths.destinationPath);
+    return {
+      status: "removed",
+      destinationPath: paths.destinationPath,
+      legacyRemoved: legacy.removed,
+      legacyPreserved: legacy.preserved
+    };
+  }
+});
+
+// src/pi/extension.ts
+var DEFAULT_REQUEST_TIMEOUT_MS = 500;
+var DEFAULT_SHUTDOWN_FLUSH_TIMEOUT_MS = 5e3;
+var pendingPosts = /* @__PURE__ */ new Set();
+function positiveInteger(value, fallback) {
+  if (!value) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function absoluteEnvPath(value) {
+  if (!value?.trim()) return void 0;
+  const trimmed = value.trim();
+  if (trimmed === "~") return os.homedir();
+  if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
+    return path2.join(os.homedir(), trimmed.slice(2));
+  }
+  return path2.isAbsolute(trimmed) ? path2.normalize(trimmed) : void 0;
+}
+function observerDirectory() {
+  const fmlHome = absoluteEnvPath(process.env.FML_HOME);
+  return absoluteEnvPath(process.env.FML_OBSERVER_DIR) ?? absoluteEnvPath(process.env.PANOPTICON_HOME) ?? (fmlHome ? path2.join(fmlHome, "panopticon") : path2.join(os.homedir(), ".fml", "panopticon"));
+}
+function readObserverEndpoint(filePath) {
+  try {
+    const parsed = JSON.parse(fs2.readFileSync(filePath, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    const record = parsed;
+    if (record.host !== "127.0.0.1" && record.host !== "::1" && record.host !== "localhost" || typeof record.port !== "number" || !Number.isInteger(record.port) || record.port <= 0 || record.port > 65535) {
+      return null;
+    }
+    return { host: record.host, port: record.port };
+  } catch {
+    return null;
+  }
+}
+function readObserverAuthToken(filePath) {
+  try {
+    return fs2.readFileSync(filePath, "utf8").trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function deliver(event) {
+  const directory = observerDirectory();
+  const endpoint = readObserverEndpoint(path2.join(directory, "endpoint.json"));
+  const authToken = readObserverAuthToken(path2.join(directory, "auth-token"));
+  if (!endpoint || !authToken) return;
+  const host = endpoint.host === "::1" ? "[::1]" : endpoint.host;
+  try {
+    const response = await fetch(`http://${host}:${endpoint.port}/hooks`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${authToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        target: "pi",
+        payload: event,
+        ...event.cwd ? { cwd: event.cwd } : {}
+      }),
+      signal: AbortSignal.timeout(
+        positiveInteger(
+          process.env.FML_PI_REQUEST_TIMEOUT_MS,
+          DEFAULT_REQUEST_TIMEOUT_MS
+        )
+      )
+    });
+    await response.arrayBuffer();
+  } catch {
+  }
+}
+function post(event) {
+  const request = deliver(event);
+  pendingPosts.add(request);
+  void request.finally(() => pendingPosts.delete(request));
+}
+async function flushPendingPosts(timeoutMs = positiveInteger(
+  process.env.FML_PI_SHUTDOWN_FLUSH_TIMEOUT_MS,
+  DEFAULT_SHUTDOWN_FLUSH_TIMEOUT_MS
+)) {
+  if (pendingPosts.size === 0) return;
+  await Promise.race([
+    Promise.allSettled([...pendingPosts]),
+    new Promise((resolve) => setTimeout(resolve, timeoutMs))
+  ]);
+}
+function modelLabel(model) {
+  if (!model || typeof model !== "object") return void 0;
+  const record = model;
+  const id = record.id ?? record.name ?? record.model;
+  const provider = record.provider ?? record.providerId;
+  return [provider, id].filter((value) => typeof value === "string" && value.length > 0).join(":") || void 0;
+}
+function fmlPiExtension(pi) {
+  let sessionId = randomUUID2();
+  let cwd;
+  function emit(event) {
+    post({
+      ...event,
+      session_id: sessionId,
+      source: "pi",
+      cwd
+    });
+  }
+  pi.on("session_start", async (_event, context) => {
+    sessionId = context.sessionManager.getSessionId();
+    cwd = context.cwd;
+    emit({ hook_event_name: "SessionStart" });
+  });
+  pi.on("input", async (event) => {
+    emit({ hook_event_name: "UserPromptSubmit", prompt: event.text });
+  });
+  pi.on("turn_start", async (event) => {
+    emit({
+      hook_event_name: "TurnStart",
+      turn_index: event.turnIndex,
+      pi_timestamp: event.timestamp
+    });
+  });
+  pi.on("turn_end", async (event) => {
+    emit({
+      hook_event_name: "Stop",
+      turn_index: event.turnIndex,
+      assistant_message: event.message
+    });
+  });
+  pi.on("tool_call", async (event) => {
+    emit({
+      hook_event_name: "PreToolUse",
+      tool_name: event.toolName,
+      tool_call_id: event.toolCallId,
+      tool_input: event.input
+    });
+  });
+  pi.on("tool_result", async (event) => {
+    emit({
+      hook_event_name: event.isError ? "PostToolUseFailure" : "PostToolUse",
+      tool_name: event.toolName,
+      tool_call_id: event.toolCallId,
+      tool_input: event.input,
+      tool_result: { content: event.content, details: event.details }
+    });
+  });
+  pi.on("session_before_compact", async (event) => {
+    emit({
+      hook_event_name: "PreCompact",
+      branch_entry_count: event.branchEntries.length,
+      custom_instructions: event.customInstructions
+    });
+  });
+  pi.on("session_compact", async (event) => {
+    emit({
+      hook_event_name: "PostCompact",
+      compaction_entry: event.compactionEntry,
+      from_extension: event.fromExtension
+    });
+  });
+  pi.on("model_select", async (event) => {
+    emit({
+      hook_event_name: "ConfigChange",
+      config_key: "model",
+      config_source: event.source,
+      previous_value: modelLabel(event.previousModel),
+      new_value: modelLabel(event.model)
+    });
+  });
+  pi.on("thinking_level_select", async (event) => {
+    emit({
+      hook_event_name: "ConfigChange",
+      config_key: "thinking_level",
+      previous_value: event.previousLevel,
+      new_value: event.level
+    });
+  });
+  pi.on("user_bash", async (event) => {
+    emit({
+      hook_event_name: "Notification",
+      notification_type: "user_bash",
+      command: event.command,
+      exclude_from_context: event.excludeFromContext,
+      event_cwd: event.cwd
+    });
+  });
+  pi.on("session_shutdown", async () => {
+    emit({ hook_event_name: "SessionEnd" });
+    await flushPendingPosts();
+  });
+}
+var __fmlPiExtensionTest = {
+  flushPendingPosts,
+  pendingPostCount: () => pendingPosts.size
+};
+export {
+  FML_PI_EXTENSION_MARKER,
+  __fmlPiExtensionTest,
+  fmlPiExtension as default
+};

package/dist/sync-cycle.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import {
   runObserverSyncCycle
-} from "./chunk-CK5MEL5J.js";
-import "./chunk-JXSSPQ5B.js";
-import "./chunk-7DR5X7XI.js";
+} from "./chunk-3KISRT57.js";
+import "./chunk-YSU5CS2V.js";
+import "./chunk-A6HAEVJX.js";
 import "./chunk-MLKGABMK.js";
 
 // src/sync-cycle.ts

package/dist/{token-store-R7WXEPLI.js → token-store-BT5THIAJ.js}

@@ -10,7 +10,7 @@ import {
   setSelectedOrg,
   storeServiceRefreshToken,
   writeTokens
-} from "./chunk-7DR5X7XI.js";
+} from "./chunk-A6HAEVJX.js";
 import "./chunk-MLKGABMK.js";
 export {
   SERVICE_TOKEN_LOGIN_USER_ID,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fml-inc/fml",
-  "version": "0.8.0-rc.1",
+  "version": "0.8.0-rc.3",
   "description": "FML CLI and agent tools",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
@@ -37,15 +37,17 @@
     "zod": "4.1.12"
   },
   "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.83.0",
     "@sentry/core": "^10.43.0",
     "@types/node": "^22.0.0",
+    "esbuild": "^0.27.1",
     "tsup": "^8.0.0",
     "typescript": "^5",
-    "@fml/panopticon": "0.0.0",
-    "@fml/agent-targets": "0.0.0"
+    "@fml/agent-targets": "0.0.0",
+    "@fml/panopticon": "0.0.0"
   },
   "scripts": {
-    "build": "node scripts/generate-plugin-manifest.js && tsup",
+    "build": "node scripts/generate-plugin-manifest.js && tsup && node scripts/build-pi-extension.mjs",
     "dev": "tsup --watch",
     "pack:local": "pnpm pack",
     "type-check": "tsc --noEmit",