@redscope-ai/redscope 1.0.0

package/dist/chunk-zwwdebd0.js

@@ -0,0 +1,65 @@
+// @bun
+import {
+  require_dist_cjs as require_dist_cjs2
+} from "./chunk-ees8xdhd.js";
+import {
+  require_dist_cjs
+} from "./chunk-1aer7c78.js";
+import {
+  __commonJS
+} from "./chunk-hhsxm2yr.js";
+
+// node_modules/.bun/@smithy+node-config-provider@4.3.14/node_modules/@smithy/node-config-provider/dist-cjs/index.js
+var require_dist_cjs3 = __commonJS((exports) => {
+  var propertyProvider = require_dist_cjs();
+  var sharedIniFileLoader = require_dist_cjs2();
+  function getSelectorName(functionString) {
+    try {
+      const constants = new Set(Array.from(functionString.match(/([A-Z_]){3,}/g) ?? []));
+      constants.delete("CONFIG");
+      constants.delete("CONFIG_PREFIX_SEPARATOR");
+      constants.delete("ENV");
+      return [...constants].join(", ");
+    } catch (e) {
+      return functionString;
+    }
+  }
+  var fromEnv = (envVarSelector, options) => async () => {
+    try {
+      const config = envVarSelector(process.env, options);
+      if (config === undefined) {
+        throw new Error;
+      }
+      return config;
+    } catch (e) {
+      throw new propertyProvider.CredentialsProviderError(e.message || `Not found in ENV: ${getSelectorName(envVarSelector.toString())}`, { logger: options?.logger });
+    }
+  };
+  var fromSharedConfigFiles = (configSelector, { preferredFile = "config", ...init } = {}) => async () => {
+    const profile = sharedIniFileLoader.getProfileName(init);
+    const { configFile, credentialsFile } = await sharedIniFileLoader.loadSharedConfigFiles(init);
+    const profileFromCredentials = credentialsFile[profile] || {};
+    const profileFromConfig = configFile[profile] || {};
+    const mergedProfile = preferredFile === "config" ? { ...profileFromCredentials, ...profileFromConfig } : { ...profileFromConfig, ...profileFromCredentials };
+    try {
+      const cfgFile = preferredFile === "config" ? configFile : credentialsFile;
+      const configValue = configSelector(mergedProfile, cfgFile);
+      if (configValue === undefined) {
+        throw new Error;
+      }
+      return configValue;
+    } catch (e) {
+      throw new propertyProvider.CredentialsProviderError(e.message || `Not found in config files w/ profile [${profile}]: ${getSelectorName(configSelector.toString())}`, { logger: init.logger });
+    }
+  };
+  var isFunction = (func) => typeof func === "function";
+  var fromStatic = (defaultValue) => isFunction(defaultValue) ? async () => await defaultValue() : propertyProvider.fromStatic(defaultValue);
+  var loadConfig = ({ environmentVariableSelector, configFileSelector, default: defaultValue }, configuration = {}) => {
+    const { signingName, logger } = configuration;
+    const envOptions = { signingName, logger };
+    return propertyProvider.memoize(propertyProvider.chain(fromEnv(environmentVariableSelector, envOptions), fromSharedConfigFiles(configFileSelector, configuration), fromStatic(defaultValue)));
+  };
+  exports.loadConfig = loadConfig;
+});
+
+export { require_dist_cjs3 as require_dist_cjs };

package/dist/chunk-zxc6x9w8.js

@@ -0,0 +1,340 @@
+// @bun
+import {
+  getAutonomyCommandText,
+  getAutonomyDeepSectionText,
+  getAutonomyStatusText,
+  init_autonomy
+} from "./chunk-cvqpp7dk.js";
+import"./chunk-1qd6f6vk.js";
+import"./chunk-6acx5heq.js";
+import"./chunk-0s8fars0.js";
+import"./chunk-k49xc781.js";
+import {
+  init_autonomyFlows,
+  init_overlayContext,
+  listAutonomyFlows,
+  useRegisterOverlay
+} from "./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 {
+  Dialog,
+  ThemedBox_default,
+  ThemedText,
+  init_src,
+  use_input_default
+} from "./chunk-2g0ytd9d.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./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 {
+  __esm,
+  __toESM
+} from "./chunk-hhsxm2yr.js";
+
+// src/commands/autonomyPanel.tsx
+function getAutonomyPanelBaseActionCountForTests() {
+  return BASE_AUTONOMY_PANEL_ACTION_COUNT;
+}
+function AutonomyPanel({ onDone }) {
+  useRegisterOverlay("autonomy-panel");
+  const [selectedIndex, setSelectedIndex] = import_react.useState(0);
+  const [flows, setFlows] = import_react.useState([]);
+  import_react.useEffect(() => {
+    let cancelled = false;
+    listAutonomyFlows().then((items) => {
+      if (!cancelled)
+        setFlows(items.slice(0, 5));
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  const actions = import_react.useMemo(() => {
+    const base = [
+      {
+        label: "Overview",
+        description: "Show run and flow counts plus the latest automatic activity",
+        run: () => getAutonomyStatusText()
+      },
+      {
+        label: "Full deep status",
+        description: "Print every local autonomy surface in one diagnostic report",
+        run: () => getAutonomyStatusText({ deep: true })
+      },
+      {
+        label: "Auto mode",
+        description: "Check whether auto permission mode is available and why",
+        run: () => getAutonomyDeepSectionText("auto-mode")
+      },
+      {
+        label: "Runs summary",
+        description: "Show queued/running/completed/failed run totals and latest run",
+        run: () => getAutonomyDeepSectionText("runs")
+      },
+      {
+        label: "Recent runs",
+        description: "List recent autonomy run IDs, triggers, statuses, and prompts",
+        run: () => getAutonomyCommandText("runs 10")
+      },
+      {
+        label: "Flows summary",
+        description: "Show managed flow totals across queued/running/waiting states",
+        run: () => getAutonomyDeepSectionText("flows")
+      },
+      {
+        label: "Recent flows",
+        description: "List recent managed flow IDs, status, current step, and goal",
+        run: () => getAutonomyCommandText("flows 10")
+      },
+      {
+        label: "Cron",
+        description: "Show scheduled autonomy jobs, durability, recurrence, and next run",
+        run: () => getAutonomyDeepSectionText("cron")
+      },
+      {
+        label: "Workflow runs",
+        description: "Show persisted WorkflowTool runs and their current workflow step",
+        run: () => getAutonomyDeepSectionText("workflow-runs")
+      },
+      {
+        label: "Teams",
+        description: "Show Agent Teams, teammate backends, activity, and open tasks",
+        run: () => getAutonomyDeepSectionText("teams")
+      },
+      {
+        label: "Pipes",
+        description: "Show UDS/named-pipe and LAN registry for terminal messaging",
+        run: () => getAutonomyDeepSectionText("pipes")
+      },
+      {
+        label: "Runtime",
+        description: "Show daemon state and live background or interactive sessions",
+        run: () => getAutonomyDeepSectionText("runtime")
+      },
+      {
+        label: "Remote Control",
+        description: "Show bridge mode, base URL, token presence, and entitlement note",
+        run: () => getAutonomyDeepSectionText("remote-control")
+      },
+      {
+        label: "RemoteTrigger",
+        description: "Show recent remote trigger audit records, failures, and latest call",
+        run: () => getAutonomyDeepSectionText("remote-trigger")
+      }
+    ];
+    const flowActions = flows.flatMap((flow) => {
+      const shortId = flow.flowId.slice(0, 8);
+      const items = [
+        {
+          label: `Flow ${shortId}`,
+          description: `${flow.status}: ${flow.goal}`,
+          run: () => getAutonomyCommandText(`flow ${flow.flowId}`)
+        }
+      ];
+      if (flow.status === "waiting") {
+        items.push({
+          label: `Resume ${shortId}`,
+          description: flow.currentStep ? `Resume waiting step: ${flow.currentStep}` : "Resume waiting flow",
+          run: () => getAutonomyCommandText(`flow resume ${flow.flowId}`, {
+            enqueueInMemory: true
+          })
+        });
+      }
+      if (flow.status === "queued" || flow.status === "running" || flow.status === "waiting" || flow.status === "blocked") {
+        items.push({
+          label: `Cancel ${shortId}`,
+          description: `Cancel ${flow.status} flow`,
+          run: () => getAutonomyCommandText(`flow cancel ${flow.flowId}`, {
+            removeQueuedInMemory: true
+          })
+        });
+      }
+      return items;
+    });
+    return [...base, ...flowActions];
+  }, [flows]);
+  const selectCurrent = () => {
+    const action = actions[selectedIndex];
+    if (!action)
+      return;
+    action.run().then((result) => {
+      onDone(result, { display: "system" });
+    });
+  };
+  use_input_default((_input, key) => {
+    if (key.upArrow) {
+      setSelectedIndex((index) => Math.max(0, index - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setSelectedIndex((index) => Math.min(actions.length - 1, index + 1));
+      return;
+    }
+    if (key.return) {
+      selectCurrent();
+    }
+  });
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Dialog, {
+    title: "Autonomy",
+    subtitle: `${actions.length} actions`,
+    onCancel: () => onDone("Autonomy panel dismissed", { display: "system" }),
+    color: "background",
+    hideInputGuide: true,
+    children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      flexDirection: "column",
+      children: [
+        actions.map((action, index) => /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+          flexDirection: "row",
+          children: [
+            /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+              children: `${index === selectedIndex ? "\u203A" : " "} ${action.label}`.padEnd(ACTION_LABEL_COLUMN_WIDTH)
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+              dimColor: true,
+              children: action.description
+            }, undefined, false, undefined, this)
+          ]
+        }, `${action.label}-${index}`, true, undefined, this)),
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+          marginTop: 1,
+          children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+            dimColor: true,
+            children: "\u2191/\u2193 select \xB7 Enter run \xB7 Esc close"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+async function call(onDone, _context, args) {
+  const trimmed = args?.trim() ?? "";
+  if (trimmed) {
+    const result = await getAutonomyCommandText(trimmed, {
+      enqueueInMemory: true,
+      removeQueuedInMemory: true
+    });
+    onDone(result, { display: "system" });
+    return null;
+  }
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(AutonomyPanel, {
+    onDone
+  }, undefined, false, undefined, this);
+}
+var import_react, jsx_dev_runtime, BASE_AUTONOMY_PANEL_ACTION_COUNT = 14, ACTION_LABEL_COLUMN_WIDTH = 24;
+var init_autonomyPanel = __esm(() => {
+  init_src();
+  init_src();
+  init_overlayContext();
+  init_autonomy();
+  init_autonomyFlows();
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+init_autonomyPanel();
+
+export {
+  getAutonomyPanelBaseActionCountForTests,
+  call
+};

package/dist/chunk-zy2e7sz0.js

@@ -0,0 +1,8 @@
+// @bun
+import"./chunk-hhsxm2yr.js";
+
+// src/utils/eventLoopStallDetector.ts
+var startEventLoopStallDetector = () => {};
+export {
+  startEventLoopStallDetector
+};

package/dist/chunk-zzf074w3.js

@@ -0,0 +1,196 @@
+// @bun
+import {
+  getGlobalConfig,
+  init_config1 as init_config
+} from "./chunk-eemjb825.js";
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/buddy/types.ts
+var RARITIES, c, duck, goose, blob, cat, dragon, octopus, owl, penguin, turtle, snail, ghost, axolotl, capybara, cactus, robot, rabbit, mushroom, chonk, SPECIES, EYES, HATS, STAT_NAMES, RARITY_WEIGHTS, RARITY_STARS, RARITY_COLORS;
+var init_types = __esm(() => {
+  RARITIES = [
+    "common",
+    "uncommon",
+    "rare",
+    "epic",
+    "legendary"
+  ];
+  c = String.fromCharCode;
+  duck = c(100, 117, 99, 107);
+  goose = c(103, 111, 111, 115, 101);
+  blob = c(98, 108, 111, 98);
+  cat = c(99, 97, 116);
+  dragon = c(100, 114, 97, 103, 111, 110);
+  octopus = c(111, 99, 116, 111, 112, 117, 115);
+  owl = c(111, 119, 108);
+  penguin = c(112, 101, 110, 103, 117, 105, 110);
+  turtle = c(116, 117, 114, 116, 108, 101);
+  snail = c(115, 110, 97, 105, 108);
+  ghost = c(103, 104, 111, 115, 116);
+  axolotl = c(97, 120, 111, 108, 111, 116, 108);
+  capybara = c(99, 97, 112, 121, 98, 97, 114, 97);
+  cactus = c(99, 97, 99, 116, 117, 115);
+  robot = c(114, 111, 98, 111, 116);
+  rabbit = c(114, 97, 98, 98, 105, 116);
+  mushroom = c(109, 117, 115, 104, 114, 111, 111, 109);
+  chonk = c(99, 104, 111, 110, 107);
+  SPECIES = [
+    duck,
+    goose,
+    blob,
+    cat,
+    dragon,
+    octopus,
+    owl,
+    penguin,
+    turtle,
+    snail,
+    ghost,
+    axolotl,
+    capybara,
+    cactus,
+    robot,
+    rabbit,
+    mushroom,
+    chonk
+  ];
+  EYES = ["\xB7", "\u2726", "\xD7", "\u25C9", "@", "\xB0"];
+  HATS = [
+    "none",
+    "crown",
+    "tophat",
+    "propeller",
+    "halo",
+    "wizard",
+    "beanie",
+    "tinyduck"
+  ];
+  STAT_NAMES = [
+    "DEBUGGING",
+    "PATIENCE",
+    "CHAOS",
+    "WISDOM",
+    "SNARK"
+  ];
+  RARITY_WEIGHTS = {
+    common: 60,
+    uncommon: 25,
+    rare: 10,
+    epic: 4,
+    legendary: 1
+  };
+  RARITY_STARS = {
+    common: "\u2605",
+    uncommon: "\u2605\u2605",
+    rare: "\u2605\u2605\u2605",
+    epic: "\u2605\u2605\u2605\u2605",
+    legendary: "\u2605\u2605\u2605\u2605\u2605"
+  };
+  RARITY_COLORS = {
+    common: "inactive",
+    uncommon: "success",
+    rare: "permission",
+    epic: "autoAccept",
+    legendary: "warning"
+  };
+});
+
+// src/buddy/companion.ts
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return function() {
+    a |= 0;
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function hashString(s) {
+  if (typeof Bun !== "undefined") {
+    return Number(BigInt(Bun.hash(s)) & 0xffffffffn);
+  }
+  let h = 2166136261;
+  for (let i = 0;i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function pick(rng, arr) {
+  return arr[Math.floor(rng() * arr.length)];
+}
+function rollRarity(rng) {
+  const total = Object.values(RARITY_WEIGHTS).reduce((a, b) => a + b, 0);
+  let roll = rng() * total;
+  for (const rarity of RARITIES) {
+    roll -= RARITY_WEIGHTS[rarity];
+    if (roll < 0)
+      return rarity;
+  }
+  return "common";
+}
+function rollStats(rng, rarity) {
+  const floor = RARITY_FLOOR[rarity];
+  const peak = pick(rng, STAT_NAMES);
+  let dump = pick(rng, STAT_NAMES);
+  while (dump === peak)
+    dump = pick(rng, STAT_NAMES);
+  const stats = {};
+  for (const name of STAT_NAMES) {
+    if (name === peak) {
+      stats[name] = Math.min(100, floor + 50 + Math.floor(rng() * 30));
+    } else if (name === dump) {
+      stats[name] = Math.max(1, floor - 10 + Math.floor(rng() * 15));
+    } else {
+      stats[name] = floor + Math.floor(rng() * 40);
+    }
+  }
+  return stats;
+}
+function rollFrom(rng) {
+  const rarity = rollRarity(rng);
+  const bones = {
+    rarity,
+    species: pick(rng, SPECIES),
+    eye: pick(rng, EYES),
+    hat: rarity === "common" ? "none" : pick(rng, HATS),
+    shiny: rng() < 0.01,
+    stats: rollStats(rng, rarity)
+  };
+  return { bones, inspirationSeed: Math.floor(rng() * 1e9) };
+}
+function rollWithSeed(seed) {
+  return rollFrom(mulberry32(hashString(seed)));
+}
+function generateSeed() {
+  return `rehatch-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function companionUserId() {
+  const config = getGlobalConfig();
+  return config.oauthAccount?.accountUuid ?? config.userID ?? "anon";
+}
+function getCompanion() {
+  const stored = getGlobalConfig().companion;
+  if (!stored)
+    return;
+  const seed = stored.seed ?? companionUserId();
+  const { bones } = rollWithSeed(seed);
+  return { ...stored, ...bones };
+}
+var RARITY_FLOOR;
+var init_companion = __esm(() => {
+  init_config();
+  init_types();
+  RARITY_FLOOR = {
+    common: 5,
+    uncommon: 15,
+    rare: 25,
+    epic: 35,
+    legendary: 50
+  };
+});
+
+export { duck, goose, blob, cat, dragon, octopus, owl, penguin, turtle, snail, ghost, axolotl, capybara, cactus, robot, rabbit, mushroom, chonk, STAT_NAMES, RARITY_STARS, RARITY_COLORS, init_types, rollWithSeed, generateSeed, getCompanion, init_companion };