@redscope-ai/redscope 1.0.0

package/dist/chunk-y0jpkqb0.js

@@ -0,0 +1,180 @@
+// @bun
+import {
+  init_path
+} from "./chunk-y1q7rt9n.js";
+import {
+  sanitizePath
+} from "./chunk-za3k6h2h.js";
+import {
+  createBufferedWriter,
+  getClaudeConfigHomeDir,
+  getFsImplementation,
+  init_bufferedWriter,
+  init_cleanupRegistry,
+  init_debug,
+  init_envUtils,
+  init_fsOperations,
+  init_slowOperations,
+  isEnvTruthy,
+  jsonStringify,
+  logForDebugging,
+  registerCleanup
+} from "./chunk-s3hafnk3.js";
+import {
+  getOriginalCwd,
+  getSessionId,
+  init_state
+} from "./chunk-9h9k5vz3.js";
+
+// src/utils/asciicast.ts
+init_state();
+init_bufferedWriter();
+init_cleanupRegistry();
+init_debug();
+init_envUtils();
+init_fsOperations();
+init_path();
+init_slowOperations();
+import { appendFile, rename } from "fs/promises";
+import { basename, dirname, join } from "path";
+var recordingState = {
+  filePath: null,
+  timestamp: 0
+};
+function getRecordFilePath() {
+  if (recordingState.filePath !== null) {
+    return recordingState.filePath;
+  }
+  if (process.env.USER_TYPE !== "ant") {
+    return null;
+  }
+  if (!isEnvTruthy(process.env.CLAUDE_CODE_TERMINAL_RECORDING)) {
+    return null;
+  }
+  const projectsDir = join(getClaudeConfigHomeDir(), "projects");
+  const projectDir = join(projectsDir, sanitizePath(getOriginalCwd()));
+  recordingState.timestamp = Date.now();
+  recordingState.filePath = join(projectDir, `${getSessionId()}-${recordingState.timestamp}.cast`);
+  return recordingState.filePath;
+}
+function _resetRecordingStateForTesting() {
+  recordingState.filePath = null;
+  recordingState.timestamp = 0;
+}
+function getSessionRecordingPaths() {
+  const sessionId = getSessionId();
+  const projectsDir = join(getClaudeConfigHomeDir(), "projects");
+  const projectDir = join(projectsDir, sanitizePath(getOriginalCwd()));
+  try {
+    const entries = getFsImplementation().readdirSync(projectDir);
+    const names = typeof entries[0] === "string" ? entries : entries.map((e) => e.name);
+    const files = names.filter((f) => f.startsWith(sessionId) && f.endsWith(".cast")).sort();
+    return files.map((f) => join(projectDir, f));
+  } catch {
+    return [];
+  }
+}
+async function renameRecordingForSession() {
+  const oldPath = recordingState.filePath;
+  if (!oldPath || recordingState.timestamp === 0) {
+    return;
+  }
+  const projectsDir = join(getClaudeConfigHomeDir(), "projects");
+  const projectDir = join(projectsDir, sanitizePath(getOriginalCwd()));
+  const newPath = join(projectDir, `${getSessionId()}-${recordingState.timestamp}.cast`);
+  if (oldPath === newPath) {
+    return;
+  }
+  await recorder?.flush();
+  const oldName = basename(oldPath);
+  const newName = basename(newPath);
+  try {
+    await rename(oldPath, newPath);
+    recordingState.filePath = newPath;
+    logForDebugging(`[asciicast] Renamed recording: ${oldName} \u2192 ${newName}`);
+  } catch {
+    logForDebugging(`[asciicast] Failed to rename recording from ${oldName} to ${newName}`);
+  }
+}
+var recorder = null;
+function getTerminalSize() {
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+  return { cols, rows };
+}
+async function flushAsciicastRecorder() {
+  await recorder?.flush();
+}
+function installAsciicastRecorder() {
+  const filePath = getRecordFilePath();
+  if (!filePath) {
+    return;
+  }
+  const { cols, rows } = getTerminalSize();
+  const startTime = performance.now();
+  const header = jsonStringify({
+    version: 2,
+    width: cols,
+    height: rows,
+    timestamp: Math.floor(Date.now() / 1000),
+    env: {
+      SHELL: process.env.SHELL || "",
+      TERM: process.env.TERM || ""
+    }
+  });
+  try {
+    getFsImplementation().mkdirSync(dirname(filePath));
+  } catch {}
+  getFsImplementation().appendFileSync(filePath, header + `
+`, { mode: 384 });
+  let pendingWrite = Promise.resolve();
+  const writer = createBufferedWriter({
+    writeFn(content) {
+      const currentPath = recordingState.filePath;
+      if (!currentPath) {
+        return;
+      }
+      pendingWrite = pendingWrite.then(() => appendFile(currentPath, content)).catch(() => {});
+    },
+    flushIntervalMs: 500,
+    maxBufferSize: 50,
+    maxBufferBytes: 10 * 1024 * 1024
+  });
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  process.stdout.write = function(chunk, encodingOrCb, cb) {
+    const elapsed = (performance.now() - startTime) / 1000;
+    const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf-8");
+    writer.write(jsonStringify([elapsed, "o", text]) + `
+`);
+    if (typeof encodingOrCb === "function") {
+      return originalWrite(chunk, encodingOrCb);
+    }
+    return originalWrite(chunk, encodingOrCb, cb);
+  };
+  function onResize() {
+    const elapsed = (performance.now() - startTime) / 1000;
+    const { cols: newCols, rows: newRows } = getTerminalSize();
+    writer.write(jsonStringify([elapsed, "r", `${newCols}x${newRows}`]) + `
+`);
+  }
+  process.stdout.on("resize", onResize);
+  recorder = {
+    async flush() {
+      writer.flush();
+      await pendingWrite;
+    },
+    async dispose() {
+      writer.dispose();
+      await pendingWrite;
+      process.stdout.removeListener("resize", onResize);
+      process.stdout.write = originalWrite;
+    }
+  };
+  registerCleanup(async () => {
+    await recorder?.dispose();
+    recorder = null;
+  });
+  logForDebugging(`[asciicast] Recording to ${filePath}`);
+}
+
+export { getRecordFilePath, _resetRecordingStateForTesting, getSessionRecordingPaths, renameRecordingForSession, flushAsciicastRecorder, installAsciicastRecorder };

package/dist/chunk-y1q7rt9n.js

@@ -0,0 +1,102 @@
+// @bun
+import {
+  init_windowsPaths,
+  posixPathToWindowsPath
+} from "./chunk-trqrj23e.js";
+import {
+  init_sessionStoragePortable
+} from "./chunk-za3k6h2h.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-pdvg91cg.js";
+import {
+  getFsImplementation,
+  getPlatform,
+  init_fsOperations,
+  init_platform
+} from "./chunk-s3hafnk3.js";
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/utils/path.ts
+import { homedir } from "os";
+import { dirname, isAbsolute, join, normalize, posix, relative, resolve } from "path";
+function expandPath(path, baseDir) {
+  const actualBaseDir = baseDir ?? getCwd() ?? getFsImplementation().cwd();
+  if (typeof path !== "string") {
+    throw new TypeError(`Path must be a string, received ${typeof path}`);
+  }
+  if (typeof actualBaseDir !== "string") {
+    throw new TypeError(`Base directory must be a string, received ${typeof actualBaseDir}`);
+  }
+  if (path.includes("\x00") || actualBaseDir.includes("\x00")) {
+    throw new Error("Path contains null bytes");
+  }
+  const isSyntheticPosixPath = (value) => value.includes("/") && !value.includes("\\") && !/^[A-Za-z]:/.test(value);
+  const trimmedPath = path.trim();
+  if (!trimmedPath) {
+    if (getPlatform() === "windows" && isSyntheticPosixPath(actualBaseDir)) {
+      return posix.normalize(actualBaseDir).normalize("NFC");
+    }
+    return normalize(actualBaseDir).normalize("NFC");
+  }
+  if (trimmedPath === "~") {
+    return homedir().normalize("NFC");
+  }
+  if (trimmedPath.startsWith("~/")) {
+    return join(homedir(), trimmedPath.slice(2)).normalize("NFC");
+  }
+  let processedPath = trimmedPath;
+  if (getPlatform() === "windows" && trimmedPath.match(/^\/[a-z]\//i)) {
+    try {
+      processedPath = posixPathToWindowsPath(trimmedPath);
+    } catch {
+      processedPath = trimmedPath;
+    }
+  }
+  if (isAbsolute(processedPath)) {
+    if (getPlatform() === "windows" && isSyntheticPosixPath(processedPath)) {
+      return posix.normalize(processedPath).normalize("NFC");
+    }
+    return normalize(processedPath).normalize("NFC");
+  }
+  if (getPlatform() === "windows" && isSyntheticPosixPath(actualBaseDir) && !/^[A-Za-z]:/.test(processedPath) && !processedPath.startsWith("\\\\")) {
+    return posix.resolve(actualBaseDir, processedPath).normalize("NFC");
+  }
+  return resolve(actualBaseDir, processedPath).normalize("NFC");
+}
+function toRelativePath(absolutePath) {
+  const relativePath = relative(getCwd(), absolutePath);
+  return relativePath.startsWith("..") ? absolutePath : relativePath;
+}
+function getDirectoryForPath(path) {
+  const absolutePath = expandPath(path);
+  if (absolutePath.startsWith("\\\\") || absolutePath.startsWith("//")) {
+    return dirname(absolutePath);
+  }
+  try {
+    const stats = getFsImplementation().statSync(absolutePath);
+    if (stats.isDirectory()) {
+      return absolutePath;
+    }
+  } catch {}
+  return dirname(absolutePath);
+}
+function containsPathTraversal(path) {
+  return /(?:^|[\\/])\.\.(?:[\\/]|$)/.test(path);
+}
+function normalizePathForConfigKey(path) {
+  const normalized = normalize(path);
+  return normalized.replace(/\\/g, "/");
+}
+var init_path = __esm(() => {
+  init_cwd();
+  init_fsOperations();
+  init_platform();
+  init_windowsPaths();
+  init_sessionStoragePortable();
+});
+
+export { expandPath, toRelativePath, getDirectoryForPath, containsPathTraversal, normalizePathForConfigKey, init_path };

package/dist/chunk-y67ntyek.js

@@ -0,0 +1,258 @@
+// @bun
+import {
+  MAX_UDS_FRAME_BYTES,
+  attachUdsResponseReader,
+  getChunkBytes,
+  init_udsMessaging,
+  init_udsResponseReader
+} from "./chunk-9ffc9n60.js";
+import"./chunk-k49xc781.js";
+import {
+  init_genericProcessUtils,
+  isProcessRunning
+} from "./chunk-hjxqmtg5.js";
+import"./chunk-hzmzwte2.js";
+import"./chunk-pdvg91cg.js";
+import"./chunk-c1yc761e.js";
+import"./chunk-c5g9shkw.js";
+import"./chunk-aeysytks.js";
+import {
+  errorMessage,
+  getUserConfigSubdirs,
+  init_debug,
+  init_errors,
+  init_redscopeCompat,
+  init_slowOperations,
+  isFsInaccessible,
+  jsonParse,
+  jsonStringify,
+  logForDebugging
+} from "./chunk-s3hafnk3.js";
+import"./chunk-kb3758f7.js";
+import"./chunk-9h9k5vz3.js";
+import"./chunk-xmpgmeb8.js";
+import"./chunk-2kz09j2s.js";
+import"./chunk-c0k7b0jw.js";
+import {
+  __esm,
+  __require
+} from "./chunk-hhsxm2yr.js";
+
+// src/utils/udsClient.ts
+import { createConnection } from "net";
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+function getSessionDirs() {
+  return getUserConfigSubdirs("sessions");
+}
+async function listAllLiveSessions() {
+  const results = [];
+  for (const dir of getSessionDirs()) {
+    let files;
+    try {
+      files = await readdir(dir);
+    } catch (e) {
+      if (!isFsInaccessible(e)) {
+        logForDebugging(`[udsClient] readdir failed: ${errorMessage(e)}`);
+      }
+      continue;
+    }
+    for (const file of files) {
+      if (!/^\d+\.json$/.test(file))
+        continue;
+      const pid = parseInt(file.slice(0, -5), 10);
+      if (!isProcessRunning(pid)) {
+        continue;
+      }
+      try {
+        const raw = await readFile(join(dir, file), "utf8");
+        const data = jsonParse(raw);
+        results.push({
+          pid,
+          sessionId: data.sessionId,
+          cwd: data.cwd,
+          startedAt: data.startedAt,
+          kind: data.kind,
+          name: data.name,
+          messagingSocketPath: data.messagingSocketPath,
+          entrypoint: data.entrypoint,
+          bridgeSessionId: data.bridgeSessionId,
+          alive: true
+        });
+      } catch {}
+    }
+  }
+  return results;
+}
+async function listPeers() {
+  const all = await listAllLiveSessions();
+  return all.filter((s) => s.pid !== process.pid && s.messagingSocketPath != null);
+}
+async function findAuthTokenForSocketPath(socketPath) {
+  const { readUdsCapabilityToken } = await import("./chunk-94pfyv6a.js");
+  return readUdsCapabilityToken(socketPath);
+}
+async function isPeerAlive(socketPath, timeoutMs = 3000, authToken) {
+  const token = authToken ?? await findAuthTokenForSocketPath(socketPath);
+  if (!token)
+    return false;
+  return new Promise((resolve) => {
+    const conn = createConnection(socketPath, () => {
+      const ping = {
+        type: "ping",
+        ts: new Date().toISOString(),
+        meta: { authToken: token }
+      };
+      conn.write(jsonStringify(ping) + `
+`);
+    });
+    let resolved = false;
+    const timer = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        conn.destroy();
+        resolve(false);
+      }
+    }, timeoutMs);
+    let buffer = "";
+    conn.on("data", (chunk) => {
+      if (Buffer.byteLength(buffer, "utf8") + getChunkBytes(chunk) > MAX_UDS_FRAME_BYTES) {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timer);
+          conn.destroy();
+          resolve(false);
+        }
+        return;
+      }
+      buffer += chunk.toString();
+      if (buffer.includes('"pong"')) {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timer);
+          conn.end();
+          resolve(true);
+        }
+      }
+    });
+    conn.on("error", () => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        resolve(false);
+      }
+    });
+  });
+}
+async function sendToUdsSocket(targetSocketPath, message, timeoutMs = 5000) {
+  const { parseUdsTarget } = await import("./chunk-94pfyv6a.js");
+  const target = parseUdsTarget(targetSocketPath);
+  const authToken = await findAuthTokenForSocketPath(target.socketPath);
+  if (!authToken) {
+    throw new Error(`No auth token found for peer at ${target.socketPath}`);
+  }
+  const data = typeof message === "string" ? message : jsonStringify(message);
+  const udsMsg = {
+    type: "text",
+    data,
+    ts: new Date().toISOString()
+  };
+  const { getUdsMessagingSocketPath } = await import("./chunk-94pfyv6a.js");
+  udsMsg.from = getUdsMessagingSocketPath();
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let conn;
+    const finish = (error) => {
+      if (settled)
+        return;
+      settled = true;
+      if (error) {
+        conn.destroy(error);
+        reject(error);
+      } else {
+        conn.end();
+        resolve();
+      }
+    };
+    conn = createConnection(target.socketPath, () => {
+      udsMsg.meta = { ...udsMsg.meta, authToken };
+      conn.write(jsonStringify(udsMsg) + `
+`, (err) => {
+        if (err)
+          finish(err);
+      });
+    });
+    attachUdsResponseReader(conn, {
+      maxFrameBytes: MAX_UDS_FRAME_BYTES,
+      onSettled: finish,
+      formatSocketError: (err) => new UdsPeerConnectionError(target.socketPath, err)
+    });
+    conn.setTimeout(timeoutMs, () => {
+      finish(new UdsPeerConnectionError(target.socketPath, new Error("Connection timed out")));
+    });
+  });
+}
+function connectToPeer(socketPath, onSocketError, timeoutMs = 5000) {
+  return new Promise((resolve, reject) => {
+    const conn = createConnection(socketPath);
+    let settled = false;
+    const timeout = setTimeout(fail, timeoutMs, new Error("Connection timed out"));
+    function cleanupListeners() {
+      clearTimeout(timeout);
+      conn.off("error", fail);
+    }
+    function fail(cause) {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanupListeners();
+      conn.destroy();
+      reject(new UdsPeerConnectionError(socketPath, cause));
+    }
+    conn.once("connect", () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanupListeners();
+      conn.on("error", onSocketError);
+      resolve(conn);
+    });
+    conn.on("error", fail);
+  });
+}
+function disconnectPeer(socket) {
+  if (!socket.destroyed) {
+    socket.end();
+  }
+}
+var UdsPeerConnectionError;
+var init_udsClient = __esm(() => {
+  init_debug();
+  init_errors();
+  init_genericProcessUtils();
+  init_redscopeCompat();
+  init_slowOperations();
+  init_udsMessaging();
+  init_udsResponseReader();
+  UdsPeerConnectionError = class UdsPeerConnectionError extends Error {
+    socketPath;
+    constructor(socketPath, cause) {
+      super(`Failed to connect to peer at ${socketPath}: ${errorMessage(cause)}`, { cause });
+      this.name = "UdsPeerConnectionError";
+      this.socketPath = socketPath;
+    }
+  };
+});
+init_udsClient();
+
+export {
+  sendToUdsSocket,
+  listPeers,
+  listAllLiveSessions,
+  isPeerAlive,
+  disconnectPeer,
+  connectToPeer,
+  UdsPeerConnectionError
+};

package/dist/chunk-ybk37qp9.js

@@ -0,0 +1,37 @@
+// @bun
+import {
+  require_execAsync
+} from "./chunk-c17f0h2s.js";
+import {
+  require_src
+} from "./chunk-e3abfxpy.js";
+import {
+  __commonJS
+} from "./chunk-hhsxm2yr.js";
+
+// node_modules/.bun/@opentelemetry+resources@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-darwin.js
+var require_getMachineId_darwin = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getMachineId = undefined;
+  var execAsync_1 = require_execAsync();
+  var api_1 = require_src();
+  async function getMachineId() {
+    try {
+      const result = await (0, execAsync_1.execAsync)('ioreg -rd1 -c "IOPlatformExpertDevice"');
+      const idLine = result.stdout.split(`
+`).find((line) => line.includes("IOPlatformUUID"));
+      if (!idLine) {
+        return;
+      }
+      const parts = idLine.split('" = "');
+      if (parts.length === 2) {
+        return parts[1].slice(0, -1);
+      }
+    } catch (e) {
+      api_1.diag.debug(`error reading machine id: ${e}`);
+    }
+    return;
+  }
+  exports.getMachineId = getMachineId;
+});
+export default require_getMachineId_darwin();