@redscope-ai/redscope 1.0.0

package/dist/chunk-enzzk67f.js

@@ -0,0 +1,313 @@
+// @bun
+import {
+  buildCliLaunch,
+  init_cliLaunch,
+  spawnCli
+} from "./chunk-4kqt1pm1.js";
+import {
+  init_state,
+  queryDaemonStatus,
+  removeDaemonState,
+  stopDaemonByPid,
+  writeDaemonState
+} from "./chunk-0s8fars0.js";
+import"./chunk-rpmntgyh.js";
+import"./chunk-v4ypszbb.js";
+import"./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/daemon/main.ts
+import { resolve } from "path";
+async function daemonMain(args) {
+  const subcommand = args[0] || "status";
+  switch (subcommand) {
+    case "start":
+      await runSupervisor(args.slice(1));
+      break;
+    case "stop":
+      await handleDaemonStop();
+      break;
+    case "status":
+    case "ps":
+      await showUnifiedStatus();
+      break;
+    case "bg": {
+      const bg = await import("./chunk-ym11azkj.js");
+      await bg.handleBgStart(args.slice(1));
+      break;
+    }
+    case "attach": {
+      const bg = await import("./chunk-ym11azkj.js");
+      await bg.attachHandler(args[1]);
+      break;
+    }
+    case "logs": {
+      const bg = await import("./chunk-ym11azkj.js");
+      await bg.logsHandler(args[1]);
+      break;
+    }
+    case "kill": {
+      const bg = await import("./chunk-ym11azkj.js");
+      await bg.killHandler(args[1]);
+      break;
+    }
+    case "--help":
+    case "-h":
+    case "help":
+      printHelp();
+      break;
+    default:
+      console.error(`Unknown daemon subcommand: ${subcommand}`);
+      printHelp();
+      process.exitCode = 1;
+  }
+}
+function printHelp() {
+  console.log(`
+RedScope AI Daemon \u2014 background process management
+
+USAGE
+  redscope daemon [subcommand]
+
+SUBCOMMANDS
+  status      Show daemon and session status (default)
+  start       Start the daemon supervisor
+  stop        Stop the daemon
+  bg          Start a background session
+  attach      Attach to a background session
+  logs        Show session logs
+  kill        Kill a session
+  help        Show this help
+
+REPL
+  /daemon [subcommand]    Same commands available in interactive mode
+
+OPTIONS (for start)
+  --dir <path>              Working directory (default: current)
+  --spawn-mode <mode>       Worker spawn mode: same-dir | worktree (default: same-dir)
+  --capacity <N>            Max concurrent sessions per worker (default: 4)
+  --permission-mode <mode>  Permission mode for spawned sessions
+  --sandbox                 Enable sandbox mode
+  --name <name>             Session name
+  -h, --help                Show this help
+`);
+}
+async function showUnifiedStatus() {
+  const result = queryDaemonStatus();
+  console.log("=== Daemon Supervisor ===");
+  switch (result.status) {
+    case "running": {
+      const s = result.state;
+      console.log(`  Status:  running`);
+      console.log(`  PID:     ${s.pid}`);
+      console.log(`  CWD:     ${s.cwd}`);
+      console.log(`  Started: ${s.startedAt}`);
+      console.log(`  Workers: ${s.workerKinds.join(", ")}`);
+      break;
+    }
+    case "stopped":
+      console.log("  Status: stopped");
+      break;
+    case "stale":
+      console.log("  Status: stale (cleaned up)");
+      break;
+  }
+  console.log(`
+=== Background Sessions ===`);
+  const bg = await import("./chunk-ym11azkj.js");
+  await bg.psHandler([]);
+}
+async function handleDaemonStop() {
+  const result = queryDaemonStatus();
+  if (result.status === "stopped") {
+    console.log("daemon is not running");
+    return;
+  }
+  if (result.status === "stale") {
+    console.log("daemon was stale (cleaned up)");
+    return;
+  }
+  console.log(`stopping daemon (PID: ${result.state.pid})...`);
+  const stopped = await stopDaemonByPid();
+  if (stopped) {
+    console.log("daemon stopped");
+  } else {
+    console.log("daemon could not be stopped (may have already exited)");
+  }
+}
+function parseSupervisorArgs(args) {
+  const result = {};
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--dir" && i + 1 < args.length) {
+      result.dir = resolve(args[++i]);
+    } else if (arg.startsWith("--dir=")) {
+      result.dir = resolve(arg.slice("--dir=".length));
+    } else if (arg === "--spawn-mode" && i + 1 < args.length) {
+      result.spawnMode = args[++i];
+    } else if (arg.startsWith("--spawn-mode=")) {
+      result.spawnMode = arg.slice("--spawn-mode=".length);
+    } else if (arg === "--capacity" && i + 1 < args.length) {
+      result.capacity = args[++i];
+    } else if (arg.startsWith("--capacity=")) {
+      result.capacity = arg.slice("--capacity=".length);
+    } else if (arg === "--permission-mode" && i + 1 < args.length) {
+      result.permissionMode = args[++i];
+    } else if (arg.startsWith("--permission-mode=")) {
+      result.permissionMode = arg.slice("--permission-mode=".length);
+    } else if (arg === "--sandbox") {
+      result.sandbox = "1";
+    } else if (arg === "--name" && i + 1 < args.length) {
+      result.name = args[++i];
+    } else if (arg.startsWith("--name=")) {
+      result.name = arg.slice("--name=".length);
+    }
+  }
+  return result;
+}
+async function runSupervisor(args) {
+  const config = parseSupervisorArgs(args);
+  const dir = config.dir || resolve(".");
+  console.log(`[daemon] supervisor starting in ${dir}`);
+  const workers = [
+    {
+      kind: "remoteControl",
+      process: null,
+      backoffMs: BACKOFF_INITIAL_MS,
+      failureCount: 0,
+      parked: false,
+      lastStartTime: 0
+    }
+  ];
+  writeDaemonState({
+    pid: process.pid,
+    cwd: dir,
+    startedAt: new Date().toISOString(),
+    workerKinds: workers.map((w) => w.kind),
+    lastStatus: "running"
+  });
+  const controller = new AbortController;
+  const shutdown = () => {
+    console.log("[daemon] supervisor shutting down...");
+    controller.abort();
+    removeDaemonState();
+    for (const w of workers) {
+      if (w.process && !w.process.killed) {
+        w.process.kill("SIGTERM");
+      }
+    }
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+  for (const worker of workers) {
+    if (!controller.signal.aborted) {
+      spawnWorker(worker, dir, config, controller.signal);
+    }
+  }
+  await new Promise((resolve2) => {
+    if (controller.signal.aborted) {
+      resolve2();
+      return;
+    }
+    controller.signal.addEventListener("abort", () => resolve2(), { once: true });
+  });
+  await Promise.all(workers.filter((w) => w.process && !w.process.killed).map((w) => new Promise((resolve2) => {
+    if (!w.process) {
+      resolve2();
+      return;
+    }
+    w.process.on("exit", () => resolve2());
+    setTimeout(() => {
+      if (w.process && !w.process.killed) {
+        w.process.kill("SIGKILL");
+      }
+      resolve2();
+    }, 30000);
+  })));
+  console.log("[daemon] supervisor stopped");
+}
+function spawnWorker(worker, dir, config, signal) {
+  if (signal.aborted || worker.parked)
+    return;
+  worker.lastStartTime = Date.now();
+  const env = {
+    ...process.env,
+    DAEMON_WORKER_DIR: dir,
+    DAEMON_WORKER_NAME: config.name,
+    DAEMON_WORKER_SPAWN_MODE: config.spawnMode || "same-dir",
+    DAEMON_WORKER_CAPACITY: config.capacity || "4",
+    DAEMON_WORKER_PERMISSION: config.permissionMode,
+    DAEMON_WORKER_SANDBOX: config.sandbox || "0",
+    DAEMON_WORKER_CREATE_SESSION: "1",
+    CLAUDE_CODE_SESSION_KIND: "daemon-worker"
+  };
+  console.log(`[daemon] spawning worker '${worker.kind}'`);
+  const launch = buildCliLaunch([`--daemon-worker=${worker.kind}`], { env });
+  const child = spawnCli(launch, {
+    cwd: dir,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  worker.process = child;
+  child.stdout?.on("data", (data) => {
+    const lines = data.toString().trimEnd().split(`
+`);
+    for (const line of lines) {
+      console.log(`  ${line}`);
+    }
+  });
+  child.stderr?.on("data", (data) => {
+    const lines = data.toString().trimEnd().split(`
+`);
+    for (const line of lines) {
+      console.error(`  ${line}`);
+    }
+  });
+  child.on("exit", (code, sig) => {
+    worker.process = null;
+    if (signal.aborted) {
+      return;
+    }
+    if (code === EXIT_CODE_PERMANENT) {
+      console.error(`[daemon] worker '${worker.kind}' exited with permanent error \u2014 parking`);
+      worker.parked = true;
+      return;
+    }
+    const runDuration = Date.now() - worker.lastStartTime;
+    if (runDuration < 1e4) {
+      worker.failureCount++;
+      if (worker.failureCount >= MAX_RAPID_FAILURES) {
+        console.error(`[daemon] worker '${worker.kind}' failed ${worker.failureCount} times rapidly \u2014 parking`);
+        worker.parked = true;
+        return;
+      }
+    } else {
+      worker.failureCount = 0;
+      worker.backoffMs = BACKOFF_INITIAL_MS;
+    }
+    console.log(`[daemon] worker '${worker.kind}' exited (code=${code}, signal=${sig}), restarting in ${worker.backoffMs}ms`);
+    setTimeout(() => {
+      if (!signal.aborted && !worker.parked) {
+        spawnWorker(worker, dir, config, signal);
+      }
+    }, worker.backoffMs);
+    worker.backoffMs = Math.min(worker.backoffMs * BACKOFF_MULTIPLIER, BACKOFF_CAP_MS);
+  });
+}
+var EXIT_CODE_PERMANENT = 78, BACKOFF_INITIAL_MS = 2000, BACKOFF_CAP_MS = 120000, BACKOFF_MULTIPLIER = 2, MAX_RAPID_FAILURES = 5;
+var init_main = __esm(() => {
+  init_cliLaunch();
+  init_state();
+});
+init_main();
+
+export {
+  daemonMain
+};

package/dist/chunk-eskhp70f.js

@@ -0,0 +1,117 @@
+// @bun
+import {
+  clearSessionCaches,
+  init_caches
+} from "./chunk-85tcn547.js";
+import"./chunk-j3xveeg4.js";
+import"./chunk-gmdy2w3z.js";
+import"./chunk-q0e485mg.js";
+import"./chunk-2kcgxnvp.js";
+import"./chunk-14p6wvsq.js";
+import"./chunk-6s0q1s5r.js";
+import"./chunk-3w9sye8h.js";
+import"./chunk-nzxfj0gq.js";
+import"./chunk-vr0n9pv9.js";
+import"./chunk-9a9g5hbj.js";
+import"./chunk-ptxteaeh.js";
+import"./chunk-w4p5t920.js";
+import"./chunk-rgyzsbs3.js";
+import"./chunk-q3b4n194.js";
+import"./chunk-kywtr3jg.js";
+import"./chunk-eewg66y1.js";
+import"./chunk-71sdcaq6.js";
+import"./chunk-9hn8e6h1.js";
+import"./chunk-7qey87th.js";
+import"./chunk-zw62m6n3.js";
+import"./chunk-1w20m7gw.js";
+import"./chunk-zzf074w3.js";
+import"./chunk-rpmntgyh.js";
+import"./chunk-24kv69g3.js";
+import"./chunk-hzxzvzw8.js";
+import"./chunk-30wnahyg.js";
+import"./chunk-ztmb7geg.js";
+import"./chunk-tbdkekz3.js";
+import"./chunk-65zbgg1n.js";
+import"./chunk-4spgkgr3.js";
+import"./chunk-60fkafk2.js";
+import"./chunk-50m3a23z.js";
+import"./chunk-6hygvrhn.js";
+import"./chunk-7tfdhkpy.js";
+import"./chunk-8gv2pjby.js";
+import"./chunk-g06pm4n9.js";
+import"./chunk-2p369q9z.js";
+import"./chunk-z0jgeax8.js";
+import"./chunk-w68wc625.js";
+import"./chunk-6hr7742d.js";
+import"./chunk-xyg1sk2w.js";
+import"./chunk-935nrvdb.js";
+import"./chunk-8zz4z1q3.js";
+import"./chunk-fncpkzs5.js";
+import"./chunk-hqxp6b72.js";
+import"./chunk-m2c3bjv1.js";
+import"./chunk-jhtccjc9.js";
+import"./chunk-7nvday0n.js";
+import"./chunk-vxbjzggp.js";
+import"./chunk-yc1stfve.js";
+import"./chunk-8yvsnrkr.js";
+import"./chunk-5mmhfbxb.js";
+import"./chunk-eemjb825.js";
+import"./chunk-ga1jkyqy.js";
+import"./chunk-y1q7rt9n.js";
+import"./chunk-8kct9arg.js";
+import"./chunk-k7hexw3v.js";
+import"./chunk-trqrj23e.js";
+import"./chunk-za3k6h2h.js";
+import"./chunk-8kf8h7xf.js";
+import"./chunk-bgan4cpf.js";
+import"./chunk-jmv7k0jn.js";
+import"./chunk-hjxqmtg5.js";
+import"./chunk-bzyzrq0k.js";
+import"./chunk-vwenx8ke.js";
+import"./chunk-q2h79ncs.js";
+import"./chunk-v4ypszbb.js";
+import"./chunk-qfsn720k.js";
+import"./chunk-7qx3xhv3.js";
+import"./chunk-j9475b46.js";
+import"./chunk-fdwabr8p.js";
+import"./chunk-e4dsy4g1.js";
+import"./chunk-326zehp8.js";
+import"./chunk-kc67kt75.js";
+import"./chunk-40t1d75v.js";
+import"./chunk-dbts5q5p.js";
+import"./chunk-e3abfxpy.js";
+import"./chunk-q44zc68f.js";
+import"./chunk-fejeqe61.js";
+import"./chunk-q1vrhh0q.js";
+import"./chunk-hn4w9pkj.js";
+import"./chunk-2g0ytd9d.js";
+import"./chunk-de0qnnf7.js";
+import"./chunk-j1mep9ck.js";
+import"./chunk-6x35ffpx.js";
+import"./chunk-1zbwhcbt.js";
+import"./chunk-92bjkrf2.js";
+import"./chunk-10k5jfc5.js";
+import"./chunk-n9g24mwe.js";
+import"./chunk-e3j7m7k2.js";
+import"./chunk-hzmzwte2.js";
+import"./chunk-pdvg91cg.js";
+import"./chunk-c696122m.js";
+import"./chunk-xbj5keyy.js";
+import"./chunk-c1yc761e.js";
+import"./chunk-c5g9shkw.js";
+import"./chunk-aeysytks.js";
+import"./chunk-s3hafnk3.js";
+import"./chunk-kb3758f7.js";
+import"./chunk-9h9k5vz3.js";
+import"./chunk-xmpgmeb8.js";
+import"./chunk-2kz09j2s.js";
+import"./chunk-c0k7b0jw.js";
+import"./chunk-pecy49yr.js";
+import"./chunk-azbab59e.js";
+import"./chunk-3nk9q8dr.js";
+import"./chunk-hhsxm2yr.js";
+init_caches();
+
+export {
+  clearSessionCaches
+};

package/dist/chunk-ewx6z4g8.js

@@ -0,0 +1,55 @@
+// @bun
+import {
+  __require
+} from "./chunk-hhsxm2yr.js";
+
+// src/cli/rollback.ts
+async function rollback(target, options) {
+  if (options?.list) {
+    console.log("Recent versions:");
+    console.log("  (version listing requires access to the release registry)");
+    console.log("  Use `redscope update --list` for available versions.");
+    return;
+  }
+  if (options?.safe) {
+    console.log("Safe rollback: would install the server-pinned safe version.");
+    if (options.dryRun) {
+      console.log("  (dry run \u2014 no changes made)");
+      return;
+    }
+    console.log("  Safe version pinning requires access to the release API.");
+    console.log("  Contact oncall for the current safe version.");
+    return;
+  }
+  if (!target) {
+    console.error(`Usage: redscope rollback [target]
+
+` + `Options:
+` + `  -l, --list     List recent published versions
+` + `  --dry-run      Show what would be installed
+` + `  --safe         Roll back to server-pinned safe version
+
+` + `Examples:
+` + `  redscope rollback 2.1.880
+` + `  redscope rollback --list
+` + "  redscope rollback --safe");
+    process.exitCode = 1;
+    return;
+  }
+  console.log(`Rolling back to version ${target}...`);
+  if (options?.dryRun) {
+    console.log(`  (dry run \u2014 would install ${target})`);
+    return;
+  }
+  const { spawnSync } = await import("child_process");
+  const result = spawnSync("npm", ["install", "-g", `@anthropic-ai/claude-code@${target}`], { stdio: "inherit" });
+  if (result.status !== 0) {
+    console.error(`Rollback failed with exit code ${result.status}`);
+    process.exitCode = result.status ?? 1;
+  } else {
+    console.log(`Rolled back to ${target} successfully.`);
+  }
+}
+export {
+  rollback
+};

package/dist/chunk-eyvx461k.js

@@ -0,0 +1,76 @@
+// @bun
+import {
+  CHANNEL_PERMISSION_METHOD,
+  CHANNEL_PERMISSION_REQUEST_METHOD,
+  ChannelMessageNotificationSchema,
+  ChannelPermissionNotificationSchema,
+  ChannelPermissionRequestNotificationSchema,
+  findChannelEntry,
+  gateChannelServer,
+  getEffectiveChannelAllowlist,
+  init_channelNotification,
+  wrapChannelMessage
+} from "./chunk-tj26qpf7.js";
+import"./chunk-7qey87th.js";
+import"./chunk-eemjb825.js";
+import"./chunk-ga1jkyqy.js";
+import"./chunk-y1q7rt9n.js";
+import"./chunk-8kct9arg.js";
+import"./chunk-k7hexw3v.js";
+import"./chunk-trqrj23e.js";
+import"./chunk-za3k6h2h.js";
+import"./chunk-8kf8h7xf.js";
+import"./chunk-bgan4cpf.js";
+import"./chunk-jmv7k0jn.js";
+import"./chunk-hjxqmtg5.js";
+import"./chunk-bzyzrq0k.js";
+import"./chunk-vwenx8ke.js";
+import"./chunk-q2h79ncs.js";
+import"./chunk-v4ypszbb.js";
+import"./chunk-qfsn720k.js";
+import"./chunk-j9475b46.js";
+import"./chunk-fdwabr8p.js";
+import"./chunk-326zehp8.js";
+import"./chunk-40t1d75v.js";
+import"./chunk-e3abfxpy.js";
+import"./chunk-fejeqe61.js";
+import"./chunk-q1vrhh0q.js";
+import"./chunk-hn4w9pkj.js";
+import"./chunk-2g0ytd9d.js";
+import"./chunk-de0qnnf7.js";
+import"./chunk-j1mep9ck.js";
+import"./chunk-6x35ffpx.js";
+import"./chunk-1zbwhcbt.js";
+import"./chunk-10k5jfc5.js";
+import"./chunk-n9g24mwe.js";
+import"./chunk-e3j7m7k2.js";
+import"./chunk-hzmzwte2.js";
+import"./chunk-pdvg91cg.js";
+import"./chunk-c696122m.js";
+import"./chunk-xbj5keyy.js";
+import"./chunk-c1yc761e.js";
+import"./chunk-c5g9shkw.js";
+import"./chunk-aeysytks.js";
+import"./chunk-s3hafnk3.js";
+import"./chunk-kb3758f7.js";
+import"./chunk-9h9k5vz3.js";
+import"./chunk-xmpgmeb8.js";
+import"./chunk-2kz09j2s.js";
+import"./chunk-c0k7b0jw.js";
+import"./chunk-pecy49yr.js";
+import"./chunk-azbab59e.js";
+import"./chunk-3nk9q8dr.js";
+import"./chunk-hhsxm2yr.js";
+init_channelNotification();
+
+export {
+  wrapChannelMessage,
+  getEffectiveChannelAllowlist,
+  gateChannelServer,
+  findChannelEntry,
+  ChannelPermissionRequestNotificationSchema,
+  ChannelPermissionNotificationSchema,
+  ChannelMessageNotificationSchema,
+  CHANNEL_PERMISSION_REQUEST_METHOD,
+  CHANNEL_PERMISSION_METHOD
+};

package/dist/chunk-eztq2b5f.js

@@ -0,0 +1,94 @@
+// @bun
+import {
+  getPreferredUserConfigFile,
+  init_redscopeCompat,
+  init_slowOperations,
+  jsonParse,
+  jsonStringify
+} 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"./chunk-hhsxm2yr.js";
+
+// src/server/lockfile.ts
+init_redscopeCompat();
+init_slowOperations();
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { dirname } from "path";
+var LOCK_FILE = "server-lock.json";
+function getServerLockPath() {
+  return getPreferredUserConfigFile(LOCK_FILE);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseLock(value) {
+  if (!isRecord(value))
+    return null;
+  if (typeof value.pid !== "number" || typeof value.port !== "number" || typeof value.host !== "string" || typeof value.httpUrl !== "string" || typeof value.startedAt !== "number") {
+    return null;
+  }
+  return {
+    pid: value.pid,
+    port: value.port,
+    host: value.host,
+    httpUrl: value.httpUrl,
+    startedAt: value.startedAt
+  };
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return isRecord(error) && (error.code === "EPERM" || error.code === "EACCES");
+  }
+}
+async function healthCheck(httpUrl) {
+  if (!httpUrl.startsWith("http://") && !httpUrl.startsWith("https://")) {
+    return true;
+  }
+  try {
+    const response = await fetch(`${httpUrl.replace(/\/$/, "")}/health`, {
+      signal: AbortSignal.timeout(750)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function writeServerLock(info) {
+  const lockPath = getServerLockPath();
+  await mkdir(dirname(lockPath), { recursive: true });
+  await writeFile(lockPath, `${jsonStringify(info)}
+`, "utf8");
+}
+async function removeServerLock() {
+  await rm(getServerLockPath(), { force: true });
+}
+async function probeRunningServer() {
+  const lockPath = getServerLockPath();
+  let lock = null;
+  try {
+    lock = parseLock(jsonParse(await readFile(lockPath, "utf8")));
+  } catch {
+    return null;
+  }
+  if (!lock) {
+    await removeServerLock();
+    return null;
+  }
+  if (!isPidAlive(lock.pid) || !await healthCheck(lock.httpUrl)) {
+    await removeServerLock();
+    return null;
+  }
+  return lock;
+}
+export {
+  writeServerLock,
+  removeServerLock,
+  probeRunningServer
+};