@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-H3ISZJMJ.js

@@ -0,0 +1,403 @@
+import {
+  createEngineMetadata
+} from "./chunk-4EBSXZ73.js";
+import {
+  BaseProviderAuth,
+  assertSkipAuthAllowed
+} from "./chunk-33IGPPUI.js";
+import {
+  logWarning
+} from "./chunk-ETAD4NKD.js";
+import {
+  getProviderRuntimeQuirks
+} from "./chunk-Y733RB7T.js";
+import {
+  getDefaultPaths
+} from "./chunk-56WPYDJH.js";
+import {
+  resolveBuildRoot
+} from "./chunk-CHA2HDE5.js";
+import {
+  BUILD_CURSOR_ALLOW_CONFIG_FALLBACK,
+  BUILD_WORKTREE,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/core/providers/cursor/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  CURSOR_RUNTIME_ALLOW_RULES: () => CURSOR_RUNTIME_ALLOW_RULES,
+  CursorConfigWriteRulesError: () => CursorConfigWriteRulesError,
+  getCursorAuthPaths: () => getCursorAuthPaths,
+  getCursorConfigPath: () => getCursorConfigPath,
+  isAuthenticated: () => isAuthenticated,
+  isAuthenticatedTriState: () => isAuthenticatedTriState,
+  resolveCursorConfigDir: () => resolveCursorConfigDir,
+  resolveCursorConfigDirWithLegacyFallback: () => resolveCursorConfigDirWithLegacyFallback,
+  withCursorRuntimeAllowRules: () => withCursorRuntimeAllowRules
+});
+import {
+  accessSync,
+  existsSync,
+  constants as fsConstants,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { stat } from "fs/promises";
+import { homedir } from "os";
+import * as path from "path";
+
+// src/core/providers/cursor/metadata.ts
+var metadata = createEngineMetadata(
+  {
+    id: "cursor",
+    name: "Cursor",
+    description: "Authenticate with Cursor AI",
+    cliCommand: "cursor-agent",
+    cliBinary: "cursor-agent",
+    installCommand: "curl https://cursor.com/install -fsS | bash",
+    authHint: "cursor-agent login",
+    setupCommand: "build provider setup --providers cursor",
+    docsPath: "docs/PROVIDER_SETUP.md",
+    docsAnchor: "cursor-cli",
+    experimental: false,
+    gitAttribution: {
+      signatures: {
+        identities: ["cursoragent@cursor.com"],
+        trailers: ["Made-with"],
+        bylines: ["Made with Cursor", "Co-authored-by: Cursor"]
+      },
+      // Build applies these settings for the local CLI executor only. It does
+      // not rely on them for the cloud-agent or SDK executors, where the Guard
+      // gate is the control it enforces itself.
+      humanOnlySettings: [
+        {
+          scope: "user",
+          file: "cli-config.json",
+          set: {
+            "attribution.attributeCommitsToAgent": false,
+            "attribution.attributePRsToAgent": false
+          }
+        },
+        {
+          scope: "runtime",
+          file: "cli-config.json",
+          set: {
+            "attribution.attributeCommitsToAgent": false,
+            "attribution.attributePRsToAgent": false
+          }
+        }
+      ]
+    }
+  },
+  ["experimental"]
+);
+
+// src/core/providers/cursor/auth.ts
+var CURSOR_RUNTIME_ALLOW_RULES = ["Write(*)", "Read(*)", "Execute(*)"];
+function withCursorRuntimeAllowRules(parsed) {
+  const permissions = parsed.permissions && typeof parsed.permissions === "object" && !Array.isArray(parsed.permissions) ? parsed.permissions : {};
+  const allow = Array.isArray(permissions.allow) ? permissions.allow.filter((entry) => typeof entry === "string") : [];
+  const deny = Array.isArray(permissions.deny) ? permissions.deny.filter((entry) => typeof entry === "string") : [];
+  const added = CURSOR_RUNTIME_ALLOW_RULES.filter((rule) => !allow.includes(rule));
+  return {
+    config: { ...parsed, permissions: { ...permissions, allow: [...allow, ...added], deny } },
+    added
+  };
+}
+function resolveCursorFallbackRoot(options) {
+  const candidate = options?.worktreeRoot?.trim();
+  if (candidate) {
+    return path.resolve(candidate);
+  }
+  return resolveBuildRoot();
+}
+function getCursorFallbackConfigDir(options) {
+  const uid = process.getuid?.() ?? process.pid;
+  return path.join(
+    resolveCursorFallbackRoot(options),
+    ".build-project",
+    "tmp",
+    "cursor-config-fallback",
+    String(uid),
+    String(process.pid)
+  );
+}
+function hasCursorWritePermission(configDir) {
+  try {
+    if (existsSync(configDir)) {
+      accessSync(configDir, fsConstants.W_OK);
+      return true;
+    }
+    accessSync(path.dirname(configDir), fsConstants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function configHasWriteRules(configPath) {
+  try {
+    if (!existsSync(configPath)) return false;
+    const parsed = JSON.parse(readFileSync(configPath, "utf8"));
+    const allow = Array.isArray(parsed.permissions?.allow) ? parsed.permissions.allow : [];
+    return allow.some((entry) => typeof entry === "string" && /^Write\(/.test(entry));
+  } catch {
+    return false;
+  }
+}
+function cursorApiKeyAuthState(env) {
+  const source = env ?? process.env;
+  const value = source.CURSOR_API_KEY;
+  return typeof value === "string" && value.trim().length > 0 ? "unknown" : "no";
+}
+function configHasAuthMaterial(configPath) {
+  try {
+    const parsed = JSON.parse(readFileSync(configPath, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return false;
+    }
+    const hasNonEmptyStringValue = (value) => {
+      if (typeof value === "string") {
+        return value.trim().length > 0;
+      }
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        return Object.values(value).some(hasNonEmptyStringValue);
+      }
+      return false;
+    };
+    const auth = parsed.auth;
+    if (hasNonEmptyStringValue(auth)) {
+      return true;
+    }
+    const authInfo = parsed.authInfo;
+    if (hasNonEmptyStringValue(authInfo)) {
+      return true;
+    }
+    const serverConfigCache = parsed.serverConfigCache;
+    if (serverConfigCache && typeof serverConfigCache === "object" && !Array.isArray(serverConfigCache)) {
+      const authCacheKey = serverConfigCache.authCacheKey;
+      if (hasNonEmptyStringValue(authCacheKey)) {
+        return true;
+      }
+    }
+    return ["token", "accessToken", "refreshToken", "apiKey"].some(
+      (key) => typeof parsed[key] === "string" && parsed[key].trim().length > 0
+    );
+  } catch {
+    return false;
+  }
+}
+function buildRuntimeCursorConfig(sourceConfigPath) {
+  const defaultConfig = {
+    version: 1,
+    permissions: {
+      allow: [...CURSOR_RUNTIME_ALLOW_RULES],
+      deny: []
+    }
+  };
+  try {
+    if (!existsSync(sourceConfigPath)) {
+      return JSON.stringify(defaultConfig, null, 2);
+    }
+    const parsed = JSON.parse(readFileSync(sourceConfigPath, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return JSON.stringify(defaultConfig, null, 2);
+    }
+    return JSON.stringify(withCursorRuntimeAllowRules(parsed).config, null, 2);
+  } catch {
+    return JSON.stringify(defaultConfig, null, 2);
+  }
+}
+function prepareCursorFallbackConfigDir(sourceDir, fallbackDir) {
+  try {
+    mkdirSync(fallbackDir, { recursive: true, mode: 448 });
+    const sourceConfigPath = getCursorConfigPath(sourceDir);
+    const fallbackConfigPath = getCursorConfigPath(fallbackDir);
+    writeFileSync(fallbackConfigPath, buildRuntimeCursorConfig(sourceConfigPath), { mode: 384 });
+    return true;
+  } catch (error) {
+    try {
+      if (existsSync(fallbackDir)) {
+        unlinkSync(getCursorConfigPath(fallbackDir));
+      }
+    } catch {
+    }
+    logWarning(
+      "Cursor",
+      `Failed to prepare fallback config dir at ${fallbackDir}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return false;
+  }
+}
+var CursorAuth = class extends BaseProviderAuth {
+  metadata = metadata;
+  defaultConfigSubdir = "cursor";
+  configDirEnvVar = "CURSOR_CONFIG_DIR";
+  /**
+   * Resolves the Cursor config directory
+   */
+  resolveConfigDir(options) {
+    if (options?.cursorConfigDir !== void 0) {
+      return super.resolveConfigDir({
+        ...options,
+        configDir: options.cursorConfigDir
+      });
+    }
+    if (options?.configDir !== void 0 || process.env[this.configDirEnvVar]) {
+      return super.resolveConfigDir(options);
+    }
+    const cursorCliConfigDir = path.join(homedir(), ".cursor");
+    if (existsSync(this.getAuthFilePath(cursorCliConfigDir))) {
+      return cursorCliConfigDir;
+    }
+    return super.resolveConfigDir(options);
+  }
+  getAuthFilePath(configDir) {
+    return path.join(configDir, "cli-config.json");
+  }
+  /**
+   * Checks if authenticated by verifying auth file exists
+   */
+  async isAuthenticated(options) {
+    const configDir = this.resolveConfigDir(options);
+    const authPath = this.getAuthFilePath(configDir);
+    let statsResult = null;
+    try {
+      statsResult = await stat(authPath);
+    } catch {
+      statsResult = null;
+    }
+    if (process.env.BUILD_SKIP_AUTH === "1") {
+      assertSkipAuthAllowed();
+      return statsResult !== null;
+    }
+    if (statsResult?.isFile()) {
+      return configHasAuthMaterial(authPath);
+    }
+    if (statsResult !== null) {
+      return false;
+    }
+    return false;
+  }
+};
+var cursorAuth = new CursorAuth();
+function resolveCursorConfigDir(options) {
+  return cursorAuth.resolveConfigDir(options);
+}
+function resolveCursorSourceConfigDir(options) {
+  const resolved = resolveCursorConfigDir(options);
+  const legacyDir = path.join(homedir(), ".build", "cursor");
+  const resolvedAuthPath = getCursorConfigPath(resolved);
+  const legacyAuthPath = getCursorConfigPath(legacyDir);
+  return !existsSync(resolvedAuthPath) && existsSync(legacyAuthPath) ? legacyDir : resolved;
+}
+var CursorConfigWriteRulesError = class extends Error {
+  constructor() {
+    super(
+      "[Cursor] Resolved config dir lacks Write(*) permission rules or is not writable. Run 'cursor-agent login', fix permissions on your Cursor config dir, or set BUILD_CURSOR_ALLOW_CONFIG_FALLBACK=1 to use an isolated fallback config."
+    );
+    this.name = "CursorConfigWriteRulesError";
+  }
+};
+function resolveCursorConfigDirWithLegacyFallback(options) {
+  const selectedDir = resolveCursorSourceConfigDir(options);
+  const selectedAuthPath = getCursorConfigPath(selectedDir);
+  if (configHasWriteRules(selectedAuthPath) && hasCursorWritePermission(selectedDir)) {
+    return selectedDir;
+  }
+  const runtimeEnv = options?.runtimeEnv;
+  const runtimeWorktree = runtimeEnv?.BUILD_WORKTREE?.trim();
+  const isolatedBuildRun = runtimeWorktree !== void 0 ? runtimeWorktree === "1" : readEnv(BUILD_WORKTREE).value;
+  const runtimeFallback = runtimeEnv?.BUILD_CURSOR_ALLOW_CONFIG_FALLBACK;
+  const runtimeFallbackIsExplicit = runtimeFallback === "0" || runtimeFallback === "1";
+  const allowFallback = runtimeFallbackIsExplicit ? runtimeFallback === "1" : (readEnv(BUILD_CURSOR_ALLOW_CONFIG_FALLBACK).value ?? false) || isolatedBuildRun;
+  if (!allowFallback) {
+    throw new CursorConfigWriteRulesError();
+  }
+  const fallbackDir = getCursorFallbackConfigDir(options);
+  if (!prepareCursorFallbackConfigDir(selectedDir, fallbackDir)) {
+    logWarning(
+      "Cursor",
+      `Fallback config preparation failed; continuing with the original config dir ${selectedDir} (writes may be restricted).`
+    );
+    return selectedDir;
+  }
+  logWarning(
+    "Cursor",
+    `Detected restricted or write-limited config environment. Worktree runs use an isolated fallback config with broad Write(*)/Read(*)/Execute(*) allow rules: ${fallbackDir}`
+  );
+  return fallbackDir;
+}
+function getCursorConfigPath(configDir) {
+  return path.join(configDir, "cli-config.json");
+}
+function getCursorAuthPaths(configDir) {
+  return [
+    getCursorConfigPath(configDir),
+    // cli-config.json
+    path.join(configDir, "chats"),
+    // chats directory
+    path.join(configDir, "projects")
+    // projects directory
+  ];
+}
+async function isAuthenticated(options) {
+  return cursorAuth.isAuthenticated(options);
+}
+async function isAuthenticatedTriState(options) {
+  if (options?.mode === "active") {
+    try {
+      const configDir = resolveCursorSourceConfigDir();
+      if (configHasAuthMaterial(getCursorConfigPath(configDir))) {
+        return "yes";
+      }
+      return cursorApiKeyAuthState(options.env);
+    } catch {
+      return "unknown";
+    }
+  }
+  const quirks = getProviderRuntimeQuirks("cursor");
+  const envVarName = quirks?.config?.envVar ?? "CURSOR_CONFIG_DIR";
+  const configEnvValue = process.env[envVarName];
+  const authFileName = quirks?.config?.authFiles?.[0]?.path ?? "cli-config.json";
+  if (configEnvValue) {
+    const candidate = path.join(configEnvValue, authFileName);
+    if (configHasAuthMaterial(candidate)) {
+      return "yes";
+    }
+    return cursorApiKeyAuthState(options?.env);
+  }
+  const buildSubdir = quirks?.config?.buildSubdir ?? "providers/cursor";
+  const buildDir = path.join(getDefaultPaths().userConfigDir, buildSubdir);
+  const nativeDir = quirks?.config?.nativeDirs?.[0] ?? ".cursor";
+  const candidates = [
+    path.join(buildDir, authFileName),
+    path.join(homedir(), nativeDir, authFileName)
+  ];
+  for (const candidate of candidates) {
+    if (configHasAuthMaterial(candidate)) {
+      return "yes";
+    }
+  }
+  return cursorApiKeyAuthState(options?.env);
+}
+
+export {
+  metadata,
+  CURSOR_RUNTIME_ALLOW_RULES,
+  withCursorRuntimeAllowRules,
+  resolveCursorConfigDir,
+  CursorConfigWriteRulesError,
+  resolveCursorConfigDirWithLegacyFallback,
+  getCursorConfigPath,
+  getCursorAuthPaths,
+  isAuthenticated,
+  isAuthenticatedTriState,
+  auth_exports
+};
+//# sourceMappingURL=chunk-H3ISZJMJ.js.map

package/dist/chunk-H4HXVWEC.js

@@ -0,0 +1,9 @@
+// src/utils/ipv4-ranges.ts
+function hasLocalIpv4Prefix(ip) {
+  return /^127\./.test(ip) || /^10\./.test(ip) || /^192\.168\./.test(ip) || /^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(ip) || /^169\.254\./.test(ip);
+}
+
+export {
+  hasLocalIpv4Prefix
+};
+//# sourceMappingURL=chunk-H4HXVWEC.js.map

package/dist/chunk-H6MJGKAW.js

@@ -0,0 +1,120 @@
+// src/core/providers/shared/token-tracker.ts
+var INPUT_TOKEN_FIELDS = [
+  "input_tokens",
+  "prompt_tokens",
+  "promptTokenCount",
+  "inputTokens"
+];
+var OUTPUT_TOKEN_FIELDS = [
+  "output_tokens",
+  "completion_tokens",
+  "candidatesTokenCount",
+  "outputTokens"
+];
+var CACHED_TOKEN_FIELDS = [
+  "cached_input_tokens",
+  "cachedInputTokens",
+  "cache_read_input_tokens"
+];
+var CACHE_CREATION_TOKEN_FIELDS = [
+  "cache_creation_input_tokens",
+  "cacheCreationInputTokens",
+  "cache_write_input_tokens",
+  "cacheWriteTokens"
+];
+function extractField(raw, fieldNames) {
+  for (const name of fieldNames) {
+    const value = raw[name];
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function normalizeTokenUsage(raw, _provider) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const inputTokens = extractField(raw, INPUT_TOKEN_FIELDS);
+  const outputTokens = extractField(raw, OUTPUT_TOKEN_FIELDS);
+  if (inputTokens === void 0 || outputTokens === void 0) return void 0;
+  const cachedInputTokens = extractField(raw, CACHED_TOKEN_FIELDS);
+  const cacheCreationInputTokens = extractField(raw, CACHE_CREATION_TOKEN_FIELDS);
+  const totalTokens = inputTokens + outputTokens;
+  const cacheReadIncluded = raw.cacheReadTokensIncludedInInput;
+  const cacheCreationIncluded = raw.cacheCreationTokensIncludedInInput;
+  return {
+    inputTokens,
+    outputTokens,
+    ...cachedInputTokens !== void 0 ? { cachedInputTokens } : {},
+    ...cacheCreationInputTokens !== void 0 ? { cacheCreationInputTokens } : {},
+    ...typeof cacheReadIncluded === "boolean" ? { cacheReadTokensIncludedInInput: cacheReadIncluded } : {},
+    ...typeof cacheCreationIncluded === "boolean" ? { cacheCreationTokensIncludedInInput: cacheCreationIncluded } : {},
+    totalTokens
+  };
+}
+function sumTokenUsage(usage) {
+  if (!usage) return void 0;
+  const total = usage.inputTokens + usage.outputTokens + (usage.cacheReadTokensIncludedInInput === true ? 0 : usage.cachedInputTokens ?? 0) + (usage.cacheCreationTokensIncludedInInput === true ? 0 : usage.cacheCreationInputTokens ?? 0);
+  return total > 0 ? total : void 0;
+}
+function mergeCacheDimension(left, right, countKey, flagKey) {
+  const leftCount = left[countKey] ?? 0;
+  const rightCount = right[countKey] ?? 0;
+  const count = leftCount + rightCount;
+  if (count <= 0) return { count: 0, leftLift: 0, rightLift: 0 };
+  const leftIncluded = left[flagKey] === true;
+  const rightIncluded = right[flagKey] === true;
+  if (leftCount > 0 && rightCount > 0 && leftIncluded !== rightIncluded) {
+    return {
+      count,
+      included: true,
+      leftLift: leftIncluded ? 0 : leftCount,
+      rightLift: rightIncluded ? 0 : rightCount
+    };
+  }
+  const reportedCountIncluded = leftCount > 0 && leftIncluded || rightCount > 0 && rightIncluded;
+  const reportedSeparate = leftCount > 0 && left[flagKey] === false || rightCount > 0 && right[flagKey] === false;
+  return {
+    count,
+    leftLift: 0,
+    rightLift: 0,
+    ...reportedCountIncluded ? { included: true } : reportedSeparate ? { included: false } : {}
+  };
+}
+function mergeTokenUsage(left, right) {
+  if (!left) return right;
+  if (!right) return left;
+  const read = mergeCacheDimension(
+    left,
+    right,
+    "cachedInputTokens",
+    "cacheReadTokensIncludedInInput"
+  );
+  const creation = mergeCacheDimension(
+    left,
+    right,
+    "cacheCreationInputTokens",
+    "cacheCreationTokensIncludedInInput"
+  );
+  const merged = {
+    inputTokens: left.inputTokens + right.inputTokens + read.leftLift + read.rightLift + creation.leftLift + creation.rightLift,
+    outputTokens: left.outputTokens + right.outputTokens
+  };
+  if (read.count > 0) {
+    merged.cachedInputTokens = read.count;
+    if (read.included !== void 0) merged.cacheReadTokensIncludedInInput = read.included;
+  }
+  if (creation.count > 0) {
+    merged.cacheCreationInputTokens = creation.count;
+    if (creation.included !== void 0) {
+      merged.cacheCreationTokensIncludedInInput = creation.included;
+    }
+  }
+  return merged;
+}
+
+export {
+  normalizeTokenUsage,
+  sumTokenUsage,
+  mergeTokenUsage
+};
+//# sourceMappingURL=chunk-H6MJGKAW.js.map