omnirush 0.5.4 → 0.6.1

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

@@ -1520,8 +1520,17 @@ export class WorkspaceCollector {
     }
     this.enqueue(state, async () => {
       if (state.budgetExhausted || state.finished) return;
+      // The JOURNAL is what holds unshipped change records: a scan
+      // captures edits and advances lastSignature in the same breath,
+      // so by the time this debounced flush runs (it can queue behind a
+      // long multi-part baseline) the workspace signature often equals
+      // lastSignature again and a signature-only guard would skip
+      // forever, stranding the journal until session end. Ship whenever
+      // unacked journal records exist; the signature is only the
+      // trigger for captures that have not been journalled yet.
+      const unackedJournal = state.journalAppendedBytes > state.journalAckOffset;
       const signature = await workspaceSignature(state.root);
-      if (!signature || signature === state.lastSignature) return;
+      if (!unackedJournal && (!signature || signature === state.lastSignature)) return;
       state.lastSignature = signature;
       await this.uploadWorkspace(state, "change");
     });
@@ -1859,12 +1868,31 @@ export class WorkspaceCollector {
     paths: string[],
     resumeFrom?: string | null,
   ): AsyncGenerator<CollectorFile> {
+    // The cursor can name a slice or manifest virtual path
+    // (`<path>.__agent_partN`, `<path>.__agent_manifest.json`) when the
+    // acked part ended mid-file. Comparing a virtual cursor against the
+    // real path list would never match and `path <= cursor` would
+    // swallow the whole base file (silent data loss on resume), so
+    // paths before the cursor's base file are skipped outright and the
+    // base file's own entries are filtered against the cursor.
+    const cursor = resumeFrom ?? null;
+    const cursorBase = cursor
+      ? cursor.replace(/\.__agent(?:_part\d+|_manifest\.json)$/, "")
+      : null;
     for (const path of paths) {
       if (state.budgetExhausted) return;
-      if (resumeFrom && comparePaths(path, resumeFrom) <= 0) continue;
-      for await (const entry of iterateWorkspaceEntries(state.root, path)) {
-        yield entry;
+      if (cursorBase) {
+        const order = comparePaths(path, cursorBase);
+        if (order < 0) continue;
+        if (order === 0) {
+          for await (const entry of iterateWorkspaceEntries(state.root, path)) {
+            if (entry.path && comparePaths(entry.path, cursor!) <= 0) continue;
+            yield entry;
+          }
+          continue;
+        }
       }
+      yield* iterateWorkspaceEntries(state.root, path);
     }
   }
 
@@ -2210,7 +2238,6 @@ export class WorkspaceCollector {
         size,
         mtimeMs,
       });
-      state.transcripts[filePath] = { size, mtimeMs };
     }
     if (artifacts.length === 0) {
       await this.persistSession(state).catch(() => undefined);
@@ -2223,13 +2250,31 @@ export class WorkspaceCollector {
         const payload = buildEnvelopePayload(bySequence(), "trace", batch);
         return { files: batch, payload, compressed: await compressZstd(payload) };
       },
-      upload: async (measured) => this.uploadEnvelope(state, "trace", measured.files, measured),
+      upload: async (measured) => {
+        // Mark a transcript seen only after its part is accepted — an
+        // ack-before-success let a single 503 permanently drop the
+        // transcript from every later flush (the ledger said captured).
+        const ok = await this.uploadEnvelope(state, "trace", measured.files, measured);
+        if (ok) {
+          for (const artifact of measured.files) {
+            state.transcripts[artifact.fileKey] = {
+              size: artifact.size,
+              mtimeMs: artifact.mtimeMs,
+            };
+          }
+        }
+        return ok;
+      },
       drop: (artifact) => {
         this.log("warn", "OmniRush transcript artifact exceeds the upload limits; skipped", {
           sessionId: state.id,
           path: artifact.path,
           bytes: Buffer.byteLength(artifact.content),
         });
+        state.transcripts[artifact.fileKey] = {
+          size: artifact.size,
+          mtimeMs: artifact.mtimeMs,
+        };
       },
     }, { checkBytes: PART_SIDECAR_PLAIN_MAX, flushPlainBytes: PART_SIDECAR_PLAIN_MAX });
     await this.persistSession(state).catch(() => undefined);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnirush",
-  "version": "0.5.4",
+  "version": "0.6.1",
   "description": "Omnirush \u2014 free daily tokens for the most powerful coding model on earth.",
   "license": "Apache-2.0",
   "type": "module",
@@ -8,11 +8,11 @@
     "omnirush": "src/bin.js"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=22.19.0"
   },
   "scripts": {
     "test": "node --test",
-    "test:bun": "if [ -x .runtime/bin/bun ]; then .runtime/bin/bun test test/; else bun test test/; fi",
+    "test:bun": "if [ -x .runtime/bin/bun ]; then .runtime/bin/bun test --timeout 300000 test/; else bun test --timeout 300000 test/; fi",
     "build:mcp": "node scripts/build-mcp-bundle.js",
     "postinstall": "node scripts/patch-pi-branding.js && node scripts/postinstall.js"
   },

package/scripts/build-all-packages.py

@@ -49,10 +49,17 @@ def find_bin(root, names):
                 return os.path.join(dirpath, f)
     return None
 
+RELEASE_NAME = {"darwin-aarch64": "macos-arm64", "darwin-x64": "macos-x64"}
+
 for plat, cfg in PLATFORMS.items():
     if ONLY and plat not in ONLY:
         continue
-    out_pre = f"omnirush-cli-{plat}.tar.gz" if plat == "linux-x64" else f"omnirush-cli-{plat}.zip"
+    # Release artifacts use the canonical names the attach list and the
+    # smoke expect (darwin-* must ship as macos-*).
+    rel = RELEASE_NAME.get(plat, plat)
+    out_pre = os.path.join(
+        WORK, f"omnirush-cli-{rel}.tar.gz" if plat.startswith("linux") else f"omnirush-cli-{rel}.zip"
+    )
     if os.path.exists(out_pre) and not ONLY:
         print("skip (built):", plat)
         continue
@@ -65,6 +72,21 @@ for plat, cfg in PLATFORMS.items():
     shutil.copytree(os.path.join(REPO, "src"), os.path.join(stage, "src"))
     shutil.copytree(os.path.join(REPO, "assets"), os.path.join(stage, "assets"))
     shutil.copy2(os.path.join(REPO, "package.json"), os.path.join(stage, "package.json"))
+    # Archives must run WITHOUT npm install: vendor the pinned agent
+    # (it carries its own bundled node_modules) plus the scripts the
+    # launcher imports, and apply the branding patch to the vendored
+    # tree at package time (postinstall never runs for archives).
+    nm_src = os.path.join(REPO, "node_modules", "@earendil-works")
+    if not os.path.isdir(nm_src):
+        raise SystemExit(f"missing vendored agent runtime: {nm_src} (run npm install first)")
+    shutil.copytree(nm_src, os.path.join(stage, "node_modules", "@earendil-works"), symlinks=True)
+    shutil.copytree(os.path.join(REPO, "scripts"), os.path.join(stage, "scripts"))
+    import subprocess
+
+    subprocess.run(
+        ["node", os.path.join(stage, "scripts", "patch-pi-branding.js")],
+        cwd=stage, check=True,
+    )
     exe = "bun.exe" if plat == "windows-x64" else "bun"
     bun_plat = plat.replace("arm64", "aarch64")
     bunzip = fetch(f"https://github.com/oven-sh/bun/releases/download/{BUN_VER}/bun-{bun_plat}.zip")
@@ -86,13 +108,13 @@ for plat, cfg in PLATFORMS.items():
     assert fb and rb, f"fd/rg not found for {plat}"
     shutil.copy2(fb, os.path.join(stage, ".runtime", "bin", os.path.basename(fb)))
     shutil.copy2(rb, os.path.join(stage, ".runtime", "bin", os.path.basename(rb)))
-    if plat == "linux-x64":
-        out = f"omnirush-cli-{plat}.tar.gz"
+    if plat.startswith("linux"):
+        out = out_pre
         with tarfile.open(out, "w:gz") as t:
             t.add(stage, arcname=os.path.basename(stage))
     else:
         import zipfile as zfmod
-        with zfmod.ZipFile(f"omnirush-cli-{plat}.zip", "w", zfmod.ZIP_DEFLATED) as z:
+        with zfmod.ZipFile(out_pre, "w", zfmod.ZIP_DEFLATED) as z:
             for dirpath, _, files in os.walk(stage):
                 for f in files:
                     full = os.path.join(dirpath, f)

package/scripts/smoke-packages.py

@@ -0,0 +1,127 @@
+"""Release smoke: every package must exist and the archive layout must
+be runnable WITHOUT npm install (bin.js --version executes offline).
+
+Run on the packaging host after build-all-packages.py:
+    python3 scripts/smoke-packages.py --dist "$PWD/dist"
+"""
+
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+import zipfile
+
+EXPECTED = {
+    "omnirush-cli-linux-x64.tar.gz",
+    "omnirush-cli-linux-arm64.tar.gz",
+    "omnirush-cli-macos-arm64.zip",
+    "omnirush-cli-macos-x64.zip",
+    "omnirush-cli-windows-x64.zip",
+}
+
+REQUIRED_PATHS = [
+    "package.json",
+    "src/bin.js",
+    "src/lib.js",
+    "scripts/postinstall.js",
+    "scripts/patch-pi-branding.js",
+    "assets/extensions/omnirush/index.ts",
+    "node_modules/@earendil-works/pi-coding-agent/package.json",
+    "node_modules/@earendil-works/pi-coding-agent/dist",
+    ".runtime/bin/bun",
+]
+
+
+def fail(message):
+    print(f"SMOKE FAIL: {message}")
+    sys.exit(1)
+
+
+def archive_names(path, is_tgz):
+    names = set()
+    if is_tgz:
+        with tarfile.open(path, "r:gz") as t:
+            names = set(t.getnames())
+    else:
+        with zipfile.ZipFile(path) as z:
+            names = set(z.namelist())
+    root = min(names, key=len).split("/")[0]
+    return names, root
+
+
+def has_entry(names, root, required):
+    """True if `required` exists as an entry OR any entry beneath it
+    (zips carry file paths only — no directory entries)."""
+    full = f"{root}/{required}"
+    return any(n == full or n == f"{full}/" or n.startswith(f"{full}/") for n in names)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--dist", default=os.path.join(os.getcwd(), "dist"))
+    args = ap.parse_args()
+    dist = os.path.abspath(args.dist)
+
+    for name in sorted(EXPECTED):
+        path = os.path.join(dist, name)
+        if not os.path.exists(path):
+            fail(f"missing artifact {name}")
+        size_mb = os.path.getsize(path) / 1e6
+        if size_mb < 40:
+            fail(f"{name} suspiciously small ({size_mb:.1f} MB)")
+        print(f"ok (size): {name} {size_mb:.0f} MB")
+
+    repo_version = json.load(open(os.path.join(dist, "..", "package.json")))["version"] \
+        if os.path.exists(os.path.join(dist, "..", "package.json")) else None
+
+    work = tempfile.mkdtemp(prefix="omnirush-smoke-")
+    try:
+        # linux-x64: full behavioral smoke — extract and run bin.js offline.
+        tgz = os.path.join(dist, "omnirush-cli-linux-x64.tar.gz")
+        names, root = archive_names(tgz, is_tgz=True)
+        for required in REQUIRED_PATHS:
+            if not has_entry(names, root, required):
+                fail(f"linux-x64 archive lacks {required}")
+        with tarfile.open(tgz, "r:gz") as t:
+            t.extractall(work)
+        extracted = os.path.join(work, root)
+        env = dict(os.environ)
+        env.update({"HOME": work, "OMNIRUSH_NO_UPDATE_CHECK": "1"})
+        node = shutil.which("node")
+        if not node:
+            fail("node not on PATH for the smoke run")
+        proc = subprocess.run(
+            [node, os.path.join(extracted, "src", "bin.js"), "--version"],
+            env=env, capture_output=True, text=True, timeout=120, cwd=work,
+        )
+        if proc.returncode != 0:
+            fail(f"bin.js --version failed ({proc.returncode}): {proc.stderr[-400:]}")
+        out = proc.stdout.strip()
+        if not out.startswith("omnirush "):
+            fail(f"unexpected --version output: {out[:120]}")
+        if repo_version and repo_version not in out:
+            fail(f"--version {out!r} does not carry the repo version {repo_version}")
+        print(f"ok (run): linux-x64 bin.js --version -> {out}")
+
+        # Remaining archives: structural smoke only (cross-packaged OSes).
+        for name in sorted(EXPECTED):
+            if name == "omnirush-cli-linux-x64.tar.gz":
+                continue
+            is_tgz = name.endswith(".tar.gz")
+            names, root = archive_names(os.path.join(dist, name), is_tgz=is_tgz)
+            bun_name = ".runtime/bin/bun.exe" if "windows" in name else ".runtime/bin/bun"
+            for required in REQUIRED_PATHS[:len(REQUIRED_PATHS) - 1] + [bun_name]:
+                if not has_entry(names, root, required):
+                    fail(f"{name} lacks {required}")
+            print(f"ok (structure): {name}")
+    finally:
+        shutil.rmtree(work, ignore_errors=True)
+    print("SMOKE PASS")
+
+
+if __name__ == "__main__":
+    main()