@lazehq/cli 0.1.18 → 0.1.20

package/dist/laze.mjs

@@ -31497,7 +31497,8 @@ function runRedacted({
   baseEnv,
   stdout: stdout2,
   stderr: stderr2,
-  cwd
+  cwd,
+  signal
 }) {
   const values = Object.values(env);
   return new Promise((resolve17, reject) => {
@@ -31505,8 +31506,12 @@ function runRedacted({
     const child = spawn(file3, args, {
       env: { ...baseEnv, ...env },
       stdio: ["inherit", "pipe", "pipe"],
-      ...cwd ? { cwd } : {}
+      ...cwd ? { cwd } : {},
+      ...signal ? { detached: true } : {}
     });
+    const killGroup = () => killProcessGroup({ child });
+    if (signal?.aborted) killGroup();
+    signal?.addEventListener("abort", killGroup, { once: true });
     const pipe2 = (stream, sink) => {
       const decoder2 = new StringDecoder("utf8");
       const redactor = createRedactor({ values });
@@ -31520,11 +31525,20 @@ function runRedacted({
     };
     const drained = Promise.all([pipe2(child.stdout, stdout2), pipe2(child.stderr, stderr2)]);
     child.on("error", reject);
-    child.on("close", (code, signal) => {
-      void drained.then(() => resolve17(code ?? (signal ? 128 + signalNumber(signal) : 1)));
+    child.on("close", (code, ended) => {
+      signal?.removeEventListener("abort", killGroup);
+      void drained.then(() => resolve17(code ?? (ended ? 128 + signalNumber(ended) : 1)));
     });
   });
 }
+function killProcessGroup({ child }) {
+  if (child.pid === void 0) return;
+  try {
+    process.kill(-child.pid, "SIGKILL");
+  } catch {
+    child.kill("SIGKILL");
+  }
+}
 function signalNumber(signal) {
   const numbers = { SIGINT: 2, SIGKILL: 9, SIGTERM: 15 };
   return numbers[signal] ?? 1;
@@ -35606,7 +35620,7 @@ function flagText({
 }
 
 // src/rules/cli-version.rules.ts
-var STAMPED = "0.1.18";
+var STAMPED = "0.1.20";
 function cliVersionOf({ stamped = STAMPED } = {}) {
   return stamped.startsWith("__") ? "dev" : stamped;
 }
@@ -67466,8 +67480,23 @@ function channelLabelIn(channel) {
 // src/services/claude-wait.service.ts
 import { readFile as readFile6, rm as rm2, writeFile as writeFile5, mkdir as mkdir5 } from "node:fs/promises";
 import { dirname as dirname5 } from "node:path";
+
+// src/rules/rush-host.rules.ts
+function rushSessionOf({ parentArgs }) {
+  if (!parentArgs) return void 0;
+  const [program = "", verb, action, id] = parentArgs;
+  const isRush = program === "rush" || program.endsWith("/rush");
+  if (!isRush || verb !== "host" || action !== "run" || !id) return void 0;
+  return { id, program };
+}
+function rushSendCommand({ program, id }) {
+  return ["sh", "-c", 'printf "%s\\n" "$LAZE_WAKE_TEXT" | "$0" session send "$1"', program, id];
+}
+
+// src/services/claude-wait.service.ts
 var ROUND_SECONDS = 50;
 var WATCH_MS = 2e3;
+var RUSH_RETRY_MS = 3e4;
 var CHANNEL_CHECK_MS = 5e3;
 async function holderOf({ path }) {
   return readFile6(path, "utf8").then(
@@ -67603,10 +67632,24 @@ async function waitForMessages({ context, args }) {
   if (!await takeLock({ context, path: lock, sessionId: input2.session_id, claudePid })) return 0;
   const seen = () => input2.transcript_path ? readFile6(input2.transcript_path, "utf8") : Promise.resolve("");
   const deadline = context.nowMs() + (WAIT_HOOK_TIMEOUT_SECONDS - 60) * 1e3;
+  const rush = rushSessionOf({
+    parentArgs: await context.processes.argsOf(await context.processes.parentOf(claudePid) ?? 0)
+  });
   try {
     while (context.nowMs() < deadline) {
       const code = await settleRound({ context, client, name: name2, lock, claudePid, session, seen });
-      if (code !== "again") return code;
+      if (code === "again") continue;
+      if (code !== 0 || !rush || context.processes.alive(claudePid)) return code;
+      return await wakeThroughRush({
+        context,
+        client,
+        name: name2,
+        lock,
+        claudePid,
+        session,
+        rush,
+        deadline
+      });
     }
     return 0;
   } finally {
@@ -67614,6 +67657,40 @@ async function waitForMessages({ context, args }) {
       await rm2(lock, { force: true });
   }
 }
+async function rushRound({
+  context,
+  client,
+  name: name2,
+  lock,
+  claudePid,
+  session,
+  rush
+}) {
+  if ((await holderOf({ path: lock }))?.pid !== context.processes.pid) return true;
+  const key = session ? sessionKeyOf({ session }) : void 0;
+  if (key && await liveElsewhere({ context, key, claudePid })) return true;
+  const due = await dueFromSpool({ context, profile: name2, seen: async () => "", pushedToo: true });
+  const messages = due.length > 0 ? due : await takeRound({ context, client, claudePid: 0, session });
+  if (messages.length === 0) return false;
+  await keepTaken({ context, profile: name2, messages });
+  const self2 = await currentNameOf({ context, client, profile: name2 });
+  const command = rushSendCommand(rush);
+  const env = { LAZE_WAKE_TEXT: hookContextOf({ messages, self: self2 }) };
+  const quiet = { write: () => true };
+  const sent = await context.runCommand({ command, env, stdout: quiet, stderr: quiet });
+  if (sent !== 0) return false;
+  await turnStarted({ context, client, agent: name2, messages }).catch(() => void 0);
+  await dropFromSpool({ context, profile: name2, messageIds: messages.map((m) => m.messageId) });
+  return true;
+}
+async function wakeThroughRush(round) {
+  while (round.context.nowMs() < round.deadline) {
+    const done = await rushRound(round).catch(() => "failed");
+    if (done === true) return 0;
+    await round.context.sleep(done === "failed" ? RUSH_RETRY_MS : 1e3);
+  }
+  return 0;
+}
 async function waitHook({ context, args }) {
   try {
     return await waitForMessages({ context, args });
@@ -69352,11 +69429,14 @@ async function registerWithClaude({ context, folder }) {
     `claude plugin marketplace update ${LAZE_PLUGIN} ${quiet}`,
     `{ claude plugin install ${LAZE_PLUGIN}@${LAZE_PLUGIN} --scope user ${quiet} || claude plugin update ${LAZE_PLUGIN}@${LAZE_PLUGIN} ${quiet}; }`
   ].join("; ");
-  const run4 = context.runCommand({ command: ["sh", "-c", script], env: {} }).catch(() => 1);
+  const stop3 = new AbortController();
+  const command = ["sh", "-c", script];
+  const run4 = context.runCommand({ command, env: {}, signal: stop3.signal }).catch(() => 1);
   const done = new AbortController();
   const gaveUp = context.sleep(REGISTER_LIMIT_MS, done.signal).then(() => -1);
   const code = await Promise.race([run4, gaveUp]);
   done.abort();
+  stop3.abort();
   return code === 0;
 }
 function registeredMarkOf({ context }) {
@@ -85312,7 +85392,8 @@ async function runCommand({
   inherited,
   env,
   stdout: stdout2 = process.stdout,
-  stderr: stderr2 = process.stderr
+  stderr: stderr2 = process.stderr,
+  signal
 }) {
   const [program = "", ...rest] = command;
   try {
@@ -85321,7 +85402,8 @@ async function runCommand({
       env,
       baseEnv: inherited,
       stdout: stdout2,
-      stderr: stderr2
+      stderr: stderr2,
+      ...signal ? { signal } : {}
     });
   } catch (error62) {
     stderr2.write(`laze vault: ${error62 instanceof Error ? error62.message : String(error62)}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazehq/cli",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "The Laze command line: sign in, read and post in chat, and connect your own Claude Code or Codex session as an agent.",
   "license": "UNLICENSED",
   "type": "module",