@redscope-ai/redscope 1.0.0

package/dist/chunk-zzz0nwb5.js

@@ -0,0 +1,310 @@
+// @bun
+import {
+  init_systemTheme,
+  resolveThemeSetting
+} from "./chunk-d2an0138.js";
+import {
+  init_AppState,
+  useAppState,
+  useSetAppState
+} from "./chunk-gmdy2w3z.js";
+import {
+  init_useKeybinding
+} from "./chunk-65zbgg1n.js";
+import {
+  FAST_MODE_MODEL_DISPLAY,
+  LIGHTNING_BOLT,
+  clearFastModeCooldown,
+  formatModelPricing,
+  getFastModeModel,
+  getFastModeRuntimeState,
+  getFastModeUnavailableReason,
+  getGlobalConfig,
+  getOpus46CostTier,
+  init_config1 as init_config,
+  init_fastMode,
+  init_figures,
+  init_modelCost,
+  init_settings1 as init_settings,
+  isFastModeEnabled,
+  isFastModeSupportedByModel,
+  prefetchFastModeStatus,
+  updateSettingsForSource
+} from "./chunk-eemjb825.js";
+import {
+  formatDuration,
+  init_format
+} from "./chunk-q1vrhh0q.js";
+import {
+  Dialog,
+  Link,
+  ThemedBox_default,
+  ThemedText,
+  color,
+  init_source,
+  init_src,
+  source_default,
+  useKeybindings
+} from "./chunk-2g0ytd9d.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-de0qnnf7.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-j1mep9ck.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-hhsxm2yr.js";
+
+// src/components/FastIcon.tsx
+function FastIcon({ cooldown }) {
+  if (cooldown) {
+    return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      color: "promptBorder",
+      dimColor: true,
+      children: LIGHTNING_BOLT
+    }, undefined, false, undefined, this);
+  }
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+    color: "fastMode",
+    children: LIGHTNING_BOLT
+  }, undefined, false, undefined, this);
+}
+function getFastIconString(applyColor = true, cooldown = false) {
+  if (!applyColor) {
+    return LIGHTNING_BOLT;
+  }
+  const themeName = resolveThemeSetting(getGlobalConfig().theme);
+  if (cooldown) {
+    return source_default.dim(color("promptBorder", themeName)(LIGHTNING_BOLT));
+  }
+  return color("fastMode", themeName)(LIGHTNING_BOLT);
+}
+var jsx_dev_runtime;
+var init_FastIcon = __esm(() => {
+  init_source();
+  init_figures();
+  init_src();
+  init_config();
+  init_systemTheme();
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+// src/commands/fast/fast.tsx
+function applyFastMode(enable, setAppState) {
+  clearFastModeCooldown();
+  updateSettingsForSource("userSettings", {
+    fastMode: enable ? true : undefined
+  });
+  if (enable) {
+    setAppState((prev) => {
+      const needsModelSwitch = !isFastModeSupportedByModel(prev.mainLoopModel);
+      return {
+        ...prev,
+        ...needsModelSwitch ? { mainLoopModel: getFastModeModel(), mainLoopModelForSession: null } : {},
+        fastMode: true
+      };
+    });
+  } else {
+    setAppState((prev) => ({ ...prev, fastMode: false }));
+  }
+}
+function FastModePicker({
+  onDone,
+  unavailableReason
+}) {
+  const model = useAppState((s) => s.mainLoopModel);
+  const initialFastMode = useAppState((s) => s.fastMode);
+  const setAppState = useSetAppState();
+  const [enableFastMode, setEnableFastMode] = import_react.useState(initialFastMode ?? false);
+  const runtimeState = getFastModeRuntimeState();
+  const isCooldown = runtimeState.status === "cooldown";
+  const isUnavailable = unavailableReason !== null;
+  const pricing = formatModelPricing(getOpus46CostTier(true));
+  function handleConfirm() {
+    if (isUnavailable)
+      return;
+    applyFastMode(enableFastMode, setAppState);
+    logEvent("tengu_fast_mode_toggled", {
+      enabled: enableFastMode,
+      source: "picker"
+    });
+    if (enableFastMode) {
+      const fastIcon = getFastIconString(enableFastMode);
+      const modelUpdated = !isFastModeSupportedByModel(model) ? ` \xB7 model set to ${FAST_MODE_MODEL_DISPLAY}` : "";
+      onDone(`${fastIcon} Fast mode ON${modelUpdated} \xB7 ${pricing}`);
+    } else {
+      setAppState((prev) => ({ ...prev, fastMode: false }));
+      onDone(`Fast mode OFF`);
+    }
+  }
+  function handleCancel() {
+    if (isUnavailable) {
+      if (initialFastMode) {
+        applyFastMode(false, setAppState);
+      }
+      onDone("Fast mode OFF", { display: "system" });
+      return;
+    }
+    const message = initialFastMode ? `${getFastIconString()} Kept Fast mode ON` : `Kept Fast mode OFF`;
+    onDone(message, { display: "system" });
+  }
+  function handleToggle() {
+    if (isUnavailable)
+      return;
+    setEnableFastMode((prev) => !prev);
+  }
+  useKeybindings({
+    "confirm:yes": handleConfirm,
+    "confirm:nextField": handleToggle,
+    "confirm:next": handleToggle,
+    "confirm:previous": handleToggle,
+    "confirm:cycleMode": handleToggle,
+    "confirm:toggle": handleToggle
+  }, { context: "Confirmation" });
+  const title = /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(FastIcon, {
+        cooldown: isCooldown
+      }, undefined, false, undefined, this),
+      " Fast mode (research preview)"
+    ]
+  }, undefined, true, undefined, this);
+  return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Dialog, {
+    title,
+    subtitle: `High-speed mode for ${FAST_MODE_MODEL_DISPLAY}. Billed as extra usage at a premium rate. Separate rate limits apply.`,
+    onCancel: handleCancel,
+    color: "fastMode",
+    inputGuide: (exitState) => exitState.pending ? /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+      children: [
+        "Press ",
+        exitState.keyName,
+        " again to exit"
+      ]
+    }, undefined, true, undefined, this) : isUnavailable ? /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+      children: "Esc to cancel"
+    }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+      children: "Tab to toggle \xB7 Enter to confirm \xB7 Esc to cancel"
+    }, undefined, false, undefined, this),
+    children: [
+      unavailableReason ? /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedBox_default, {
+        marginLeft: 2,
+        children: /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+          color: "error",
+          children: unavailableReason
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(jsx_dev_runtime2.Fragment, {
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedBox_default, {
+            flexDirection: "column",
+            gap: 0,
+            marginLeft: 2,
+            children: /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedBox_default, {
+              flexDirection: "row",
+              gap: 2,
+              children: [
+                /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+                  bold: true,
+                  children: "Fast mode"
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+                  color: enableFastMode ? "fastMode" : undefined,
+                  bold: enableFastMode,
+                  children: enableFastMode ? "ON " : "OFF"
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+                  dimColor: true,
+                  children: pricing
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this)
+          }, undefined, false, undefined, this),
+          isCooldown && runtimeState.status === "cooldown" && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedBox_default, {
+            marginLeft: 2,
+            children: /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+              color: "warning",
+              children: [
+                runtimeState.reason === "overloaded" ? "Fast mode overloaded and is temporarily unavailable" : "You've hit your fast limit",
+                " \xB7 resets in ",
+                formatDuration(runtimeState.resetAt - Date.now(), {
+                  hideTrailingZeros: true
+                })
+              ]
+            }, undefined, true, undefined, this)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+        dimColor: true,
+        children: [
+          "Learn more:",
+          " ",
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Link, {
+            url: "https://code.claude.com/docs/en/fast-mode",
+            children: "https://code.claude.com/docs/en/fast-mode"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+async function handleFastModeShortcut(enable, getAppState, setAppState) {
+  const unavailableReason = getFastModeUnavailableReason();
+  if (unavailableReason) {
+    return `Fast mode unavailable: ${unavailableReason}`;
+  }
+  const { mainLoopModel } = getAppState();
+  applyFastMode(enable, setAppState);
+  logEvent("tengu_fast_mode_toggled", {
+    enabled: enable,
+    source: "shortcut"
+  });
+  if (enable) {
+    const fastIcon = getFastIconString(true);
+    const modelUpdated = !isFastModeSupportedByModel(mainLoopModel) ? ` \xB7 model set to ${FAST_MODE_MODEL_DISPLAY}` : "";
+    const pricing = formatModelPricing(getOpus46CostTier(true));
+    return `${fastIcon} Fast mode ON${modelUpdated} \xB7 ${pricing}`;
+  } else {
+    return `Fast mode OFF`;
+  }
+}
+async function call(onDone, context, args) {
+  if (!isFastModeEnabled()) {
+    return null;
+  }
+  await prefetchFastModeStatus();
+  const arg = args?.trim().toLowerCase();
+  if (arg === "on" || arg === "off") {
+    const result = await handleFastModeShortcut(arg === "on", context.getAppState, context.setAppState);
+    onDone(result);
+    return null;
+  }
+  const unavailableReason = getFastModeUnavailableReason();
+  logEvent("tengu_fast_mode_picker_shown", {
+    unavailable_reason: unavailableReason ?? ""
+  });
+  return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(FastModePicker, {
+    onDone,
+    unavailableReason
+  }, undefined, false, undefined, this);
+}
+var import_react, jsx_dev_runtime2;
+var init_fast = __esm(() => {
+  init_src();
+  init_FastIcon();
+  init_src();
+  init_useKeybinding();
+  init_analytics();
+  init_AppState();
+  init_fastMode();
+  init_format();
+  init_modelCost();
+  init_settings();
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime2 = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { getFastIconString, init_FastIcon, FastModePicker, call, init_fast };

package/dist/cli-bun.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env -S bun --no-env-file
+import "./cli.js"

package/dist/cli-node.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./cli.js"

package/dist/cli.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env bun
+// @bun
+import {
+  init_envUtils,
+  isEnvTruthy
+} 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 {
+  __require
+} from "./chunk-hhsxm2yr.js";
+
+// src/entrypoints/cli.tsx
+init_envUtils();
+if (typeof globalThis.MACRO === "undefined") {
+  globalThis.MACRO = {
+    VERSION: process.env.CLAUDE_CODE_VERSION || "1.0.0",
+    BUILD_TIME: new Date().toISOString(),
+    FEEDBACK_CHANNEL: "",
+    ISSUES_EXPLAINER: "",
+    NATIVE_PACKAGE_URL: "",
+    PACKAGE_URL: "",
+    VERSION_CHANGELOG: ""
+  };
+}
+if (isEnvTruthy(process.env.CLAUDE_CODE_FORCE_INTERACTIVE)) {
+  for (const stream of [process.stdin, process.stdout, process.stderr]) {
+    if (!stream.isTTY) {
+      try {
+        Object.defineProperty(stream, "isTTY", {
+          value: true,
+          configurable: true
+        });
+      } catch {}
+    }
+  }
+}
+process.env.COREPACK_ENABLE_AUTO_PIN = "0";
+if (process.env.CLAUDE_CODE_REMOTE === "true") {
+  const existing = process.env.NODE_OPTIONS || "";
+  process.env.NODE_OPTIONS = existing ? `${existing} --max-old-space-size=8192` : "--max-old-space-size=8192";
+}
+if (false) {}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 1 && (args[0] === "--version" || args[0] === "-v" || args[0] === "-V")) {
+    console.log(`${"1.0.0"} (RedScope AI)`);
+    return;
+  }
+  const { profileCheckpoint } = await import("./chunk-jwd7cka0.js");
+  profileCheckpoint("cli_entry");
+  if (false) {}
+  if (process.argv[2] === "--claude-in-chrome-mcp") {
+    profileCheckpoint("cli_claude_in_chrome_mcp_path");
+    const { runClaudeInChromeMcpServer } = await import("./chunk-cba7c5w3.js");
+    await runClaudeInChromeMcpServer();
+    return;
+  } else if (process.argv[2] === "--chrome-native-host") {
+    profileCheckpoint("cli_chrome_native_host_path");
+    const { runChromeNativeHost } = await import("./chunk-n6a6hgtp.js");
+    await runChromeNativeHost();
+    return;
+  } else if (process.argv[2] === "--computer-use-mcp") {
+    profileCheckpoint("cli_computer_use_mcp_path");
+    const { runComputerUseMcpServer } = await import("./chunk-hwba5xdc.js");
+    await runComputerUseMcpServer();
+    return;
+  }
+  if (process.argv[2] === "--acp") {
+    profileCheckpoint("cli_acp_path");
+    const { runAcpAgent } = await import("./chunk-v4nqnvqq.js");
+    await runAcpAgent();
+    return;
+  }
+  if (args[0] === "weixin") {
+    profileCheckpoint("cli_weixin_path");
+    const { handleWeixinCli } = await import("./chunk-nmfwksa4.js");
+    const { enableConfigs } = await import("./chunk-bwb1vxnt.js");
+    const { initializeAnalyticsSink } = await import("./chunk-38frkej6.js");
+    const { shutdownDatadog } = await import("./chunk-mvfqanv5.js");
+    const { shutdown1PEventLogging } = await import("./chunk-1y7kp51j.js");
+    const { logForDebugging } = await import("./chunk-ndttd6es.js");
+    const { ChannelPermissionRequestNotificationSchema } = await import("./chunk-eyvx461k.js");
+    await handleWeixinCli(args.slice(1), {
+      enableConfigs,
+      initializeAnalyticsSink,
+      shutdownDatadog,
+      shutdown1PEventLogging,
+      logForDebugging,
+      registerPermissionHandler(server, handler) {
+        server.setNotificationHandler(ChannelPermissionRequestNotificationSchema(), async (notification) => handler(notification.params));
+      }
+    }, "1.0.0");
+    return;
+  }
+  if (args[0] === "--daemon-worker" || args[0]?.startsWith("--daemon-worker=")) {
+    if (false) {}
+    const kind = args[0] === "--daemon-worker" ? args[1] : args[0].split("=")[1];
+    const { runDaemonWorker } = await import("./chunk-mznav6d1.js");
+    await runDaemonWorker(kind);
+    return;
+  }
+  if (args[0] === "remote-control" || args[0] === "rc" || args[0] === "remote" || args[0] === "sync" || args[0] === "bridge") {
+    profileCheckpoint("cli_bridge_path");
+    const { enableConfigs } = await import("./chunk-bwb1vxnt.js");
+    enableConfigs();
+    const { getBridgeDisabledReason, checkBridgeMinVersion } = await import("./chunk-kfsvcs5t.js");
+    const { BRIDGE_LOGIN_ERROR } = await import("./chunk-13qesvnw.js");
+    const { bridgeMain } = await import("./chunk-7g15x8hm.js");
+    const { exitWithError } = await import("./chunk-3vfxjn7g.js");
+    const { getClaudeAIOAuthTokens } = await import("./chunk-ayymxgn1.js");
+    const { getBridgeAccessToken } = await import("./chunk-nbkbq9en.js");
+    if (!getClaudeAIOAuthTokens()?.accessToken && !getBridgeAccessToken()) {
+      exitWithError(BRIDGE_LOGIN_ERROR);
+    }
+    const disabledReason = await getBridgeDisabledReason();
+    if (disabledReason) {
+      exitWithError(`Error: ${disabledReason}`);
+    }
+    const versionError = checkBridgeMinVersion();
+    if (versionError) {
+      exitWithError(versionError);
+    }
+    const { waitForPolicyLimitsToLoad, isPolicyAllowed } = await import("./chunk-rqd60ay5.js");
+    await waitForPolicyLimitsToLoad();
+    if (!isPolicyAllowed("allow_remote_control")) {
+      exitWithError("Error: Remote Control is disabled by your organization's policy.");
+    }
+    await bridgeMain(args.slice(1));
+    return;
+  }
+  if (args[0] === "daemon") {
+    profileCheckpoint("cli_daemon_path");
+    const { enableConfigs } = await import("./chunk-bwb1vxnt.js");
+    enableConfigs();
+    const { setShellIfWindows } = await import("./chunk-aq5n2adz.js");
+    setShellIfWindows();
+    const { initSinks } = await import("./chunk-fbtfp370.js");
+    initSinks();
+    const { daemonMain } = await import("./chunk-enzzk67f.js");
+    await daemonMain(args.slice(1));
+    return;
+  }
+  if (args.includes("--bg") || args.includes("--background")) {
+    profileCheckpoint("cli_daemon_path");
+    const { enableConfigs } = await import("./chunk-bwb1vxnt.js");
+    enableConfigs();
+    const { setShellIfWindows } = await import("./chunk-aq5n2adz.js");
+    setShellIfWindows();
+    const bg = await import("./chunk-ym11azkj.js");
+    await bg.handleBgStart(args.filter((a) => a !== "--bg" && a !== "--background"));
+    return;
+  }
+  if (args[0] === "ps" || args[0] === "logs" || args[0] === "attach" || args[0] === "kill") {
+    const mapped = args[0] === "ps" ? "status" : args[0];
+    console.error(`[deprecated] Use: redscope daemon ${mapped}${args[1] ? " " + args[1] : ""}`);
+    profileCheckpoint("cli_daemon_path");
+    const { enableConfigs } = await import("./chunk-bwb1vxnt.js");
+    enableConfigs();
+    const { setShellIfWindows } = await import("./chunk-aq5n2adz.js");
+    setShellIfWindows();
+    const { initSinks } = await import("./chunk-fbtfp370.js");
+    initSinks();
+    const { daemonMain } = await import("./chunk-enzzk67f.js");
+    await daemonMain([args[0] === "ps" ? "status" : args[0], ...args.slice(1)]);
+    return;
+  }
+  if (args[0] === "job") {
+    profileCheckpoint("cli_templates_path");
+    const { templatesMain } = await import("./chunk-4tr60273.js");
+    await templatesMain(args.slice(1));
+    process.exit(0);
+  }
+  if (args[0] === "new" || args[0] === "list" || args[0] === "reply") {
+    console.error(`[deprecated] Use: redscope job ${args[0]} ${args.slice(1).join(" ")}`.trim());
+    profileCheckpoint("cli_templates_path");
+    const { templatesMain } = await import("./chunk-4tr60273.js");
+    await templatesMain(args);
+    process.exit(0);
+  }
+  if (false) {}
+  if (false) {}
+  const hasTmuxFlag = args.includes("--tmux") || args.includes("--tmux=classic");
+  if (hasTmuxFlag && (args.includes("-w") || args.includes("--worktree") || args.some((a) => a.startsWith("--worktree=")))) {
+    profileCheckpoint("cli_tmux_worktree_fast_path");
+    const { enableConfigs } = await import("./chunk-bwb1vxnt.js");
+    enableConfigs();
+    const { isWorktreeModeEnabled } = await import("./chunk-h12a4f4x.js");
+    if (isWorktreeModeEnabled()) {
+      const { execIntoTmuxWorktree } = await import("./chunk-7br0w7j5.js");
+      const result = await execIntoTmuxWorktree(args);
+      if (result.handled) {
+        return;
+      }
+      if (result.error) {
+        const { exitWithError } = await import("./chunk-3vfxjn7g.js");
+        exitWithError(result.error);
+      }
+    }
+  }
+  if (args.length === 1 && (args[0] === "--update" || args[0] === "--upgrade")) {
+    process.argv = [process.argv[0], process.argv[1], "update"];
+  }
+  if (args.includes("--bare")) {
+    process.env.CLAUDE_CODE_SIMPLE = "1";
+  }
+  const { startCapturingEarlyInput } = await import("./chunk-4tjdwtyy.js");
+  startCapturingEarlyInput();
+  profileCheckpoint("cli_before_main_import");
+  const { main: cliMain } = await import("./chunk-pxxhtxf5.js");
+  profileCheckpoint("cli_after_main_import");
+  await cliMain();
+  profileCheckpoint("cli_after_main_complete");
+}
+main();