agent-yes 1.258.3 → 1.259.0

package/ts/subcommands.spec.ts

@@ -2675,6 +2675,119 @@ describe("subcommands.cmdWhoami", () => {
   });
 });
 
+describe("subcommands.cmdRole", () => {
+  async function registerAgent(over: Record<string, unknown> = {}) {
+    const { appendGlobalPid } = await import("./globalPidIndex.ts");
+    await appendGlobalPid({
+      pid: 910001,
+      cli: "claude",
+      prompt: null,
+      cwd: "/repo/lane",
+      log_file: null,
+      status: "active",
+      exit_code: null,
+      exit_reason: null,
+      started_at: Date.now(),
+      wrapper_pid: 515151,
+      agent_id: "eeee0000ffff",
+      ...over,
+    } as any);
+  }
+
+  function capture() {
+    const out: string[] = [];
+    const err: string[] = [];
+    const origOut = process.stdout.write.bind(process.stdout);
+    const origErr = process.stderr.write.bind(process.stderr);
+    (process.stdout as any).write = (s: any) => (out.push(String(s)), true);
+    (process.stderr as any).write = (s: any) => (err.push(String(s)), true);
+    return {
+      out,
+      err,
+      restore() {
+        process.stdout.write = origOut;
+        process.stderr.write = origErr;
+      },
+    };
+  }
+
+  async function withAgentEnv<T>(fn: () => Promise<T>): Promise<T> {
+    const saved = process.env.AGENT_YES_PID;
+    process.env.AGENT_YES_PID = "515151";
+    try {
+      return await fn();
+    } finally {
+      if (saved === undefined) delete process.env.AGENT_YES_PID;
+      else process.env.AGENT_YES_PID = saved;
+    }
+  }
+
+  it("self get/set/clear round-trips via agent context", async () => {
+    const { runSubcommand } = await loadModule();
+    await registerAgent();
+    await withAgentEnv(async () => {
+      let cap = capture();
+      try {
+        expect(await runSubcommand(["bun", "cli.js", "role", "pm"])).toBe(0);
+        expect(cap.out.join("")).toContain('role set to "pm"');
+      } finally {
+        cap.restore();
+      }
+      cap = capture();
+      try {
+        expect(await runSubcommand(["bun", "cli.js", "role"])).toBe(0);
+        expect(cap.out.join("")).toBe("pm\n");
+        expect(await runSubcommand(["bun", "cli.js", "role", "--clear"])).toBe(0);
+        expect(await runSubcommand(["bun", "cli.js", "role"])).toBe(0);
+        expect(cap.out.join("")).toContain("role cleared");
+      } finally {
+        cap.restore();
+      }
+    });
+  });
+
+  it("keyword set and keyword clear work from a human shell", async () => {
+    const { runSubcommand } = await loadModule();
+    await registerAgent();
+    let cap = capture();
+    try {
+      expect(await runSubcommand(["bun", "cli.js", "role", "910001", "crm"])).toBe(0);
+      expect(cap.out.join("")).toContain('role set to "crm"');
+      expect(await runSubcommand(["bun", "cli.js", "role", "910001", "--clear"])).toBe(0);
+      expect(cap.out.join("")).toContain("role cleared");
+    } finally {
+      cap.restore();
+    }
+  });
+
+  it("rejects header-forging role values", async () => {
+    const { runSubcommand } = await loadModule();
+    await registerAgent();
+    const cap = capture();
+    try {
+      expect(await runSubcommand(["bun", "cli.js", "role", "910001", "a b>"])).toBe(1);
+      expect(cap.err.join("")).toContain("invalid role");
+    } finally {
+      cap.restore();
+    }
+  });
+
+  it("errors without agent context when no keyword is given", async () => {
+    const { runSubcommand } = await loadModule();
+    const saved = process.env.AGENT_YES_PID;
+    delete process.env.AGENT_YES_PID;
+    const cap = capture();
+    try {
+      expect(await runSubcommand(["bun", "cli.js", "role"])).toBe(1);
+      expect(await runSubcommand(["bun", "cli.js", "role", "somename"])).toBe(1);
+      expect(cap.err.join("")).toContain("no agent context");
+    } finally {
+      cap.restore();
+      if (saved !== undefined) process.env.AGENT_YES_PID = saved;
+    }
+  });
+});
+
 describe("subcommands.cmdSend double-envelope warning", () => {
   const itUnix = process.platform === "linux" || process.platform === "darwin";
 
@@ -2819,4 +2932,71 @@ describe("subcommands.cmdSend double-envelope warning", () => {
       await rm(tmp, { recursive: true, force: true }).catch(() => null);
     }
   });
+
+  it.skipIf(!itUnix)("a sender with a role gets it rendered into the envelope header", async () => {
+    const { runSubcommand } = await loadModule();
+    const { appendGlobalPid } = await import("./globalPidIndex.ts");
+    const { spawnSync } = await import("child_process");
+    const tmp = await mkdtemp(path.join(tmpdir(), "ay-fifo-"));
+    try {
+      const fifo = path.join(tmp, "role.fifo");
+      if (spawnSync("mkfifo", [fifo]).status !== 0) return;
+      const fs = await import("fs");
+      const rdwrFd = fs.openSync(fifo, fs.constants.O_RDWR);
+      await appendGlobalPid({
+        pid: process.pid,
+        cli: "claude",
+        prompt: null,
+        cwd: "/repo/alpha",
+        log_file: null,
+        fifo_file: fifo,
+        status: "active",
+        exit_code: null,
+        exit_reason: null,
+        started_at: Date.now(),
+      });
+      await appendGlobalPid({
+        pid: 900001,
+        cli: "claude",
+        prompt: null,
+        cwd: "/repo/beta",
+        log_file: null,
+        status: "active",
+        exit_code: null,
+        exit_reason: null,
+        started_at: Date.now(),
+        wrapper_pid: 424242,
+        agent_id: "cccc0000dddd",
+        role: "crm",
+      });
+      const savedAyPid = process.env.AGENT_YES_PID;
+      process.env.AGENT_YES_PID = "424242";
+      const origOut = process.stdout.write.bind(process.stdout);
+      (process.stdout as any).write = () => true;
+      try {
+        const code = await runSubcommand([
+          "bun",
+          "cli.js",
+          "send",
+          String(process.pid),
+          "hello from crm",
+          "--force",
+        ]);
+        expect(code).toBe(0);
+      } finally {
+        process.stdout.write = origOut;
+        if (savedAyPid === undefined) delete process.env.AGENT_YES_PID;
+        else process.env.AGENT_YES_PID = savedAyPid;
+      }
+      const buf = Buffer.alloc(4096);
+      const n = fs.readSync(rdwrFd, buf, 0, buf.length, null);
+      const received = buf.subarray(0, n).toString();
+      expect(received).toMatch(
+        /^<ay-msg [0-9a-f]{8} from claude #900001 \(crm\) @ \/repo\/beta — reply: ay send cccc0000dddd "\.\.\.">/,
+      );
+      fs.closeSync(rdwrFd);
+    } finally {
+      await rm(tmp, { recursive: true, force: true }).catch(() => null);
+    }
+  });
 });

package/ts/subcommands.ts

@@ -16,7 +16,12 @@ import { appendFile, mkdir, open, readFile, stat, writeFile } from "fs/promises"
 import ms from "ms";
 import { homedir } from "os";
 import path from "path";
-import { type GlobalPidRecord, readGlobalPids, updateGlobalPidStatus } from "./globalPidIndex.ts";
+import {
+  type GlobalPidRecord,
+  readGlobalPids,
+  sanitizeRole,
+  updateGlobalPidStatus,
+} from "./globalPidIndex.ts";
 import { buildAgentForest, flattenForest } from "./agentTree.ts";
 import { parseTaskCounts, type TaskCounts } from "./todoParse.ts";
 import { agentYesHome } from "./agentYesHome.ts";
@@ -321,6 +326,7 @@ async function cmdWhoami(rest: string[]): Promise<number> {
   const ageMin = Math.max(0, Math.round((Date.now() - self.started_at) / 60_000));
   const lines = [
     `agent     ${self.cli} #${self.pid}${self.agent_id ? `  (agent_id ${self.agent_id})` : ""}`,
+    `role      ${self.role ?? "-  (set with: ay role <name>)"}`,
     `state     ${state}${question ? ` — ${question}` : ""}`,
     `cwd       ${self.cwd}`,
     `started   ${new Date(self.started_at).toISOString()}  (${ageMin}m ago)`,
@@ -328,7 +334,7 @@ async function cmdWhoami(rest: string[]): Promise<number> {
     `log       ${self.log_file ?? "-"}`,
     `fifo      ${self.fifo_file ?? "-"}`,
     `reply     ${reply} "..."`,
-    `envelope  <ay-msg from ${self.cli} #${self.pid} @ ${self.cwd} — reply: ${reply} "...">…</ay-msg>`,
+    `envelope  <ay-msg from ${self.cli} #${self.pid}${self.role ? ` (${self.role})` : ""} @ ${self.cwd} — reply: ${reply} "...">…</ay-msg>`,
   ];
   process.stdout.write(lines.join("\n") + "\n");
   return 0;
@@ -379,6 +385,7 @@ async function readLocalTsPids(cwd: string): Promise<GlobalPidRecord[]> {
     exit_code: d.exitCode ?? null,
     exit_reason: d.exitReason ?? null,
     started_at: d.startedAt ?? 0,
+    role: d.role ?? null,
   }));
 }
 
@@ -413,6 +420,7 @@ const SUBCOMMANDS = new Set([
   "head",
   "send",
   "msgs",
+  "role",
   "key",
   "select",
   "spawn",
@@ -545,6 +553,8 @@ export async function runSubcommand(argv: string[]): Promise<number | null> {
         return await cmdSend(rest);
       case "msgs":
         return await cmdMsgs(rest);
+      case "role":
+        return await cmdRole(rest);
       case "key":
         return await cmdKey(rest);
       case "select":
@@ -721,6 +731,7 @@ export async function cmdHelp(managerCommands = true): Promise<number> {
       `  ay head <keyword>                   first N lines\n` +
       `  ay send <keyword> <msg>             send a message (keyword '.' = agent in this cwd)\n` +
       `  ay msgs [keyword] [--in|--out]      inter-agent message log (sent + received)\n` +
+      `  ay role [name] | ay role <kw> <name>  lane/role name shown in the send envelope\n` +
       `  ay ch mk|join|send|read|tail <topic>  local-first E2E channels: AI ↔ humans on a topic (ay ch help)\n` +
       `  ay term embed <pid>                 <script> to embed a live read-only agent terminal in a page (ay term help)\n` +
       `  ay widget ls | read selection|dom   read an opted-in page widget's context (selection/DOM) (ay widget help)\n` +
@@ -3310,7 +3321,13 @@ async function cmdSend(rest: string[]): Promise<number> {
   let nonce: string | undefined;
   if (sender.agent && !isSlashCommand(body) && !raw) {
     nonce = randomBytes(4).toString("hex");
-    prefix = `<ay-msg ${nonce} from ${sender.agent.cli} #${sender.agent.pid} @ ${shortenPath(sender.agent.cwd)} — reply: ay send ${replyTarget} "...">\n`;
+    // The sender's self-declared role ("pm", "crm", …) rides along when set —
+    // recipients read dozens of these a day and a pid/cwd doesn't carry the
+    // lane name (cwd → role isn't always derivable). sanitizeRole guarantees
+    // the value can't forge header syntax.
+    const senderRole = sanitizeRole(sender.agent.role);
+    const roleTag = senderRole ? ` (${senderRole})` : "";
+    prefix = `<ay-msg ${nonce} from ${sender.agent.cli} #${sender.agent.pid}${roleTag} @ ${shortenPath(sender.agent.cwd)} — reply: ay send ${replyTarget} "...">\n`;
     suffix = `\n</ay-msg ${nonce}>`;
     // A body that itself starts with an <ay-msg …> header is usually an agent
     // hand-wrapping what this send is about to wrap again — the recipient then
@@ -3391,6 +3408,7 @@ async function cmdSend(rest: string[]): Promise<number> {
             cli: sender.agent.cli,
             cwd: sender.agent.cwd,
             agent_id: sender.agent.agent_id,
+            role: sender.agent.role ?? undefined,
           }
         : null,
       to: {
@@ -3398,6 +3416,7 @@ async function cmdSend(rest: string[]): Promise<number> {
         cli: record.cli,
         cwd: record.cwd,
         agent_id: record.agent_id,
+        role: record.role ?? undefined,
       },
       body,
       code: trailing === "\r" ? undefined : codeName,
@@ -3569,6 +3588,87 @@ async function cmdMsgs(rest: string[]): Promise<number> {
   return 0;
 }
 
+/**
+ * `ay role [name]` / `ay role <keyword> <name>` — read or set an agent's
+ * self-declared lane/role name ("pm", "crm", …). The role rides in the
+ * `ay send` envelope header (`from claude #123 (pm) @ …`) so recipients don't
+ * translate cwd/pid into a lane by hand — the emergent `[pm→qa]` body prefixes
+ * exist exactly because the envelope lacked this. With no args: print the
+ * calling agent's role. With one arg: set the calling agent's role (requires
+ * agent context). With two args: resolve the keyword and set that agent's role.
+ * `--clear` removes it. Roles are clamped by sanitizeRole (they render into the
+ * non-nonce-protected open tag).
+ */
+const ROLE_RESOLVE_OPTS: CommonOpts = {
+  all: false,
+  active: false,
+  cwdScope: null,
+  latest: false,
+  json: false,
+};
+
+async function cmdRole(rest: string[]): Promise<number> {
+  const y = yargs(rest)
+    .usage('Usage: ay role [name] | ay role <keyword> <name> | ay role [keyword] --clear')
+    .option("clear", { type: "boolean", default: false, description: "Remove the role" })
+    .help(false)
+    .version(false)
+    .exitProcess(false);
+  const argv = await y.parseAsync();
+  const args = argv._.slice(0).map(String);
+
+  // Figure out target + new value from arity: 0 args = self get (or self clear),
+  // 1 arg = self set (or keyword clear), 2 args = keyword set.
+  let target: GlobalPidRecord | null = null;
+  let newRole: string | undefined;
+  if (args.length === 2) {
+    target = await resolveOne(args[0]!, ROLE_RESOLVE_OPTS);
+    newRole = args[1]!;
+  } else if (args.length === 1 && argv.clear) {
+    target = await resolveOne(args[0]!, ROLE_RESOLVE_OPTS);
+  } else if (args.length === 1) {
+    target = await resolveSender();
+    if (!target) {
+      process.stderr.write(
+        "ay role: no agent context (AGENT_YES_PID unset or unregistered) — from a human shell, name the agent: ay role <keyword> <name>\n",
+      );
+      return 1;
+    }
+    newRole = args[0]!;
+  } else {
+    target = await resolveSender();
+    if (!target) {
+      process.stderr.write(
+        "ay role: no agent context — from a human shell, name the agent: ay role <keyword> [<name>|--clear]\n",
+      );
+      return 1;
+    }
+  }
+
+  if (newRole === undefined && !argv.clear) {
+    process.stdout.write(`${target.role ?? ""}\n`);
+    return 0;
+  }
+
+  let role: string | null = null;
+  if (!argv.clear) {
+    role = sanitizeRole(newRole);
+    if (!role) {
+      process.stderr.write(
+        `ay role: invalid role ${JSON.stringify(newRole)} — use 1-32 chars of [A-Za-z0-9._-]\n`,
+      );
+      return 1;
+    }
+  }
+  await updateGlobalPidStatus(target.pid, { role });
+  process.stdout.write(
+    role
+      ? `pid ${target.pid} (${target.cli}): role set to "${role}" — envelopes now read: from ${target.cli} #${target.pid} (${role}) @ ${shortenPath(target.cwd)}\n`
+      : `pid ${target.pid} (${target.cli}): role cleared\n`,
+  );
+  return 0;
+}
+
 // Resolve a keyword to one agent and return it with a writable FIFO, or throw
 // with the same guidance cmdSend gives. Shared by `ay key` / `ay select`.
 async function resolveWritableAgent(keyword: string, opts: CommonOpts): Promise<GlobalPidRecord> {

package/ts/systemPathLink.spec.ts

@@ -0,0 +1,69 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { mkdtempSync, mkdirSync, writeFileSync, symlinkSync, lstatSync, readlinkSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { linkBunBinsToSystemPath } from "./systemPathLink.ts";
+
+// linkBunBinsToSystemPath is POSIX-only by design (it returns null on win32 —
+// Windows uses a different PATH model), so the behavioral tests only run where
+// the code path exists.
+const itPosix = it.skipIf(process.platform === "win32");
+
+describe("systemPathLink.linkBunBinsToSystemPath", () => {
+  let root: string;
+  let bunDir: string;
+  let target: string;
+
+  beforeEach(() => {
+    root = mkdtempSync(path.join(tmpdir(), "ay-pathlink-"));
+    bunDir = path.join(root, "bun", "bin");
+    target = path.join(root, "usr-local-bin");
+    mkdirSync(bunDir, { recursive: true });
+    for (const name of ["ay", "cy", "qq"]) writeFileSync(path.join(bunDir, name), "#!/bin/sh\n");
+  });
+  afterEach(() => rmSync(root, { recursive: true, force: true }));
+
+  itPosix("symlinks every bun bin into the target dir", () => {
+    const r = linkBunBinsToSystemPath({ bunDir, target })!;
+    expect(r.linked.sort()).toEqual(["ay", "cy", "qq"]);
+    for (const name of ["ay", "cy", "qq"]) {
+      const dest = path.join(target, name);
+      expect(lstatSync(dest).isSymbolicLink()).toBe(true);
+      expect(path.resolve(target, readlinkSync(dest))).toBe(path.join(bunDir, name));
+    }
+  });
+
+  itPosix("never clobbers a foreign (real) binary already in the target", () => {
+    mkdirSync(target, { recursive: true });
+    writeFileSync(path.join(target, "cy"), "#!/bin/sh\n# a different real cy\n");
+    const r = linkBunBinsToSystemPath({ bunDir, target })!;
+    expect(r.linked.sort()).toEqual(["ay", "qq"]); // cy left alone
+    expect(r.skipped).toContain("cy");
+    expect(lstatSync(path.join(target, "cy")).isSymbolicLink()).toBe(false); // still the real file
+  });
+
+  itPosix("is idempotent — re-running skips links it already owns", () => {
+    linkBunBinsToSystemPath({ bunDir, target });
+    const r2 = linkBunBinsToSystemPath({ bunDir, target })!;
+    expect(r2.linked).toEqual([]);
+    expect(r2.skipped.sort()).toEqual(["ay", "cy", "qq"]);
+  });
+
+  itPosix("refreshes a dangling symlink it owns (name points into bunDir but target gone)", () => {
+    mkdirSync(target, { recursive: true });
+    // a stale link named "ay" pointing at a now-missing path INSIDE bunDir
+    symlinkSync(path.join(bunDir, "ay-old-removed"), path.join(target, "ay"));
+    const r = linkBunBinsToSystemPath({ bunDir, target })!;
+    expect(r.refreshed).toContain("ay");
+    expect(path.resolve(target, readlinkSync(path.join(target, "ay")))).toBe(path.join(bunDir, "ay"));
+  });
+
+  it("returns null when the bun dir is absent", () => {
+    expect(linkBunBinsToSystemPath({ bunDir: path.join(root, "nope"), target })).toBeNull();
+  });
+
+  it("returns null on win32 regardless of inputs", () => {
+    if (process.platform !== "win32") return; // covered implicitly elsewhere
+    expect(linkBunBinsToSystemPath({ bunDir, target })).toBeNull();
+  });
+});

package/ts/systemPathLink.ts

@@ -0,0 +1,134 @@
+// Make bun-global CLIs (ay, cy, the *-yes family, qq, rech, …) resolvable from
+// EVERY shell context, including the hard case: non-interactive non-login shells
+// and Claude Code's Bash tool.
+//
+// Why this is needed: Claude Code's Bash tool sources a per-session shell
+// *snapshot* that statically `export`s a PATH captured at session start. If that
+// PATH didn't include `~/.bun/bin` (e.g. the session was spawned from a context
+// whose PATH lacked it), every bun-global CLI is "command not found" — even
+// though an interactive login shell would have them. There is no bash file that
+// reliably augments PATH for non-interactive non-login shells.
+//
+// The robust fix: symlink the bun-global bins into `/usr/local/bin`, which is on
+// PATH in EVERY context — the bare non-login default
+// (`/usr/local/bin:/usr/local/sbin:/usr/bin:…`), every snapshot, and login
+// shells. Non-clobbering (never overwrites an existing entry) and best-effort
+// (a scheduling/permission hiccup must never break setup). POSIX only — Windows
+// uses a different PATH model and isn't the reported failure surface.
+
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  readlinkSync,
+  symlinkSync,
+  unlinkSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+
+/** Did a (now-dangling) symlink at `linkPath` point into `dir`? Used to adopt
+ * only stale links we previously created, never a foreign broken link. */
+function danglingPointsInto(linkPath: string, dir: string): boolean {
+  try {
+    const oldTarget = path.resolve(path.dirname(linkPath), readlinkSync(linkPath));
+    return path.resolve(path.dirname(oldTarget)) === path.resolve(dir);
+  } catch {
+    return false;
+  }
+}
+
+/** The directory bun installs global binaries into, or null if absent. */
+export function bunBinDir(env: NodeJS.ProcessEnv = process.env): string | null {
+  const install = env.BUN_INSTALL || path.join(homedir(), ".bun");
+  const dir = path.join(install, "bin");
+  return existsSync(dir) ? dir : null;
+}
+
+export interface LinkResult {
+  target: string;
+  linked: string[]; // names newly symlinked
+  skipped: string[]; // names already present (not ours to touch)
+  refreshed: string[]; // our own dangling/stale symlinks repointed
+}
+
+/**
+ * Symlink each entry of the bun-global bin dir into `target` (default
+ * /usr/local/bin). Skips a name that already exists UNLESS it's a symlink we
+ * previously created into the same bun dir (those we refresh, so a rebuilt/moved
+ * bun bin stays valid). Returns null on an unsupported platform or when neither
+ * the bun dir nor the target is usable. Never throws.
+ */
+export function linkBunBinsToSystemPath(opts?: {
+  bunDir?: string | null;
+  target?: string;
+  env?: NodeJS.ProcessEnv;
+}): LinkResult | null {
+  if (process.platform === "win32") return null;
+  const env = opts?.env ?? process.env;
+  const bunDir = opts?.bunDir ?? bunBinDir(env);
+  if (!bunDir) return null;
+  const target = opts?.target ?? "/usr/local/bin";
+
+  try {
+    if (!existsSync(target)) mkdirSync(target, { recursive: true });
+  } catch {
+    return null; // can't create the target dir (permissions) — best-effort give up
+  }
+
+  const result: LinkResult = { target, linked: [], skipped: [], refreshed: [] };
+  let entries: string[];
+  try {
+    entries = readdirSync(bunDir);
+  } catch {
+    return null;
+  }
+
+  for (const name of entries) {
+    const src = path.join(bunDir, name);
+    const dest = path.join(target, name);
+    let existing: ReturnType<typeof lstatSync> | null = null;
+    try {
+      existing = lstatSync(dest);
+    } catch {
+      existing = null; // dest absent
+    }
+    if (existing) {
+      // Only touch a symlink WE own (points back into this bun dir). Anything
+      // else (a real binary, or a link elsewhere) is not ours to replace.
+      let ours = false;
+      if (existing.isSymbolicLink()) {
+        try {
+          ours = path.resolve(target, readlinkSync(dest)) === src;
+        } catch {
+          ours = false;
+        }
+      }
+      if (ours) {
+        result.skipped.push(name); // already correctly linked — nothing to do
+      } else if (existing.isSymbolicLink() && !existsSync(dest) && danglingPointsInto(dest, bunDir)) {
+        // A dangling symlink that USED to point into our bun dir (a bin that
+        // moved/rebuilt) — repoint it. We check the old target dir so we never
+        // hijack an unrelated broken link that merely shares a name.
+        try {
+          unlinkSync(dest);
+          symlinkSync(src, dest);
+          result.refreshed.push(name);
+        } catch {
+          result.skipped.push(name);
+        }
+      } else {
+        result.skipped.push(name); // a real/foreign entry — never clobber
+      }
+      continue;
+    }
+    try {
+      symlinkSync(src, dest);
+      result.linked.push(name);
+    } catch {
+      result.skipped.push(name); // permission/race — best effort
+    }
+  }
+  return result;
+}

package/dist/SUPPORTED_CLIS-D1BoydrZ.js

@@ -1,11 +0,0 @@
-import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-YDl8a9il.js";
-import "./ts-D-E4xqpA.js";
-import "./todoAutomation-BQRW614S.js";
-import "./JsonlStore-CPGIR0Wy.js";
-import "./globalPidIndex-Dq4KY2IV.js";
-import "./pidStore-Cmcc8Oej.js";
-import "./messageLog-BYFwioFY.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DD6bhkyI.js";
-
-export { SUPPORTED_CLIS };

package/dist/globalPidIndex-CQX_0JSB.js

@@ -1,4 +0,0 @@
-import "./logger-CDIsZ-Pp.js";
-import { a as updateGlobalPidStatus, i as readGlobalPids, n as maybeCompactGlobalPids, r as pruneOldLogs, t as appendGlobalPid } from "./globalPidIndex-Dq4KY2IV.js";
-
-export { readGlobalPids };

package/dist/pidStore-BbKqQOS8.js

@@ -1,6 +0,0 @@
-import "./logger-CDIsZ-Pp.js";
-import "./JsonlStore-CPGIR0Wy.js";
-import "./globalPidIndex-Dq4KY2IV.js";
-import { t as PidStore } from "./pidStore-Cmcc8Oej.js";
-
-export { PidStore };

package/dist/spawnGate-DqKBA07k.js

@@ -1,5 +0,0 @@
-import "./logger-CDIsZ-Pp.js";
-import "./globalPidIndex-Dq4KY2IV.js";
-import { i as waitForSpawnCapacity, n as spawnGateEnabled, r as spawnRejectionReason, t as memAvailableMb } from "./spawnGate-D0E1uRP7.js";
-
-export { waitForSpawnCapacity };

package/dist/trayApp-C35IkXnz.js

@@ -1,5 +0,0 @@
-import "./versionChecker-YDl8a9il.js";
-import "./rustBinary-orhBmTNo.js";
-import { a as trayHiddenMarker, i as launchTray, n as hasDesktop, r as isTrayHidden, t as cmdTray } from "./trayApp-4sZgxxP-.js";
-
-export { cmdTray };