@primitive.ai/prim 0.1.0-alpha.9 → 0.1.0-alpha.90

package/dist/chunk-CUE2LKLR.js

@@ -0,0 +1,155 @@
+import {
+  decodeJwtPayload,
+  primConfigDirectory,
+  resolveAuthCredential
+} from "./chunk-3EEFL6NJ.js";
+
+// src/daemon/client.ts
+import { createConnection } from "net";
+import { join } from "path";
+
+// src/daemon/principal.ts
+import { createHash } from "crypto";
+var PRINCIPAL_COMPONENT_MAX_LENGTH = 512;
+function boundedClaim(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= PRINCIPAL_COMPONENT_MAX_LENGTH ? value : void 0;
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function resolveDaemonPrincipal(token = resolveAuthCredential()?.token) {
+  if (!token) return void 0;
+  const payload = decodeJwtPayload(token);
+  const subject = boundedClaim(payload?.sub);
+  const organizationId = boundedClaim(payload?.org_id);
+  if (!(subject && organizationId)) return void 0;
+  const issuer = boundedClaim(payload?.iss) ?? "unknown-issuer";
+  return {
+    principalId: sha256(`${issuer}\0${subject}`),
+    organizationId,
+    credentialFingerprint: sha256(token)
+  };
+}
+function daemonPrincipalsMatch(caller, daemon) {
+  return caller !== void 0 && daemon !== void 0 && caller.principalId === daemon.principalId && caller.organizationId === daemon.organizationId && caller.credentialFingerprint === daemon.credentialFingerprint;
+}
+
+// src/daemon/protocol.ts
+var DAEMON_JSON_REQUEST_MAX_BYTES = 64 * 1024;
+var DAEMON_JSON_RESPONSE_MAX_BYTES = 8 * 1024 * 1024;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseDaemonResponseEnvelope(value) {
+  if (!isRecord(value)) return void 0;
+  if (!(typeof value.id === "number" && Number.isSafeInteger(value.id) && value.id >= 0)) {
+    return void 0;
+  }
+  if (typeof value.ok !== "boolean") return void 0;
+  if (value.error !== void 0 && typeof value.error !== "string") return void 0;
+  return {
+    id: value.id,
+    ok: value.ok,
+    ...value.result === void 0 ? {} : { result: value.result },
+    ...value.error === void 0 ? {} : { error: value.error }
+  };
+}
+
+// src/daemon/client.ts
+var SOCK_PATH = join(primConfigDirectory(), "sock");
+var DEFAULT_TIMEOUT_MS = 250;
+var nextRequestId = 1;
+function daemonRequest(method, params = {}, opts = {}) {
+  const id = nextRequestId++;
+  const caller = resolveDaemonPrincipal();
+  const request = {
+    id,
+    method,
+    params,
+    ...caller ? { caller } : {}
+  };
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  return new Promise((resolve) => {
+    let settled = false;
+    let socket;
+    let buffer = Buffer.alloc(0);
+    const settle = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (socket) {
+        try {
+          socket.destroy();
+        } catch {
+        }
+      }
+      resolve(value);
+    };
+    const timer = setTimeout(() => settle(null), timeoutMs);
+    timer.unref();
+    try {
+      socket = createConnection(SOCK_PATH);
+    } catch {
+      clearTimeout(timer);
+      settle(null);
+      return;
+    }
+    socket.on("error", () => {
+      clearTimeout(timer);
+      settle(null);
+    });
+    socket.on("connect", () => {
+      try {
+        socket?.write(`${JSON.stringify(request)}
+`);
+      } catch {
+        clearTimeout(timer);
+        settle(null);
+      }
+    });
+    socket.on("data", (chunk) => {
+      buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
+      if (buffer.length > DAEMON_JSON_RESPONSE_MAX_BYTES) {
+        clearTimeout(timer);
+        settle(null);
+        return;
+      }
+      const newlineIdx = buffer.indexOf(10);
+      if (newlineIdx === -1) {
+        return;
+      }
+      const line = buffer.subarray(0, newlineIdx).toString("utf8");
+      try {
+        const res = parseDaemonResponseEnvelope(JSON.parse(line));
+        if (!res || res.id !== id) {
+          clearTimeout(timer);
+          settle(null);
+          return;
+        }
+        clearTimeout(timer);
+        settle(res.ok && res.result !== void 0 ? res.result : null);
+      } catch {
+        clearTimeout(timer);
+        settle(null);
+      }
+    });
+    socket.on("end", () => {
+      if (!settled) {
+        clearTimeout(timer);
+        settle(null);
+      }
+    });
+  });
+}
+async function daemonIsLive(timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const result = await daemonRequest("ping", {}, { timeoutMs });
+  return result?.pong === true;
+}
+
+export {
+  resolveDaemonPrincipal,
+  daemonPrincipalsMatch,
+  daemonRequest,
+  daemonIsLive
+};

package/dist/chunk-EZXEWFDG.js

@@ -0,0 +1,210 @@
+// src/lib/workspace-id.ts
+import { execFileSync } from "child_process";
+import { randomUUID } from "crypto";
+import {
+  constants,
+  chmodSync,
+  closeSync,
+  fchmodSync,
+  fsyncSync,
+  linkSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { dirname, isAbsolute, join, resolve } from "path";
+var WORKSPACE_ID_RELATIVE_PATH = join("prim", "workspace-id");
+var MAX_ANCESTORS = 64;
+var MAX_GIT_FILE_BYTES = 4096;
+var MAX_ID_FILE_BYTES = 128;
+var GIT_FALLBACK_TIMEOUT_MS = 250;
+var RACE_READ_ATTEMPTS = 5;
+var RACE_READ_DELAY_MS = 5;
+var CANONICAL_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+var raceDelay = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+function isCanonicalWorkspaceId(value) {
+  return CANONICAL_UUID.test(value);
+}
+function inspectWorkspaceId(cwd = process.cwd()) {
+  const resolved = resolveWorkspaceIdPath(cwd);
+  if (resolved.status !== "resolved") return resolved;
+  return inspectPath(resolved.path);
+}
+function getOrCreateWorkspaceId(cwd = process.cwd()) {
+  const inspection = inspectWorkspaceId(cwd);
+  if (inspection.status !== "missing") return inspection;
+  return createWorkspaceId(inspection.path);
+}
+function resolveWorkspaceIdPath(cwd) {
+  if (!process.env.GIT_DIR && !process.env.GIT_WORK_TREE) {
+    const fromFilesystem = resolveFromFilesystem(cwd);
+    if (fromFilesystem) return { status: "resolved", path: fromFilesystem };
+  }
+  try {
+    const output = execFileSync(
+      "git",
+      ["rev-parse", "--is-inside-work-tree", "--git-path", WORKSPACE_ID_RELATIVE_PATH],
+      {
+        cwd,
+        encoding: "utf8",
+        maxBuffer: 4096,
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: GIT_FALLBACK_TIMEOUT_MS,
+        windowsHide: true
+      }
+    );
+    const [insideWorktree, gitPath, ...extra] = output.trim().split(/\r?\n/);
+    if (insideWorktree !== "true" || !gitPath || extra.length > 0 || gitPath.includes("\0")) {
+      return { status: "not_git" };
+    }
+    return {
+      status: "resolved",
+      path: isAbsolute(gitPath) ? resolve(gitPath) : resolve(cwd, gitPath)
+    };
+  } catch (error) {
+    const code = errorCode(error);
+    if (code === "ETIMEDOUT" || code === "EACCES" || code === "EPERM") {
+      return { status: "unavailable", operation: "resolve", errorCode: code };
+    }
+    return { status: "not_git" };
+  }
+}
+function resolveFromFilesystem(cwd) {
+  let current = resolve(cwd);
+  for (let depth = 0; depth < MAX_ANCESTORS; depth += 1) {
+    const dotGit = join(current, ".git");
+    try {
+      const stat = lstatSync(dotGit);
+      if (stat.isDirectory() && isGitDirectory(dotGit)) {
+        return join(dotGit, WORKSPACE_ID_RELATIVE_PATH);
+      }
+      if (stat.isFile() && stat.size <= MAX_GIT_FILE_BYTES) {
+        const contents = readFileSync(dotGit, "utf8");
+        const match = /^gitdir: (.+?)(?:\r?\n)?$/.exec(contents);
+        if (match?.[1]) {
+          const gitDirectory = isAbsolute(match[1]) ? resolve(match[1]) : resolve(current, match[1]);
+          if (isGitDirectory(gitDirectory)) {
+            return join(gitDirectory, WORKSPACE_ID_RELATIVE_PATH);
+          }
+        }
+      }
+      return null;
+    } catch (error) {
+      const code = errorCode(error);
+      if (code !== "ENOENT" && code !== "ENOTDIR") {
+        return null;
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+function isGitDirectory(path) {
+  try {
+    return statSync(join(path, "HEAD")).isFile();
+  } catch {
+    return false;
+  }
+}
+function inspectPath(path) {
+  let stat;
+  try {
+    stat = lstatSync(path);
+  } catch (error) {
+    const code = errorCode(error);
+    if (code === "ENOENT" || code === "ENOTDIR") return { status: "missing", path };
+    return { status: "unavailable", path, operation: "read", errorCode: code };
+  }
+  if (!stat.isFile()) return { status: "corrupt", path, reason: "not_file" };
+  if (stat.size > MAX_ID_FILE_BYTES) {
+    return { status: "corrupt", path, reason: "invalid_content" };
+  }
+  try {
+    const contents = readFileSync(path, "utf8");
+    const workspaceId = contents.endsWith("\n") ? contents.slice(0, -1) : contents;
+    if ((contents === workspaceId || contents === `${workspaceId}
+`) && isCanonicalWorkspaceId(workspaceId)) {
+      return { status: "ready", workspaceId, path, created: false };
+    }
+    return { status: "corrupt", path, reason: "invalid_content" };
+  } catch (error) {
+    return {
+      status: "unavailable",
+      path,
+      operation: "read",
+      errorCode: errorCode(error)
+    };
+  }
+}
+function createWorkspaceId(path) {
+  const parent = dirname(path);
+  const workspaceId = randomUUID();
+  const temporaryPath = join(parent, `.workspace-id-${process.pid}-${randomUUID()}.tmp`);
+  let temporaryCreated = false;
+  let publishing = false;
+  try {
+    mkdirSync(parent, { recursive: true, mode: 448 });
+    chmodSync(parent, 448);
+    const fd = openSync(
+      temporaryPath,
+      constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY,
+      384
+    );
+    temporaryCreated = true;
+    try {
+      writeFileSync(fd, `${workspaceId}
+`, "utf8");
+      fchmodSync(fd, 384);
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    publishing = true;
+    linkSync(temporaryPath, path);
+    return { status: "ready", workspaceId, path, created: true };
+  } catch (error) {
+    if (publishing && errorCode(error) === "EEXIST") return inspectAfterRace(path);
+    return {
+      status: "unavailable",
+      path,
+      operation: "create",
+      errorCode: errorCode(error)
+    };
+  } finally {
+    if (temporaryCreated) {
+      try {
+        unlinkSync(temporaryPath);
+      } catch {
+      }
+    }
+  }
+}
+function inspectAfterRace(path) {
+  let result = { status: "missing", path };
+  for (let attempt = 0; attempt < RACE_READ_ATTEMPTS; attempt += 1) {
+    result = inspectPath(path);
+    if (result.status === "ready") return result;
+    if (attempt + 1 < RACE_READ_ATTEMPTS) {
+      Atomics.wait(raceDelay, 0, 0, RACE_READ_DELAY_MS);
+    }
+  }
+  if (result.status === "missing") {
+    return { status: "unavailable", path, operation: "create", errorCode: "EEXIST" };
+  }
+  return result;
+}
+function errorCode(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) return void 0;
+  return typeof error.code === "string" ? error.code : void 0;
+}
+
+export {
+  isCanonicalWorkspaceId,
+  getOrCreateWorkspaceId
+};

package/dist/chunk-FI3LIRCB.js

@@ -0,0 +1,262 @@
+import {
+  boundedHealthError
+} from "./chunk-LEMX3IOG.js";
+import {
+  terminalSafeLine
+} from "./chunk-Z7YPFWAZ.js";
+
+// src/hooks/redact.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+import { Worker } from "worker_threads";
+var USER_HOME_RULES = [
+  {
+    pattern: /\/Users\/[^/\\\s"'`]+/g,
+    reason: "user-home-path",
+    replacement: "/Users/__redacted_user__"
+  },
+  {
+    pattern: /\/home\/[^/\\\s"'`]+/g,
+    reason: "user-home-path",
+    replacement: "/home/__redacted_user__"
+  },
+  {
+    pattern: /([A-Za-z]:\\Users\\)[^/\\\s"'`]+/gi,
+    reason: "user-home-path",
+    replacement: "$1__redacted_user__"
+  },
+  {
+    pattern: /\/root(?=\/|$)/g,
+    reason: "user-home-path",
+    replacement: "/__redacted_user__"
+  }
+];
+var DEFAULT_RULES = [
+  { pattern: /Bearer\s+[A-Za-z0-9._~+/=-]+/gi, reason: "bearer-token" },
+  {
+    pattern: /\bsk-(?:(?:ant|proj)-)?[A-Za-z0-9_-]{16,}(?![A-Za-z0-9_-])/g,
+    reason: "sk-api-key"
+  },
+  {
+    pattern: /-----BEGIN [A-Z ]+PRIVATE KEY-----[\s\S]+?-----END [A-Z ]+PRIVATE KEY-----/g,
+    reason: "private-key"
+  },
+  { pattern: /xox[abprs]-[A-Za-z0-9-]{10,}/g, reason: "slack-token" },
+  {
+    pattern: /\b(?:gh[pousr]_[A-Za-z0-9]{36,}|github_pat_[A-Za-z0-9_]{50,})\b/g,
+    reason: "github-pat"
+  },
+  { pattern: /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g, reason: "aws-access-key" },
+  {
+    pattern: /\bAWS_(?:SECRET_ACCESS_KEY|SESSION_TOKEN)"?\s*[:=]\s*["']?[A-Za-z0-9/+=]{20,}["']?/gi,
+    reason: "aws-secret"
+  },
+  { pattern: /\bAIza[0-9A-Za-z_-]{35}(?![0-9A-Za-z_-])/g, reason: "gcp-api-key" },
+  {
+    pattern: /\bya29\.[0-9A-Za-z_-]{20,}(?![0-9A-Za-z_-])/g,
+    reason: "gcp-oauth-token"
+  },
+  {
+    pattern: /\beyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*(?![A-Za-z0-9_-])/g,
+    reason: "jwt"
+  },
+  { pattern: /\bBasic\s+[A-Za-z0-9+/]+={0,2}/gi, reason: "basic-auth" },
+  { pattern: /\bhttps?:\/\/[^/\s:@]+:[^/\s@]+@/gi, reason: "basic-auth" },
+  ...USER_HOME_RULES
+];
+var MAX_SCRUB_LEN = 256e3;
+var MAX_WORKSPACE_CONFIG_BYTES = 64 * 1024;
+var MAX_WORKSPACE_RULES = 32;
+var MAX_WORKSPACE_PATTERN_LENGTH = 512;
+var MAX_WORKSPACE_REASON_LENGTH = 64;
+var WORKSPACE_RULE_TIMEOUT_MS = 250;
+var WORKSPACE_FILE = ".prim/redaction.json";
+var SAFE_REASON_RE = /^[A-Za-z0-9][A-Za-z0-9_-]*$/u;
+var SAFE_WORKSPACE_FLAGS_RE = /^[gimsu]*$/u;
+function debugRedaction(message) {
+  writeHookDebug(`redaction: ${message}`);
+}
+function normalizedWorkspaceFlags(value) {
+  if (value !== void 0 && typeof value !== "string") return null;
+  const requested = value ?? "";
+  if (!SAFE_WORKSPACE_FLAGS_RE.test(requested)) return null;
+  return [...new Set(`g${requested}`)].sort().join("");
+}
+function loadWorkspaceRules(cwd) {
+  const path = join(cwd, WORKSPACE_FILE);
+  if (!existsSync(path)) return [];
+  let cfg;
+  try {
+    if (statSync(path).size > MAX_WORKSPACE_CONFIG_BYTES) {
+      debugRedaction(`ignoring oversized ${WORKSPACE_FILE}`);
+      return [];
+    }
+    cfg = JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    debugRedaction(`ignoring unparseable ${WORKSPACE_FILE}`);
+    return [];
+  }
+  if (!Array.isArray(cfg.rules)) return [];
+  const compiled = [];
+  for (const candidate of cfg.rules.slice(0, MAX_WORKSPACE_RULES)) {
+    if (!candidate || typeof candidate !== "object") continue;
+    const { pattern, reason } = candidate;
+    const flags = normalizedWorkspaceFlags(candidate.flags);
+    if (typeof pattern !== "string" || pattern.length === 0 || pattern.length > MAX_WORKSPACE_PATTERN_LENGTH || typeof reason !== "string" || reason.length === 0 || reason.length > MAX_WORKSPACE_REASON_LENGTH || !SAFE_REASON_RE.test(reason) || flags === null) {
+      debugRedaction("skipping invalid workspace rule metadata");
+      continue;
+    }
+    try {
+      compiled.push({ pattern: new RegExp(pattern, flags), reason });
+    } catch {
+      debugRedaction(`skipping invalid workspace rule ${reason}`);
+    }
+  }
+  return compiled;
+}
+function applyRules(input, rules) {
+  if (input.length > MAX_SCRUB_LEN) return "<REDACTED:oversized>";
+  let out = input;
+  for (const rule of rules) {
+    out = out.replace(rule.pattern, rule.replacement ?? `<REDACTED:${rule.reason}>`);
+  }
+  return out;
+}
+var REDACTED_OBJECT_KEY = "<REDACTED:object-key>";
+function redactedObjectKey(input, transform) {
+  return transform(input) === input ? input : REDACTED_OBJECT_KEY;
+}
+function uniqueObjectKey(output, key) {
+  let candidate = key;
+  let suffix = 2;
+  while (Object.hasOwn(output, candidate)) candidate = `${key}_${suffix++}`;
+  return candidate;
+}
+function mapStrings(value, transform) {
+  if (typeof value === "string") return transform(value);
+  if (Array.isArray(value)) return value.map((item) => mapStrings(item, transform));
+  if (value && typeof value === "object") {
+    const out = /* @__PURE__ */ Object.create(null);
+    for (const [key, item] of Object.entries(value)) {
+      out[uniqueObjectKey(out, redactedObjectKey(key, transform))] = mapStrings(item, transform);
+    }
+    return out;
+  }
+  return value;
+}
+function scrub(value, rules = DEFAULT_RULES) {
+  return mapStrings(value, (input) => applyRules(input, rules));
+}
+function debugDetail(value) {
+  try {
+    return String(value instanceof Error ? value.message : value);
+  } catch {
+    return "unprintable detail";
+  }
+}
+function writeHookDebug(context, ...details) {
+  if (!process.env.PRIM_HOOK_DEBUG) return;
+  const raw = details.length > 0 ? `${context}: ${details.map(debugDetail).join(": ")}` : context;
+  const normalized = terminalSafeLine(raw);
+  const message = boundedHealthError(scrub(normalized, DEFAULT_RULES)) ?? context;
+  process.stderr.write(`[prim-hook] ${message === `${context}:` ? context : message}
+`);
+}
+function redactEveryString(value, reason) {
+  return mapStrings(value, () => `<REDACTED:${reason}>`);
+}
+var WORKSPACE_REDACTION_WORKER = String.raw`
+  const { parentPort, workerData } = require("node:worker_threads");
+  const REDACTED_OBJECT_KEY = "<REDACTED:object-key>";
+  const rules = workerData.rules.map((rule) => ({
+    pattern: new RegExp(rule.source, rule.flags),
+    reason: rule.reason,
+  }));
+  function redact(input) {
+      let output = input;
+      for (const rule of rules) {
+        output = output.replace(rule.pattern, "<REDACTED:" + rule.reason + ">");
+      }
+      return output;
+  }
+  function objectKey(input) {
+    return redact(input) === input ? input : REDACTED_OBJECT_KEY;
+  }
+  function uniqueKey(output, key) {
+    let candidate = key;
+    let suffix = 2;
+    while (Object.hasOwn(output, candidate)) candidate = key + "_" + suffix++;
+    return candidate;
+  }
+  function walk(value) {
+    if (typeof value === "string") {
+      return redact(value);
+    }
+    if (Array.isArray(value)) return value.map(walk);
+    if (value && typeof value === "object") {
+      const output = Object.create(null);
+      for (const [key, item] of Object.entries(value)) {
+        output[uniqueKey(output, objectKey(key))] = walk(item);
+      }
+      return output;
+    }
+    return value;
+  }
+  parentPort.postMessage(walk(workerData.value));
+`;
+function applyWorkspaceRules(value, rules) {
+  const serialized = rules.map(({ pattern, reason }) => ({
+    source: pattern.source,
+    flags: pattern.flags,
+    reason
+  }));
+  return new Promise((resolve) => {
+    let worker;
+    try {
+      worker = new Worker(WORKSPACE_REDACTION_WORKER, {
+        eval: true,
+        workerData: { value, rules: serialized }
+      });
+    } catch {
+      resolve(redactEveryString(value, "workspace-rule-failed"));
+      return;
+    }
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      void worker.terminate();
+      resolve(result);
+    };
+    const failClosed = () => finish(redactEveryString(value, "workspace-rule-failed"));
+    const timer = setTimeout(failClosed, WORKSPACE_RULE_TIMEOUT_MS);
+    worker.once("message", finish);
+    worker.once("error", failClosed);
+    worker.once("exit", (code) => {
+      if (code !== 0) failClosed();
+    });
+  });
+}
+async function scrubFromCwd(value, cwd) {
+  const defaultScrubbed = scrub(value, DEFAULT_RULES);
+  const workspaceRules = loadWorkspaceRules(cwd);
+  return workspaceRules.length === 0 ? defaultScrubbed : await applyWorkspaceRules(defaultScrubbed, workspaceRules);
+}
+function scrubEnvironmentPaths(environment) {
+  const scrubPath = (value) => value === void 0 ? void 0 : applyRules(value, USER_HOME_RULES);
+  return {
+    ...environment,
+    cwd: scrubPath(environment.cwd) ?? environment.cwd,
+    ...environment.repoRoot === void 0 ? {} : { repoRoot: scrubPath(environment.repoRoot) },
+    ...environment.gitRoot === void 0 ? {} : { gitRoot: scrubPath(environment.gitRoot) }
+  };
+}
+
+export {
+  DEFAULT_RULES,
+  scrub,
+  writeHookDebug,
+  scrubFromCwd,
+  scrubEnvironmentPaths
+};

package/dist/chunk-LEMX3IOG.js

@@ -0,0 +1,79 @@
+import {
+  terminalSafeLine
+} from "./chunk-Z7YPFWAZ.js";
+
+// src/lib/ansi.ts
+var ANSI_CODES = {
+  yellow: "\x1B[33m",
+  magenta: "\x1B[35m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  // 256-color approximation of the orange trigger marker (xterm 208).
+  orange: "\x1B[38;5;208m",
+  gray: "\x1B[90m"
+};
+var ANSI_RESET = "\x1B[0m";
+var ANSI_DIM = "\x1B[2m";
+var ANSI_BOLD = "\x1B[1m";
+function supportsColor() {
+  if (process.env.NO_COLOR !== void 0 && process.env.NO_COLOR !== "") {
+    return false;
+  }
+  return process.stderr.isTTY === true;
+}
+function color(text, c) {
+  if (!supportsColor()) {
+    return text;
+  }
+  return `${ANSI_CODES[c]}${text}${ANSI_RESET}`;
+}
+function dim(text) {
+  if (!supportsColor()) {
+    return text;
+  }
+  return `${ANSI_DIM}${text}${ANSI_RESET}`;
+}
+function bold(text) {
+  if (!supportsColor()) {
+    return text;
+  }
+  return `${ANSI_BOLD}${text}${ANSI_RESET}`;
+}
+var AREA_COLORS = {
+  auth: "yellow",
+  data: "magenta",
+  mobile: "blue",
+  infra: "cyan",
+  ui: "green",
+  billing: "orange",
+  api: "blue",
+  docs: "gray",
+  testing: "gray"
+};
+function colorForArea(area) {
+  if (!area) {
+    return "gray";
+  }
+  return AREA_COLORS[area] ?? "gray";
+}
+var MAX_HEALTH_ERROR_LENGTH = 240;
+function boundedHealthError(value) {
+  if (!value) return void 0;
+  const clean = terminalSafeLine(value);
+  if (!clean) return void 0;
+  return clean.length <= MAX_HEALTH_ERROR_LENGTH ? clean : `${clean.slice(0, MAX_HEALTH_ERROR_LENGTH - 1)}\u2026`;
+}
+function stripAnsi(text) {
+  return text.replace(/\u001b\[[0-9;]*m/g, "");
+}
+
+export {
+  color,
+  dim,
+  bold,
+  colorForArea,
+  boundedHealthError,
+  stripAnsi
+};