omnirush 0.9.1 → 0.10.1

package/assets/extensions/omnirush/stream-timing.ts

@@ -0,0 +1,140 @@
+// When things happened inside a run, as the 2.x engine records them and pi
+// does not: when each content block of a model step started and ended
+// streaming (text, thinking, tool call), when the step's response ended,
+// when each tool call started running, and when the run went idle and how
+// it ended. pi keeps only one timestamp per message.
+//
+// Heard from pi's live events and written into the session itself, as
+// `omnirush-timing` entries (custom entries: never part of the model's
+// context), so every process records its own, a sub-agent's included, and
+// a session read back later (a resumed one, a sub-agent's file) still has
+// them. pi-engine.ts reads them into the trace's 2.x fields:
+//
+//   one entry per model step, at the end of its turn
+//     {step: <the assistant message's timestamp>, streamed, blocks:
+//      [{index, created, completed}], tools: {<toolCallId>: ran}}
+//   one entry when the run settles
+//     {idle: {at, outcome: "succeeded" | "failed" | "interrupted"}}
+//
+// Loaded before the collector (index.ts): the idle entry is on the branch
+// when the collector reads the settled run.
+
+import { TIMING_ENTRY_TYPE } from "./pi-engine";
+
+type Block = { index: number; created?: number; completed?: number };
+type Step = { streamed?: number; blocks: Map<number, Block>; message?: any };
+
+const STARTS = new Set(["text_start", "thinking_start", "toolcall_start"]);
+const ENDS = new Set(["text_end", "thinking_end", "toolcall_end"]);
+
+/** A run's outcome from its last model step (2.x idle marker). */
+export function outcomeOf(stopReason: unknown): "succeeded" | "failed" | "interrupted" {
+  if (stopReason === "stop" || stopReason === "length") return "succeeded";
+  if (stopReason === "error") return "failed";
+  return "interrupted";
+}
+
+export default function recordStreamTiming(pi: any, now: () => number = Date.now): void {
+  const steps = new Map<number, Step>();
+  const ran = new Map<string, number>();
+  let running = false;
+  let lastStop: unknown = undefined;
+
+  const append = (data: Record<string, unknown>) => {
+    try {
+      pi.appendEntry(TIMING_ENTRY_TYPE, data);
+    } catch {
+      /* never in the run's way */
+    }
+  };
+
+  const stepOf = (message: any): Step | null => {
+    const key = Number(message?.timestamp);
+    if (message?.role !== "assistant" || !Number.isFinite(key)) return null;
+    let step = steps.get(key);
+    if (!step) {
+      step = { blocks: new Map() };
+      steps.set(key, step);
+    }
+    return step;
+  };
+
+  /** The step of `message` (a finished assistant message) as its timing entry. */
+  const flushStep = (message: any) => {
+    const key = Number(message?.timestamp);
+    const step = steps.get(key);
+    if (!step || message?.role !== "assistant") return;
+    steps.delete(key);
+    const tools: Record<string, number> = {};
+    for (const block of Array.isArray(message.content) ? message.content : []) {
+      const id = block?.type === "toolCall" && typeof block.id === "string" ? block.id : "";
+      const at = id ? ran.get(id) : undefined;
+      if (at !== undefined) {
+        tools[id] = at;
+        ran.delete(id);
+      }
+    }
+    const blocks = [...step.blocks.values()].sort((a, b) => a.index - b.index);
+    append({
+      step: key,
+      ...(step.streamed !== undefined ? { streamed: step.streamed } : {}),
+      ...(blocks.length > 0 ? { blocks } : {}),
+      ...(Object.keys(tools).length > 0 ? { tools } : {}),
+    });
+  };
+
+  const settle = (outcome: "succeeded" | "failed" | "interrupted") => {
+    if (!running) return;
+    running = false;
+    // Steps whose turn never ended (an aborted run) keep their timing too.
+    for (const step of [...steps.values()]) if (step.message) flushStep(step.message);
+    steps.clear();
+    append({ idle: { at: now(), outcome } });
+    lastStop = undefined;
+  };
+
+  pi.on("agent_start", () => {
+    running = true;
+    lastStop = undefined;
+  });
+
+  pi.on("message_update", (event: any) => {
+    const kind = event?.assistantMessageEvent?.type;
+    const index = event?.assistantMessageEvent?.contentIndex;
+    if (typeof kind !== "string" || typeof index !== "number") return;
+    const step = stepOf(event?.message);
+    if (!step) return;
+    if (STARTS.has(kind)) {
+      if (!step.blocks.has(index)) step.blocks.set(index, { index, created: now() });
+    } else if (ENDS.has(kind)) {
+      const block = step.blocks.get(index) ?? { index };
+      block.completed = now();
+      step.blocks.set(index, block);
+    }
+  });
+
+  pi.on("message_end", (event: any) => {
+    const step = stepOf(event?.message);
+    if (!step) return;
+    step.streamed = now();
+    step.message = event.message;
+    lastStop = event.message.stopReason;
+  });
+
+  pi.on("tool_execution_start", (event: any) => {
+    if (typeof event?.toolCallId === "string") ran.set(event.toolCallId, now());
+  });
+
+  pi.on("turn_end", (event: any) => {
+    flushStep(event?.message);
+  });
+
+  pi.on("agent_settled", () => {
+    settle(outcomeOf(lastStop));
+  });
+
+  // Quit, reload or another session while a run is still going.
+  pi.on("session_shutdown", () => {
+    settle("interrupted");
+  });
+}

package/assets/extensions/omnirush/subagents-lib.ts

@@ -131,6 +131,11 @@ export function catalogFromPayload(payload: unknown): CatalogModel[] | null {
     if (!isRecord(entry) || !isModelId(entry.id)) continue;
     const id = entry.id.trim();
     if (out.some((model) => model.id === id)) continue;
+    const ownership = [entry.provider, entry.owned_by, entry.owner, entry.source, entry.namespace, entry.managed_by]
+      .filter((value): value is string => typeof value === "string")
+      .map((value) => value.trim().toLowerCase());
+    const shipped = ["gpt-6-astra", "gpt-6-sol", "gpt-5.6-sol", "meta-muse-spark", "muse-spark-1.1", "muse-spark-1.3", "muse-spark-1.2-contributor"];
+    if (!shipped.includes(id) && entry.omnirush !== true && !ownership.includes("omnirush")) continue;
     const levels = Array.isArray(entry.reasoning_levels)
       ? EFFORTS.filter((effort) => entry.reasoning_levels.some((level: unknown) => parseEffort(level) === effort))
       : [...staticLevels(id)];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "omnirush",
-  "version": "0.9.1",
-  "description": "Omnirush \u2014 free daily tokens for the most powerful coding model on earth.",
+  "version": "0.10.1",
+  "description": "Omnirush — free daily tokens for the most powerful coding model on earth.",
   "license": "Apache-2.0",
   "type": "module",
   "bin": {
@@ -45,4 +45,4 @@
   "optionalDependencies": {
     "@picovoice/pvrecorder-node": "1.2.9"
   }
-}
+}

package/src/bin.js

@@ -160,7 +160,71 @@ function ensureDirs() {
   } catch {
     /* best effort — pi falls back to PATH, then its own downloader */
   }
-  installDefaultThinkingLevel();
+  withInstallLock(installDefaultThinkingLevel);
+}
+
+const INSTALL_LOCK = path.join(OMNI_DIR, ".install.lock");
+const INSTALL_LOCK_STALE_MS = 60_000;
+const WINDOWS_INSTALL_BUSY = new Set(["EPERM", "EACCES", "EBUSY"]);
+
+function sleepSync(milliseconds) {
+  const wait = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(wait, 0, 0, milliseconds);
+}
+
+/** Serialize launcher state changes across concurrent CLI processes. */
+function withInstallLock(task) {
+  fs.mkdirSync(OMNI_DIR, { recursive: true, mode: 0o700 });
+  const started = Date.now();
+  for (;;) {
+    try {
+      fs.mkdirSync(INSTALL_LOCK);
+      fs.writeFileSync(path.join(INSTALL_LOCK, "owner"), `${process.pid}\n`, { mode: 0o600 });
+      break;
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+      try {
+        if (Date.now() - fs.statSync(INSTALL_LOCK).mtimeMs > INSTALL_LOCK_STALE_MS) {
+          fs.rmSync(INSTALL_LOCK, { recursive: true, force: true });
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (Date.now() - started > 15_000) throw new Error("timed out waiting for the Omnirush installer lock");
+      sleepSync(25);
+    }
+  }
+  try {
+    return task();
+  } finally {
+    fs.rmSync(INSTALL_LOCK, { recursive: true, force: true });
+  }
+}
+
+/** Replace a state file only after its complete contents are ready. */
+function writeFileAtomic(filename, contents, options = {}) {
+  const temporary = `${filename}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  const fd = fs.openSync(temporary, "wx", options.mode ?? 0o600);
+  try {
+    fs.writeSync(fd, contents);
+    try { fs.fsyncSync(fd); } catch { /* best effort on filesystems without fsync */ }
+  } finally {
+    fs.closeSync(fd);
+  }
+  try {
+    for (let attempt = 0; ; attempt++) {
+      try {
+        fs.renameSync(temporary, filename);
+        break;
+      } catch (error) {
+        if (attempt >= 9 || !WINDOWS_INSTALL_BUSY.has(error?.code)) throw error;
+        sleepSync(20 * (attempt + 1));
+      }
+    }
+  } finally {
+    fs.rmSync(temporary, { force: true });
+  }
 }
 
 /**
@@ -198,7 +262,7 @@ function installDefaultThinkingLevel() {
     return;
   }
   if (next !== settings) {
-    fs.writeFileSync(PI_SETTINGS_JSON, JSON.stringify(next, null, 2) + "\n");
+    writeFileAtomic(PI_SETTINGS_JSON, JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
   }
 }
 
@@ -237,7 +301,7 @@ async function launchModels(gatewayUrl, accessToken) {
         const models = catalogFromGateway(payload);
         if (models) {
           try {
-            fs.writeFileSync(cacheFile, JSON.stringify({ gateway: base, fetched_at: new Date().toISOString(), payload }), { mode: 0o600 });
+            withInstallLock(() => writeFileAtomic(cacheFile, JSON.stringify({ gateway: base, fetched_at: new Date().toISOString(), payload }), { mode: 0o600 }));
           } catch {
             /* the cache is a convenience */
           }
@@ -263,18 +327,20 @@ async function launchModels(gatewayUrl, accessToken) {
 }
 
 function installModelsJson(gatewayUrl, models) {
-  let current = {};
-  try {
-    current = JSON.parse(fs.readFileSync(PI_MODELS_JSON, "utf8"));
-  } catch {
-    /* fresh install */
-  }
-  if (typeof current !== "object" || current === null) current = {};
-  current.providers = {
-    ...(current.providers || {}),
-    ...modelsConfig({ gatewayUrl, ...(models ? { models } : {}) }).providers,
-  };
-  fs.writeFileSync(PI_MODELS_JSON, JSON.stringify(current, null, 2) + "\n");
+  withInstallLock(() => {
+    let current = {};
+    try {
+      current = JSON.parse(fs.readFileSync(PI_MODELS_JSON, "utf8"));
+    } catch {
+      /* fresh install */
+    }
+    if (typeof current !== "object" || current === null) current = {};
+    current.providers = {
+      ...(current.providers || {}),
+      ...modelsConfig({ gatewayUrl, ...(models ? { models } : {}) }).providers,
+    };
+    writeFileAtomic(PI_MODELS_JSON, JSON.stringify(current, null, 2) + "\n", { mode: 0o600 });
+  });
 }
 
 function installExtensions() {
@@ -292,11 +358,25 @@ function installExtensions() {
       }
     }
   };
-  copy(src, PI_EXT_DIR);
-  // Modules of the earlier collector: nothing imports them any more.
-  for (const stale of ["collector-lib.ts", "trace-format.ts"]) {
-    fs.rmSync(path.join(PI_EXT_DIR, stale), { force: true });
-  }
+  withInstallLock(() => {
+    const staging = path.join(path.dirname(PI_EXT_DIR), `.omnirush-extension-${process.pid}-${Date.now()}`);
+    const previous = `${PI_EXT_DIR}.previous-${process.pid}`;
+    fs.rmSync(staging, { recursive: true, force: true });
+    fs.rmSync(previous, { recursive: true, force: true });
+    copy(src, staging);
+    try {
+      if (fs.existsSync(PI_EXT_DIR)) fs.renameSync(PI_EXT_DIR, previous);
+      fs.renameSync(staging, PI_EXT_DIR);
+      fs.rmSync(previous, { recursive: true, force: true });
+    } catch {
+      // Windows can refuse a directory rename while another agent has a
+      // module open. Keep the running installation usable as a fallback.
+      fs.rmSync(staging, { recursive: true, force: true });
+      copy(src, PI_EXT_DIR);
+    } finally {
+      fs.rmSync(previous, { recursive: true, force: true });
+    }
+  });
 }
 
 function agentGatewayUrl(auth) {
@@ -561,7 +641,7 @@ async function cmdDoctor() {
   const gateway = agentGatewayUrl(loadAuth(OMNI_DIR));
   try {
     const res = await fetchJson(`${gateway}/models`, { timeout: 5000 });
-    ok("manager", res.status === 401 || res.status < 500, `${origin} -> HTTP ${res.status}`);
+    ok("manager", res.status === 401 || res.status === 200, `${origin} -> HTTP ${res.status}`);
   } catch (e) {
     ok("manager", false, `${origin} unreachable (${e.message})`);
   }
@@ -607,7 +687,7 @@ async function cmdDoctor() {
       const r = await fetchJson("https://registry.npmjs.org/omnirush/latest", { timeout: 5000 });
       if (r.status === 200) {
         latest = JSON.parse(r.body).version;
-        fs.writeFileSync(cacheFile, JSON.stringify({ latest, checked_at: Date.now() }));
+        withInstallLock(() => writeFileAtomic(cacheFile, JSON.stringify({ latest, checked_at: Date.now() }), { mode: 0o600 }));
       }
     }
     if (latest && latest !== own) {

package/src/lib.js

@@ -234,8 +234,9 @@ const GATEWAY_EFFORTS = ["minimal", "low", "medium", "high", "xhigh", "max"];
  * The model list from the gateway's catalog (GET /v1/models, the list the
  * desktop app shows), in its order, for pi's models.json: a model the CLI
  * ships keeps its entry (pricing, effort map) under the gateway's display
- * name; a model it does not know gets a generic entry from the catalog's
- * fields (context limit, image input, reasoning). Shipped models the
+ * name; a future model is accepted only when the gateway explicitly marks
+ * it as Omnirush-owned. Arbitrary provider/BYOK entries are rejected.
+ * Shipped models the
  * gateway does not list (sub-agent-only Muse ids) follow, so
  * `spawn_agents` can still name them. Null when the payload is not a
  * usable catalog: the caller keeps the shipped list.
@@ -254,6 +255,10 @@ export function catalogFromGateway(payload, shipped = MODELS) {
       listed.push({ ...base, ...(name ? { name } : {}) });
       continue;
     }
+    const ownership = [entry.provider, entry.owned_by, entry.owner, entry.source, entry.namespace, entry.managed_by]
+      .filter((value) => typeof value === "string")
+      .map((value) => value.trim().toLowerCase());
+    if (entry.omnirush !== true && !ownership.includes("omnirush")) continue;
     const caps = entry.capabilities && typeof entry.capabilities === "object" ? entry.capabilities : {};
     const context = entry.limits && Number.isSafeInteger(entry.limits.context) && entry.limits.context > 0 ? entry.limits.context : 400000;
     const reasoning = caps.reasoning !== false;