agent-companion 0.1.1 → 0.1.3

package/bridge/directIngest.mjs

@@ -290,6 +290,7 @@ function parseCodexFile(file, nowMs) {
     agentType: "CODEX",
     title,
     repo,
+    workspacePath: cwd || "",
     branch: "main",
     state,
     lastUpdated: effectiveLastUpdated,
@@ -461,6 +462,7 @@ function parseClaudeFile(file, nowMs) {
     agentType: "CLAUDE",
     title,
     repo,
+    workspacePath: cwd || "",
     branch,
     state,
     lastUpdated: effectiveLastUpdated,
@@ -608,6 +610,8 @@ function isNoisePrompt(text) {
   if (raw.includes("Filesystem sandboxing defines")) return true;
   if (raw.includes("AGENT_COMPANION_PERSIST_SERVER_HINT_V1")) return true;
   if (raw.includes("[Request interrupted by user for tool use]")) return true;
+  if (/^\[background-service\]/i.test(raw.trim())) return true;
+  if (/"service"\s*:\s*\{/.test(raw) && /"localhostUrl"\s*:/.test(raw)) return true;
   if (raw === "Answer questions?") return true;
   return false;
 }

package/bridge/server.mjs

@@ -151,6 +151,11 @@ function normalizeState(value) {
   return allowed.includes(value) ? value : "RUNNING";
 }
 
+function isDirectSessionId(value) {
+  const id = safeTrimmedText(value, 160);
+  return id.startsWith("codex:") || id.startsWith("claude:");
+}
+
 function normalizeCategory(value) {
   const allowed = ["INFO", "ACTION", "INPUT", "ERROR"];
   return allowed.includes(value) ? value : "INFO";
@@ -479,6 +484,7 @@ function upsertSessionThread(input) {
 function syncSessionThreadFromSession(session, input = {}) {
   if (!session?.id) return null;
   const existingThread = findSessionThread(session.id);
+  const inferredIdentity = inferThreadIdentityFromSessionId(session.id);
   const fallbackLookupKey = buildSessionThreadLookupKey({
     agentType: session.agentType,
     workspacePath: input.workspacePath || existingThread?.workspacePath || "",
@@ -504,10 +510,15 @@ function syncSessionThreadFromSession(session, input = {}) {
       input.lastMessageAt,
       safeNumber(existingThread?.lastMessageAt, safeNumber(session.lastUpdated, 0))
     ),
-    codexThreadId: safeTrimmedText(input.codexThreadId, 120) || existingThread?.codexThreadId || null,
+    codexThreadId:
+      safeTrimmedText(input.codexThreadId, 120) ||
+      existingThread?.codexThreadId ||
+      inferredIdentity.codexThreadId ||
+      null,
     claudeSessionId:
       safeTrimmedText(input.claudeSessionId, 120).toLowerCase() ||
       safeTrimmedText(existingThread?.claudeSessionId, 120).toLowerCase() ||
+      inferredIdentity.claudeSessionId ||
       null
   });
 }
@@ -627,17 +638,214 @@ function extractClaudeSessionIdFromRun(run) {
   return "";
 }
 
+function normalizeClaudeSessionId(value) {
+  const candidate = safeTrimmedText(value, 120).toLowerCase();
+  if (!candidate) return "";
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(candidate)) {
+    return candidate;
+  }
+  return "";
+}
+
+function inferThreadIdentityFromSessionId(sessionId) {
+  const id = safeTrimmedText(sessionId, 160);
+  if (!id) {
+    return { codexThreadId: null, claudeSessionId: null };
+  }
+
+  if (id.startsWith("codex:")) {
+    const codexThreadId = safeTrimmedText(id.slice("codex:".length), 120).toLowerCase();
+    return {
+      codexThreadId: codexThreadId || null,
+      claudeSessionId: null
+    };
+  }
+
+  if (id.startsWith("claude:")) {
+    const claudeSessionId = normalizeClaudeSessionId(id.slice("claude:".length));
+    return {
+      codexThreadId: null,
+      claudeSessionId: claudeSessionId || null
+    };
+  }
+
+  return { codexThreadId: null, claudeSessionId: null };
+}
+
+function getLauncherRunUpdatedAt(run) {
+  return Math.max(
+    safeNumber(run?.endedAt, 0),
+    safeNumber(run?.startedAt, 0),
+    safeNumber(run?.createdAt, 0)
+  );
+}
+
+function resolveCanonicalSessionIdForDirectSession(sessionId) {
+  const directSessionId = safeTrimmedText(sessionId, 160);
+  if (!isDirectSessionId(directSessionId)) return directSessionId;
+
+  if (directSessionId.startsWith("codex:")) {
+    const threadId = directSessionId.slice("codex:".length).trim().toLowerCase();
+    if (!threadId) return directSessionId;
+
+    const mappedRun = [...launcherRuns.values()]
+      .slice()
+      .sort((a, b) => getLauncherRunUpdatedAt(b) - getLauncherRunUpdatedAt(a))
+      .find((run) => !isDirectSessionId(run?.sessionId) && extractCodexThreadIdFromRun(run) === threadId);
+    if (mappedRun?.sessionId) return mappedRun.sessionId;
+
+    const mappedThread = (Array.isArray(state.sessionThreads) ? state.sessionThreads : [])
+      .slice()
+      .sort((a, b) => safeNumber(b.updatedAt, 0) - safeNumber(a.updatedAt, 0))
+      .find(
+        (thread) =>
+          !isDirectSessionId(thread?.id) &&
+          safeTrimmedText(thread?.codexThreadId, 120).toLowerCase() === threadId
+      );
+    if (mappedThread?.id) return mappedThread.id;
+
+    return directSessionId;
+  }
+
+  const claudeSessionId = normalizeClaudeSessionId(directSessionId.slice("claude:".length));
+  if (!claudeSessionId) return directSessionId;
+
+  const mappedRun = [...launcherRuns.values()]
+    .slice()
+    .sort((a, b) => getLauncherRunUpdatedAt(b) - getLauncherRunUpdatedAt(a))
+    .find((run) => !isDirectSessionId(run?.sessionId) && extractClaudeSessionIdFromRun(run) === claudeSessionId);
+  if (mappedRun?.sessionId) return mappedRun.sessionId;
+
+  const mappedThread = (Array.isArray(state.sessionThreads) ? state.sessionThreads : [])
+    .slice()
+    .sort((a, b) => safeNumber(b.updatedAt, 0) - safeNumber(a.updatedAt, 0))
+    .find(
+      (thread) =>
+        !isDirectSessionId(thread?.id) &&
+        normalizeClaudeSessionId(thread?.claudeSessionId) === claudeSessionId
+    );
+  if (mappedThread?.id) return mappedThread.id;
+
+  return directSessionId;
+}
+
+function rewriteDirectScopedId(id, originalSessionId, canonicalSessionId) {
+  const text = safeTrimmedText(id, 240);
+  if (!text || !originalSessionId || !canonicalSessionId || originalSessionId === canonicalSessionId) {
+    return text || id;
+  }
+
+  if (text === `pending:${originalSessionId}`) {
+    return `pending:${canonicalSessionId}`;
+  }
+  if (text === `event:${originalSessionId}`) {
+    return `event:${canonicalSessionId}`;
+  }
+
+  const directPrefix = `direct:${originalSessionId}:`;
+  if (text.startsWith(directPrefix)) {
+    return `direct:${canonicalSessionId}:${text.slice(directPrefix.length)}`;
+  }
+
+  return text;
+}
+
+function canonicalizeDirectSnapshot(snapshot) {
+  if (!snapshot || typeof snapshot !== "object") return snapshot;
+
+  const sessionIdMap = new Map();
+  const sourceDirectSessionIds = new Set();
+
+  const remapSessionId = (value) => {
+    const sessionId = safeTrimmedText(value, 160);
+    if (!isDirectSessionId(sessionId)) return sessionId;
+    sourceDirectSessionIds.add(sessionId);
+
+    const existing = sessionIdMap.get(sessionId);
+    if (existing) return existing;
+
+    const canonical = resolveCanonicalSessionIdForDirectSession(sessionId) || sessionId;
+    sessionIdMap.set(sessionId, canonical);
+    return canonical;
+  };
+
+  const sessions = (Array.isArray(snapshot.sessions) ? snapshot.sessions : []).map((item) => {
+    const originalSessionId = safeTrimmedText(item?.id, 160);
+    const canonicalSessionId = remapSessionId(originalSessionId);
+    if (!originalSessionId || !canonicalSessionId || canonicalSessionId === originalSessionId) {
+      return item;
+    }
+    return { ...item, id: canonicalSessionId };
+  });
+
+  const pendingInputs = (Array.isArray(snapshot.pendingInputs) ? snapshot.pendingInputs : []).map((item) => {
+    const originalSessionId = safeTrimmedText(item?.sessionId, 160);
+    const canonicalSessionId = remapSessionId(originalSessionId);
+    if (!originalSessionId || !canonicalSessionId || canonicalSessionId === originalSessionId) {
+      return item;
+    }
+    return {
+      ...item,
+      id: rewriteDirectScopedId(item?.id, originalSessionId, canonicalSessionId),
+      sessionId: canonicalSessionId
+    };
+  });
+
+  const events = (Array.isArray(snapshot.events) ? snapshot.events : []).map((item) => {
+    const originalSessionId = safeTrimmedText(item?.sessionId, 160);
+    const canonicalSessionId = remapSessionId(originalSessionId);
+    if (!originalSessionId || !canonicalSessionId || canonicalSessionId === originalSessionId) {
+      return item;
+    }
+    return {
+      ...item,
+      id: rewriteDirectScopedId(item?.id, originalSessionId, canonicalSessionId),
+      sessionId: canonicalSessionId
+    };
+  });
+
+  const chatTurns = (Array.isArray(snapshot.chatTurns) ? snapshot.chatTurns : []).map((item) => {
+    const originalSessionId = safeTrimmedText(item?.sessionId, 160);
+    const canonicalSessionId = remapSessionId(originalSessionId);
+    if (!originalSessionId || !canonicalSessionId || canonicalSessionId === originalSessionId) {
+      return item;
+    }
+    return {
+      ...item,
+      id: rewriteDirectScopedId(item?.id, originalSessionId, canonicalSessionId),
+      sessionId: canonicalSessionId
+    };
+  });
+
+  return {
+    ...snapshot,
+    sessions,
+    pendingInputs,
+    events,
+    chatTurns,
+    directSourceSessionIds: [...sourceDirectSessionIds]
+  };
+}
+
 function buildContinueCommandFromThread(thread, prompt) {
   const safePrompt = safeTrimmedText(prompt, 1500);
   if (!safePrompt || !thread) return null;
 
   if (thread.agentType === "CODEX") {
-    const threadId = safeTrimmedText(thread.codexThreadId, 120).toLowerCase();
+    const threadId =
+      safeTrimmedText(thread.codexThreadId, 120).toLowerCase() ||
+      (safeTrimmedText(thread.id, 160).startsWith("codex:")
+        ? safeTrimmedText(thread.id.slice("codex:".length), 120).toLowerCase()
+        : "");
     if (!threadId) return null;
     return ["codex", "exec", "resume", threadId, safePrompt];
   }
 
-  const claudeSessionId = safeTrimmedText(thread.claudeSessionId, 120).toLowerCase();
+  const claudeSessionId =
+    safeTrimmedText(thread.claudeSessionId, 120).toLowerCase() ||
+    (safeTrimmedText(thread.id, 160).startsWith("claude:")
+      ? normalizeClaudeSessionId(thread.id.slice("claude:".length))
+      : "");
   if (!claudeSessionId) return null;
   return ["claude", "--resume", claudeSessionId, "-p", safePrompt, "--output-format", "stream-json"];
 }
@@ -655,14 +863,12 @@ function resolveContinueCommandForSession(sessionId, prompt) {
 }
 
 function validateSessionReuse(input) {
-  const sessionId = safeTrimmedText(input?.sessionId, 160);
-  if (!sessionId) {
+  const requestedSessionId = safeTrimmedText(input?.sessionId, 160);
+  if (!requestedSessionId) {
     return { ok: true, sessionId: "", continueCommand: null };
   }
 
-  if (sessionId.startsWith("codex:") || sessionId.startsWith("claude:")) {
-    return { ok: false, error: "direct local sessions cannot be reused from launcher" };
-  }
+  const sessionId = resolveCanonicalSessionIdForDirectSession(requestedSessionId) || requestedSessionId;
 
   const session = findSession(sessionId);
   const thread = findSessionThread(sessionId);
@@ -729,9 +935,11 @@ function writeToRunStdin(run, message) {
 
 function buildEphemeralSessionThread(session) {
   if (!session?.id) return null;
+  const workspacePath = safeTrimmedText(session?.workspacePath, 500) || "";
+  const inferredIdentity = inferThreadIdentityFromSessionId(session.id);
   const lookupKey = buildSessionThreadLookupKey({
     agentType: session.agentType,
-    workspacePath: "",
+    workspacePath,
     repo: session.repo,
     title: session.title
   });
@@ -740,7 +948,7 @@ function buildEphemeralSessionThread(session) {
     key: lookupKey,
     lookupKey,
     agentType: session.agentType,
-    workspacePath: "",
+    workspacePath,
     repo: session.repo,
     branch: session.branch,
     title: session.title,
@@ -749,7 +957,9 @@ function buildEphemeralSessionThread(session) {
     updatedAt: safeNumber(session.lastUpdated, Date.now()),
     lastRunId: null,
     runCount: 0,
-    lastMessageAt: safeNumber(session.lastUpdated, 0)
+    lastMessageAt: safeNumber(session.lastUpdated, 0),
+    codexThreadId: inferredIdentity.codexThreadId,
+    claudeSessionId: inferredIdentity.claudeSessionId
   };
 }
 
@@ -1937,21 +2147,28 @@ function stopManagedService(service, signalInput) {
 function mergeDirectSnapshot(snapshot) {
   if (!snapshot || typeof snapshot !== "object") return;
 
+  snapshot = canonicalizeDirectSnapshot(snapshot);
+
   const incomingDirectSessionIds = new Set(
     (Array.isArray(snapshot.sessions) ? snapshot.sessions : [])
       .map((item) => item?.id)
-      .filter((id) => typeof id === "string")
+      .filter((id) => typeof id === "string" && isDirectSessionId(id))
+  );
+  const incomingDirectSourceSessionIds = new Set(
+    (Array.isArray(snapshot.directSourceSessionIds) ? snapshot.directSourceSessionIds : [])
+      .map((item) => safeTrimmedText(item, 160))
+      .filter(Boolean)
   );
 
-  if (incomingDirectSessionIds.size > 0) {
+  if (incomingDirectSessionIds.size > 0 || incomingDirectSourceSessionIds.size > 0) {
     state.sessions = state.sessions.filter((item) => {
       const id = String(item?.id || "");
-      if (!id.startsWith("codex:") && !id.startsWith("claude:")) return true;
+      if (!isDirectSessionId(id)) return true;
       return incomingDirectSessionIds.has(id);
     });
     state.sessionThreads = (Array.isArray(state.sessionThreads) ? state.sessionThreads : []).filter((item) => {
       const id = String(item?.id || "");
-      if (!id.startsWith("codex:") && !id.startsWith("claude:")) return true;
+      if (!isDirectSessionId(id)) return true;
       return incomingDirectSessionIds.has(id);
     });
   }
@@ -1963,11 +2180,13 @@ function mergeDirectSnapshot(snapshot) {
     if (previous) {
       Object.assign(previous, incoming);
       syncSessionThreadFromSession(previous, {
+        workspacePath: safeTrimmedText(previous?.workspacePath, 500),
         updatedAt: safeNumber(previous.lastUpdated, Date.now())
       });
     } else {
       state.sessions.push(incoming);
       syncSessionThreadFromSession(incoming, {
+        workspacePath: safeTrimmedText(incoming?.workspacePath, 500),
         updatedAt: safeNumber(incoming.lastUpdated, Date.now())
       });
     }
@@ -2802,11 +3021,14 @@ app.post("/api/import/snapshot", (req, res) => {
   return res.json({ ok: true });
 });
 
+function refreshDirectSnapshot() {
+  withPersist(() => {
+    const snapshot = collectDirectSnapshot();
+    mergeDirectSnapshot(snapshot);
+  });
+}
+
 app.listen(PORT, () => {
-  setInterval(() => {
-    withPersist(() => {
-      const snapshot = collectDirectSnapshot();
-      mergeDirectSnapshot(snapshot);
-    });
-  }, DIRECT_SNAPSHOT_POLL_INTERVAL_MS);
+  refreshDirectSnapshot();
+  setInterval(refreshDirectSnapshot, DIRECT_SNAPSHOT_POLL_INTERVAL_MS);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-companion",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "private": false,
   "type": "module",
   "description": "Phone-to-computer companion for Codex and Claude Code.",
@@ -47,8 +47,6 @@
     "build": "tsc -b && vite build",
     "preview": "vite preview",
     "wake-proxy": "node wake-proxy/server.mjs",
-    "video:studio": "remotion studio video/index.ts",
-    "video:render": "remotion render video/index.ts AgentCompanionLaunch video-renders/agent-companion-launch.mp4",
     "prepublishOnly": "npm run build"
   },
   "bin": {
@@ -67,7 +65,6 @@
     "ws": "^8.18.3"
   },
   "devDependencies": {
-    "@remotion/cli": "^4.0.431",
     "@types/node": "^25.2.3",
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
@@ -75,10 +72,8 @@
     "@vitejs/plugin-react": "^5.1.0",
     "autoprefixer": "^10.4.24",
     "postcss": "^8.5.6",
-    "remotion": "^4.0.431",
     "tailwindcss": "^3.4.17",
     "tailwindcss-animate": "^1.0.7",
-    "tslib": "^2.8.1",
     "typescript": "^5.9.3",
     "vite": "^7.3.1",
     "vite-plugin-pwa": "^1.2.0"

package/relay/server.mjs

@@ -23,6 +23,7 @@ const RELAY_WAKE_TIMEOUT_MS = clamp(toInt(process.env.RELAY_WAKE_TIMEOUT_MS, 90_
 const RELAY_WAKE_POLL_INTERVAL_MS = clamp(toInt(process.env.RELAY_WAKE_POLL_INTERVAL_MS, 1200), 250, 10_000);
 const RELAY_WAKE_REQUEST_TIMEOUT_MS = clamp(toInt(process.env.RELAY_WAKE_REQUEST_TIMEOUT_MS, 6000), 1000, 60_000);
 const PAIRING_TTL_MS = clamp(toInt(process.env.PAIRING_TTL_MS, 10 * 60 * 1000), 30_000, 24 * 60 * 60 * 1000);
+const PAIR_CODE_LENGTH = clamp(toInt(process.env.PAIR_CODE_LENGTH, 10), 8, 16);
 const RPC_TIMEOUT_MS = clamp(toInt(process.env.RELAY_RPC_TIMEOUT_MS, 15_000), 500, 60_000);
 const PREVIEW_DEFAULT_TTL_MS = clamp(toInt(process.env.RELAY_PREVIEW_TTL_MS, 2 * 60 * 60 * 1000), 60_000, 7 * 24 * 60 * 60 * 1000);
 const PREVIEW_MAX_TTL_MS = clamp(
@@ -396,6 +397,14 @@ app.get("/api/devices/:id/launcher/runs", async (req, res) => {
   });
 });
 
+app.get("/api/devices/:id/launcher/runs/:runId", async (req, res) => {
+  const runId = encodeURIComponent(String(req.params.runId || ""));
+  return proxyToLaptopBridge(req, res, {
+    method: "GET",
+    path: `/api/launcher/runs/${runId}`
+  });
+});
+
 app.get("/api/devices/:id/launcher/services", async (req, res) => {
   const pathWithQuery = withQuery("/api/launcher/services", req.query);
   return proxyToLaptopBridge(req, res, {
@@ -1368,7 +1377,7 @@ function createPairingForLaptop(laptop) {
   }
 
   if (!code) {
-    code = `${generatePairCode()}${Math.floor(Math.random() * 10)}`;
+    code = generatePairCode();
   }
 
   const now = Date.now();
@@ -1789,7 +1798,7 @@ function parseSignedToken(token, expectedPrefix) {
 function generatePairCode() {
   const alphabet = "23456789ABCDEFGHJKMNPQRSTVWXYZ";
   let out = "";
-  for (let i = 0; i < 6; i += 1) {
+  for (let i = 0; i < PAIR_CODE_LENGTH; i += 1) {
     out += alphabet[Math.floor(Math.random() * alphabet.length)];
   }
   return out;

package/scripts/laptop-companion.mjs

@@ -43,6 +43,8 @@ let reconnectDelayMs = 1200;
 
 let bridgeChild = null;
 let bridgeStartedByCompanion = false;
+let pairingWatchTimer = null;
+let pairingNoticeShown = false;
 
 process.on("SIGINT", () => shutdown("SIGINT"));
 process.on("SIGTERM", () => shutdown("SIGTERM"));
@@ -63,6 +65,7 @@ async function main() {
 
   let registration = await getOrCreateLaptopRegistration();
   printPairingInfo(registration);
+  startPairingWatch(registration.laptopToken);
 
   while (!shuttingDown) {
     const cached = loadCompanionState();
@@ -84,6 +87,7 @@ async function main() {
     } else if (connectionResult?.authRejected) {
       registration = await getOrCreateLaptopRegistration();
       printPairingInfo(registration);
+      startPairingWatch(registration.laptopToken);
     }
 
     const waitMs = reconnectDelayMs;
@@ -275,10 +279,12 @@ async function waitForRelayAvailability() {
 }
 
 function printPairingInfo(registration) {
+  pairingNoticeShown = false;
   console.log("");
   console.log("Agent Companion computer is ready.");
   console.log(`Pairing code: ${registration.pairCode}`);
-  console.log("Enter this code in the app to pair.");
+  console.log(formatCliWarning("Open the app and enter this code. Don't share it."));
+  console.log("Keep Agent Companion running after pairing.");
   if (!quietLogs) {
     if (wakeMacAddress) {
       console.log(`Auto-wake MAC: ${wakeMacAddress}`);
@@ -292,6 +298,58 @@ function printPairingInfo(registration) {
   console.log("");
 }
 
+function startPairingWatch(laptopToken) {
+  stopPairingWatch();
+
+  const token = safeText(laptopToken, 1000);
+  if (!token || pairingNoticeShown) return;
+
+  const poll = async () => {
+    if (shuttingDown || pairingNoticeShown) return;
+
+    try {
+      const response = await fetchWithTimeout(
+        `${relayBaseUrl}/api/laptops/me`,
+        {
+          method: "GET",
+          headers: {
+            Accept: "application/json",
+            Authorization: `Bearer ${token}`
+          }
+        },
+        5000
+      );
+
+      if (response.ok) {
+        const body = await safeParseJson(response);
+        if (body?.pairedAt) {
+          pairingNoticeShown = true;
+          console.log("");
+          console.log("Device paired. Keep Agent Companion running.");
+          console.log("");
+          stopPairingWatch();
+          return;
+        }
+      }
+    } catch {
+      // ignore transient relay issues while waiting for pairing
+    }
+
+    pairingWatchTimer = setTimeout(() => {
+      void poll();
+    }, 3000);
+  };
+
+  void poll();
+}
+
+function stopPairingWatch() {
+  if (pairingWatchTimer) {
+    clearTimeout(pairingWatchTimer);
+    pairingWatchTimer = null;
+  }
+}
+
 function connectWebSocketOnce(laptopToken) {
   const wsUrl = buildLaptopWsUrl(relayBaseUrl, laptopToken);
 
@@ -330,6 +388,9 @@ function connectWebSocketOnce(laptopToken) {
           pairingExpiresAt: cached?.pairingExpiresAt || null,
           pairingUrl: cached?.pairingUrl || null
         });
+        if (!pairingNoticeShown) {
+          startPairingWatch(safeText(message.laptopToken, 1000));
+        }
       }
       if (message.type === "rpc_request" && typeof message.id === "string") {
         void handleRpcRequest(socket, message);
@@ -1079,6 +1140,7 @@ async function shutdown(signal) {
     console.log(`[companion] received ${signal}, shutting down`);
   }
   stopSnapshotLoop();
+  stopPairingWatch();
 
   if (websocket && websocket.readyState === WebSocket.OPEN) {
     websocket.close(1000, "shutdown");
@@ -1101,6 +1163,11 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function formatCliWarning(text) {
+  if (!process.stdout.isTTY) return text;
+  return `\u001b[31m${text}\u001b[0m`;
+}
+
 function isObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }