@tensorkit/raydr 0.0.0-stage → 0.1.0

package/dist/chunk-KYTKA3YV.js

@@ -0,0 +1,217 @@
+// ../../apps/server/dist/config.js
+import { randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var DEFAULT_VOICE_ID = "21m00Tcm4TlvDq8ikWAM";
+var SPEECH_PROVIDERS = ["elevenlabs", "openai", "kokoro"];
+var TRANSCRIPTION_PROVIDERS = ["elevenlabs", "openai", "whisper"];
+var DEFAULT_SPEECH_INSTRUCTIONS = "Speak like a calm colleague reading a status update aloud; unhurried, warm, no announcer energy";
+var DEFAULT_LOCAL_PORT = 47392;
+function oneOf(name, value, allowed, fallback) {
+  if (!value)
+    return fallback;
+  if (allowed.includes(value))
+    return value;
+  throw new Error(`${name} must be one of ${allowed.join(", ")} (got "${value}")`);
+}
+var warned = /* @__PURE__ */ new Set();
+function envVar(name) {
+  const value = process.env[name];
+  if (value !== void 0 && value !== "")
+    return value;
+  const legacy = name.replace(/^RAYDR_/, "RAYDAR_");
+  const old = process.env[legacy];
+  if (legacy !== name && old !== void 0 && old !== "") {
+    deprecate(legacy, name);
+    return old;
+  }
+  return void 0;
+}
+function deprecate(legacy, name) {
+  if (warned.has(legacy))
+    return;
+  warned.add(legacy);
+  console.error(`${legacy} is deprecated; rename it to ${name} (still honoured this release)`);
+}
+function migrateDir(oldDir, newDir) {
+  if (!existsSync(newDir) && existsSync(oldDir)) {
+    try {
+      mkdirSync(dirname(newDir), { recursive: true });
+      renameSync(oldDir, newDir);
+      console.error(`moved ${oldDir} to ${newDir} (raydar is now raydr)`);
+    } catch (err) {
+      console.error(`could not move ${oldDir} to ${newDir}: ${err.message}`);
+    }
+  }
+  return newDir;
+}
+function xdg(kind) {
+  const fallback = {
+    XDG_CONFIG_HOME: join(homedir(), ".config"),
+    XDG_STATE_HOME: join(homedir(), ".local", "state"),
+    XDG_CACHE_HOME: join(homedir(), ".cache"),
+    XDG_DATA_HOME: join(homedir(), ".local", "share")
+  }[kind];
+  return process.env[kind] ?? fallback;
+}
+function migrateEnvFile(envFile) {
+  let text;
+  try {
+    text = readFileSync(envFile, "utf8");
+  } catch {
+    return 0;
+  }
+  const present = new Set(text.split("\n").map((l) => l.trim().split("=")[0] ?? "").filter((k) => k.startsWith("RAYDR_")));
+  let renamed = 0;
+  const out = text.split("\n").map((line) => {
+    const m = /^(\s*)RAYDAR_([A-Z0-9_]+)(\s*=.*)$/.exec(line);
+    if (!m)
+      return line;
+    const key = `RAYDR_${m[2]}`;
+    if (present.has(key)) {
+      renamed++;
+      return null;
+    }
+    renamed++;
+    return `${m[1]}${key}${m[3]}`;
+  }).filter((l) => l !== null).join("\n");
+  if (renamed > 0) {
+    const tmp = `${envFile}.tmp-${process.pid}`;
+    writeFileSync(tmp, out, { mode: 384 });
+    renameSync(tmp, envFile);
+  }
+  return renamed;
+}
+function defaultLocalDir() {
+  return envVar("RAYDR_LOCAL_DIR") ?? migrateDir(join(xdg("XDG_DATA_HOME"), "raydar"), join(xdg("XDG_DATA_HOME"), "raydr"));
+}
+function defaultCacheDir() {
+  return join(migrateDir(join(xdg("XDG_CACHE_HOME"), "raydar"), join(xdg("XDG_CACHE_HOME"), "raydr")), "audio");
+}
+var DEFAULT_PORT = 47391;
+function defaultStateDir() {
+  return envVar("RAYDR_STATE_DIR") ?? migrateDir(join(xdg("XDG_STATE_HOME"), "raydar"), join(xdg("XDG_STATE_HOME"), "raydr"));
+}
+function defaultEnvFile() {
+  return envVar("RAYDR_ENV_FILE") ?? join(migrateDir(join(xdg("XDG_CONFIG_HOME"), "raydar"), join(xdg("XDG_CONFIG_HOME"), "raydr")), "env");
+}
+function parseEnvFile(text) {
+  const out = {};
+  for (const raw of text.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    const eq = line.indexOf("=");
+    if (eq < 0)
+      continue;
+    const key = line.slice(0, eq).trim();
+    let value = line.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    out[key] = value;
+  }
+  return out;
+}
+function newAccessKey() {
+  return randomBytes(24).toString("base64url");
+}
+function loadConfig(envFile = defaultEnvFile(), options = {}) {
+  const fromFile = existsSync(envFile) ? parseEnvFile(readFileSync(envFile, "utf8")) : {};
+  const get = (key) => {
+    const legacy = key.replace(/^RAYDR_/, "RAYDAR_");
+    let v = envVar(key) ?? fromFile[key];
+    if ((v === void 0 || v === "") && legacy !== key && fromFile[legacy]) {
+      deprecate(legacy, key);
+      v = fromFile[legacy];
+    }
+    return v === void 0 || v === "" ? void 0 : v;
+  };
+  if (options.generateKey && existsSync(envFile)) {
+    const renamed = migrateEnvFile(envFile);
+    if (renamed > 0) {
+      console.log(`renamed ${renamed} RAYDAR_ line(s) to RAYDR_ in ${envFile}`);
+      Object.assign(fromFile, parseEnvFile(readFileSync(envFile, "utf8")));
+    }
+  }
+  let accessKey = get("RAYDR_ACCESS_KEY") ?? "";
+  if (!accessKey && options.generateKey) {
+    accessKey = newAccessKey();
+    mkdirSync(dirname(envFile), { recursive: true });
+    const prefix = existsSync(envFile) && !readFileSync(envFile, "utf8").endsWith("\n") ? "\n" : "";
+    writeFileSync(envFile, `${prefix}RAYDR_ACCESS_KEY=${accessKey}
+`, { flag: "a", mode: 384 });
+    chmodSync(envFile, 384);
+    console.log(`Generated RAYDR_ACCESS_KEY and saved it to ${envFile}`);
+  } else if (existsSync(envFile) && (statSync(envFile).mode & 63) !== 0) {
+    console.warn(`warning: ${envFile} is readable by other users; run chmod 600 on it`);
+  }
+  return {
+    host: get("RAYDR_HOST") ?? "127.0.0.1",
+    port: Number(get("RAYDR_PORT") ?? DEFAULT_PORT),
+    accessKey,
+    speechProvider: oneOf("RAYDR_SPEECH_PROVIDER", get("RAYDR_SPEECH_PROVIDER"), SPEECH_PROVIDERS, "elevenlabs"),
+    transcriptionProvider: oneOf("RAYDR_TRANSCRIPTION_PROVIDER", get("RAYDR_TRANSCRIPTION_PROVIDER"), TRANSCRIPTION_PROVIDERS, "elevenlabs"),
+    elevenLabsApiKey: get("ELEVENLABS_API_KEY") ?? null,
+    elevenLabsVoiceId: get("ELEVENLABS_VOICE_ID") ?? DEFAULT_VOICE_ID,
+    openAiApiKey: get("OPENAI_API_KEY") ?? null,
+    openAiVoice: get("RAYDR_OPENAI_VOICE") ?? "alloy",
+    speechInstructions: get("RAYDR_SPEECH_INSTRUCTIONS") ?? DEFAULT_SPEECH_INSTRUCTIONS,
+    kokoroVoice: get("RAYDR_KOKORO_VOICE") ?? "af_heart",
+    whisperModel: get("RAYDR_WHISPER_MODEL") ?? "small.en",
+    localPort: positiveOr(Number(get("RAYDR_LOCAL_PORT")), DEFAULT_LOCAL_PORT),
+    localDir: get("RAYDR_LOCAL_DIR") ?? defaultLocalDir(),
+    cacheDir: get("RAYDR_CACHE_DIR") ?? defaultCacheDir(),
+    maxSpeechChars: positiveOr(Number(get("RAYDR_MAX_SPEECH_CHARS")), 1500),
+    stateDir: get("RAYDR_STATE_DIR") ?? defaultStateDir(),
+    sessionsMode: get("RAYDR_SESSIONS") === "all" ? "all" : "opt-in",
+    webDir: get("RAYDR_WEB_DIR") ?? null,
+    envFile
+  };
+}
+function positiveOr(n, fallback) {
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+// src/session-state.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+function sessionFile(stateDir, sessionId) {
+  return join2(stateDir, "sessions", `${sessionId}.json`);
+}
+function validSessionId(id) {
+  return typeof id === "string" && /^[A-Za-z0-9-]{8,64}$/.test(id);
+}
+function isEnabled(stateDir, sessionId) {
+  return validSessionId(sessionId) && existsSync2(sessionFile(stateDir, sessionId));
+}
+function enableSession(stateDir, record) {
+  mkdirSync2(join2(stateDir, "sessions"), { recursive: true, mode: 448 });
+  writeFileSync2(sessionFile(stateDir, record.sessionId), `${JSON.stringify(record, null, 2)}
+`, {
+    mode: 384
+  });
+}
+function disableSession(stateDir, sessionId) {
+  const file = sessionFile(stateDir, sessionId);
+  if (!existsSync2(file)) return false;
+  unlinkSync(file);
+  return true;
+}
+
+export {
+  SPEECH_PROVIDERS,
+  TRANSCRIPTION_PROVIDERS,
+  migrateEnvFile,
+  DEFAULT_PORT,
+  defaultStateDir,
+  defaultEnvFile,
+  parseEnvFile,
+  newAccessKey,
+  loadConfig,
+  validSessionId,
+  isEnabled,
+  enableSession,
+  disableSession
+};

package/dist/chunk-NRB77EMM.js

@@ -0,0 +1,6 @@
+// src/version.ts
+var VERSION = "0.1.0";
+
+export {
+  VERSION
+};

package/dist/hook.js

@@ -0,0 +1,95 @@
+import {
+  DEFAULT_PORT,
+  defaultEnvFile,
+  defaultStateDir,
+  isEnabled,
+  parseEnvFile
+} from "./chunk-KYTKA3YV.js";
+
+// src/hook.ts
+import { readFileSync } from "node:fs";
+import { request } from "node:http";
+var CONNECT_TIMEOUT_MS = 1e3;
+var TOTAL_BUDGET_MS = 4e3;
+async function runHook(event, urlOverride) {
+  const off = process.env.RAYDR_OFF || process.env.RAYDAR_OFF;
+  if (off === "1" || off === "true") return;
+  const deadline = Date.now() + TOTAL_BUDGET_MS;
+  const payload = await readStdin(deadline - Date.now());
+  if (payload === null) return;
+  const settings = loadSettings();
+  if (settings.sessionsMode !== "all") {
+    const sessionId = sessionIdOf(payload) ?? process.env.CLAUDE_CODE_SESSION_ID;
+    if (!sessionId || !isEnabled(settings.stateDir, sessionId)) return;
+  }
+  const url = new URL(`${urlOverride ?? settings.url}/hooks/${event}`);
+  const headers = {
+    "content-type": "application/json",
+    "content-length": Buffer.byteLength(payload)
+  };
+  if (settings.accessKey) headers.authorization = `Bearer ${settings.accessKey}`;
+  const pane = process.env.HERDR_PANE_ID;
+  if (pane && !pane.startsWith("$")) headers["X-Raydr-Pane"] = pane;
+  const remaining = deadline - Date.now();
+  if (remaining <= 0) return;
+  await new Promise((resolve) => {
+    const connectTimeout = Math.min(CONNECT_TIMEOUT_MS, remaining);
+    const req = request(url, { method: "POST", headers, timeout: connectTimeout }, (res) => {
+      res.resume();
+      res.on("end", resolve);
+      res.on("error", () => resolve());
+    });
+    const total = setTimeout(() => req.destroy(), remaining);
+    req.on("timeout", () => req.destroy());
+    req.on("error", () => resolve());
+    req.on("close", () => {
+      clearTimeout(total);
+      resolve();
+    });
+    req.end(payload);
+  });
+}
+function sessionIdOf(payload) {
+  try {
+    const parsed = JSON.parse(payload);
+    const id = parsed?.session_id;
+    return typeof id === "string" ? id : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function loadSettings() {
+  let fromFile = {};
+  try {
+    fromFile = parseEnvFile(readFileSync(defaultEnvFile(), "utf8"));
+  } catch {
+  }
+  const get = (key) => process.env[key] || fromFile[key] || process.env[key.replace(/^RAYDR_/, "RAYDAR_")] || fromFile[key.replace(/^RAYDR_/, "RAYDAR_")] || void 0;
+  const host = get("RAYDR_HOST") ?? "127.0.0.1";
+  const port = get("RAYDR_PORT") ?? String(DEFAULT_PORT);
+  const stateDirFromFile = fromFile.RAYDR_STATE_DIR || fromFile.RAYDAR_STATE_DIR;
+  return {
+    url: `http://${host}:${port}`,
+    accessKey: get("RAYDR_ACCESS_KEY"),
+    sessionsMode: get("RAYDR_SESSIONS") === "all" ? "all" : "opt-in",
+    stateDir: get("RAYDR_STATE_DIR") || stateDirFromFile || defaultStateDir()
+  };
+}
+function readStdin(timeoutMs) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    const timer = setTimeout(() => resolve(null), timeoutMs);
+    process.stdin.on("data", (c) => chunks.push(c));
+    process.stdin.on("end", () => {
+      clearTimeout(timer);
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+    process.stdin.on("error", () => {
+      clearTimeout(timer);
+      resolve(null);
+    });
+  });
+}
+export {
+  runHook
+};

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+// src/index.ts
+var [command, ...rest] = process.argv.slice(2);
+if (command === "--version" || command === "-v" || command === "version") {
+  import("./version-IVSD7EGG.js").then(({ VERSION }) => {
+    console.log(VERSION);
+  });
+} else if (command === "hook") {
+  const urlIndex = rest.indexOf("--url");
+  const url = urlIndex >= 0 ? rest[urlIndex + 1] : void 0;
+  const urlValueIndex = urlIndex >= 0 ? urlIndex + 1 : -1;
+  const event = rest.find((a, i) => !a.startsWith("--") && i !== urlValueIndex);
+  if (event) {
+    import("./hook.js").then(({ runHook }) => runHook(event, url)).catch(() => {
+    }).finally(() => process.exit(0));
+  } else {
+    process.exit(0);
+  }
+} else {
+  import("./main.js").then(({ main }) => main(process.argv.slice(2))).catch((err) => {
+    console.error(`raydr: ${err.message}`);
+    process.exit(1);
+  });
+}