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

package/dist/{chunk-PZ5AY32C.js → chunk-MLKGABMK.js}

@@ -7,4 +7,3 @@ var __export = (target, all) => {
 export {
   __export
 };
-//# sourceMappingURL=chunk-PZ5AY32C.js.map

package/dist/{chunk-2H6D7RUN.js → chunk-P3QLARXE.js}

@@ -1,11 +1,15 @@
+import {
+  resolveRepoFromCwd
+} from "./chunk-T5YVLSUC.js";
 import {
   CONVEX_URL,
+  getActiveEnv,
   getSelectedOrg,
+  getSiteUrlForConvexUrl,
   getValidToken
-} from "./chunk-VDW5L7OB.js";
+} from "./chunk-7DR5X7XI.js";
 
 // src/fml-client.ts
-import { resolveRepoFromCwd } from "@fml-inc/panopticon/repo";
 var LOGIN_EXPIRED_MESSAGE = "Authentication expired. Run `fml login` to sign in again, then restart Claude Code.";
 function isAuthError(data) {
   return data.code === "UNAUTHENTICATED" || data.code === "TOKEN_EXPIRED" || data.error?.includes("Unauthorized") === true || data.error?.includes("not authenticated") === true;
@@ -22,17 +26,12 @@ function requireToolResult(result) {
   }
   return result.result;
 }
-function createFmlClient(token) {
+function createFmlClient(token, options = {}) {
   const isServiceToken = token.startsWith("fml_st_");
-  function getSiteUrl() {
-    return CONVEX_URL.replace(".convex.cloud", ".convex.site").replace(
-      /\/$/,
-      ""
-    );
-  }
+  const siteUrl = (options.siteUrl ?? getSiteUrlForConvexUrl(CONVEX_URL)).replace(/\/$/, "");
   async function fetchContext(pathAndQuery, init) {
     try {
-      const res = await fetch(`${getSiteUrl()}${pathAndQuery}`, {
+      const res = await fetch(`${siteUrl}${pathAndQuery}`, {
         ...init,
         headers: {
           Authorization: `Bearer ${token}`,
@@ -44,7 +43,10 @@ function createFmlClient(token) {
       try {
         data = JSON.parse(text);
       } catch {
-        return { ok: false, error: `HTTP ${res.status}: ${text.slice(0, 200)}` };
+        return {
+          ok: false,
+          error: `HTTP ${res.status}: ${text.slice(0, 200)}`
+        };
       }
       if (!res.ok) {
         const envelope = data;
@@ -56,7 +58,10 @@ function createFmlClient(token) {
       }
       return { ok: true, result: data };
     } catch (err) {
-      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+      return {
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
     }
   }
   return {
@@ -69,16 +74,18 @@ function createFmlClient(token) {
     async callBackend(toolName, args, opts) {
       try {
         const body = { toolName, args };
-        const org = opts?.org ?? getSelectedOrg();
+        const org = opts?.org ?? getSelectedOrg(options.envName);
         if (org) body.org = org;
         const repo = resolveRepoFromCwd(process.cwd());
         if (repo) body.repo = repo.repo;
         if (isServiceToken) {
-          const { readTokens } = await import("./token-store-JZJ3FJHA.js");
-          const userExternalId = process.env.FML_USER_EXTERNAL_ID ?? readTokens()?.user.id;
+          const { readTokens, SERVICE_TOKEN_LOGIN_USER_ID } = await import("./token-store-R7WXEPLI.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;
           if (userExternalId) body.userExternalId = userExternalId;
         }
-        const res = await fetch(`${getSiteUrl()}/api/tools/execute`, {
+        const res = await fetch(`${siteUrl}/api/tools/execute`, {
           method: "POST",
           headers: {
             "Content-Type": "application/json",
@@ -96,8 +103,12 @@ function createFmlClient(token) {
             error: `HTTP ${res.status}: ${text.slice(0, 200)}`
           };
         }
-        if (!res.ok && !data.error) {
-          return { ok: false, error: `HTTP ${res.status}` };
+        if (!res.ok) {
+          return normalizeToolResult({
+            ok: false,
+            error: data.error ?? `HTTP ${res.status}`,
+            code: data.code
+          });
         }
         return normalizeToolResult(data);
       } catch (err) {
@@ -111,7 +122,7 @@ function createFmlClient(token) {
     // ── Tool catalog ─────────────────────────────────────────────────────
     async listTools(pluginVersion) {
       try {
-        const url = new URL(`${getSiteUrl()}/api/tools/list`);
+        const url = new URL(`${siteUrl}/api/tools/list`);
         if (pluginVersion) url.searchParams.set("pluginVersion", pluginVersion);
         const res = await fetch(url.toString(), {
           headers: { Authorization: `Bearer ${token}` }
@@ -204,14 +215,16 @@ function createFmlClient(token) {
     }
   };
 }
-async function getAuthenticatedClient() {
-  const token = await getValidToken();
+async function getAuthenticatedClient(environment = getActiveEnv()) {
+  const token = await getValidToken({ env: environment.name });
   if (!token) return null;
-  return createFmlClient(token);
+  return createFmlClient(token, {
+    envName: environment.name,
+    siteUrl: getSiteUrlForConvexUrl(environment.convexUrl)
+  });
 }
 
 export {
   createFmlClient,
   getAuthenticatedClient
 };
-//# sourceMappingURL=chunk-2H6D7RUN.js.map

package/dist/chunk-T5YVLSUC.js

@@ -0,0 +1,138 @@
+// src/repo.ts
+import { execFile, execFileSync } from "child_process";
+var REPO_CACHE = /* @__PURE__ */ new Map();
+var ASYNC_REPO_CACHE = /* @__PURE__ */ new Map();
+var GIT_TIMEOUT_MS = 5e3;
+var POSITIVE_REPO_CACHE_TTL_MS = 3e4;
+var NEGATIVE_REPO_CACHE_TTL_MS = 1e3;
+var MAX_REPO_CACHE_ENTRIES = 256;
+function cachedRepo(cwd) {
+  const entry = REPO_CACHE.get(cwd);
+  if (!entry) return { hit: false };
+  if (entry.expiresAtMs <= Date.now()) {
+    REPO_CACHE.delete(cwd);
+    return { hit: false };
+  }
+  REPO_CACHE.delete(cwd);
+  REPO_CACHE.set(cwd, entry);
+  return { hit: true, value: entry.value };
+}
+function cacheRepo(cwd, value) {
+  REPO_CACHE.delete(cwd);
+  while (REPO_CACHE.size >= MAX_REPO_CACHE_ENTRIES) {
+    const oldest = REPO_CACHE.keys().next().value;
+    if (oldest === void 0) break;
+    REPO_CACHE.delete(oldest);
+  }
+  REPO_CACHE.set(cwd, {
+    value,
+    expiresAtMs: Date.now() + (value === null ? NEGATIVE_REPO_CACHE_TTL_MS : POSITIVE_REPO_CACHE_TTL_MS)
+  });
+}
+function git(cwd, args, timeoutMs) {
+  try {
+    return execFileSync("git", ["-C", cwd, ...args], {
+      encoding: "utf8",
+      timeout: timeoutMs,
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function gitAsync(cwd, args, signal) {
+  return new Promise((resolve, reject) => {
+    try {
+      execFile(
+        "git",
+        ["-C", cwd, ...args],
+        {
+          encoding: "utf8",
+          timeout: GIT_TIMEOUT_MS,
+          windowsHide: true,
+          ...signal ? { signal } : {}
+        },
+        (error, stdout) => {
+          if (signal?.aborted) {
+            reject(signal.reason ?? new Error("Repository lookup aborted"));
+            return;
+          }
+          resolve(error ? null : stdout.trim() || null);
+        }
+      );
+    } catch (error) {
+      if (signal?.aborted) {
+        reject(signal.reason ?? error);
+        return;
+      }
+      resolve(null);
+    }
+  });
+}
+function repositorySlug(remote) {
+  const ssh = remote.match(/^[^@]+@[^:]+:([^/]+\/[^/]+?)(?:\.git)?$/);
+  if (ssh?.[1]) return ssh[1];
+  try {
+    const url = new URL(remote);
+    const slug = url.pathname.replace(/^\/+|\/+$/g, "").replace(/\.git$/, "");
+    return /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(slug) ? slug : null;
+  } catch {
+    return null;
+  }
+}
+function resolveRepoFromCwd(cwd, timeoutMs = GIT_TIMEOUT_MS) {
+  const cached = cachedRepo(cwd);
+  if (cached.hit) return cached.value;
+  const remote = git(cwd, ["remote", "get-url", "origin"], timeoutMs);
+  const repo = remote ? repositorySlug(remote) : null;
+  const result = repo ? {
+    repo,
+    branch: git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"], timeoutMs)
+  } : null;
+  cacheRepo(cwd, result);
+  return result;
+}
+function resolveRepositorySlugFromCwd(cwd, timeoutMs = GIT_TIMEOUT_MS) {
+  const cached = cachedRepo(cwd);
+  if (cached.hit) return cached.value?.repo ?? null;
+  const remote = git(cwd, ["remote", "get-url", "origin"], timeoutMs);
+  return remote ? repositorySlug(remote) : null;
+}
+async function resolveRepoFromCwdAsync(cwd, signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new Error("Repository lookup aborted");
+  }
+  const cached = cachedRepo(cwd);
+  if (cached.hit) return cached.value;
+  const cachedResolution = ASYNC_REPO_CACHE.get(cwd);
+  if (cachedResolution) return await cachedResolution;
+  const resolution = (async () => {
+    const remote = await gitAsync(cwd, ["remote", "get-url", "origin"], signal);
+    const repo = remote ? repositorySlug(remote) : null;
+    const result = repo ? {
+      repo,
+      branch: await gitAsync(
+        cwd,
+        ["rev-parse", "--abbrev-ref", "HEAD"],
+        signal
+      )
+    } : null;
+    cacheRepo(cwd, result);
+    return result;
+  })();
+  ASYNC_REPO_CACHE.set(cwd, resolution);
+  try {
+    return await resolution;
+  } finally {
+    if (ASYNC_REPO_CACHE.get(cwd) === resolution) {
+      ASYNC_REPO_CACHE.delete(cwd);
+    }
+  }
+}
+
+export {
+  resolveRepoFromCwd,
+  resolveRepositorySlugFromCwd,
+  resolveRepoFromCwdAsync
+};