omnirush 0.3.2 → 0.4.1

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

@@ -22,7 +22,9 @@
 //      node_modules, build outputs, .git (full reproducibility) — with
 //      ONLY the secrets denylist (.env*, keys, credentials, private
 //      keys) excluded. Binaries are captured (base64), symlinks are
-//      stored as records (path + target) so replay recreates them, and
+//      stored as {path, content: <target>, encoding: "symlink"} so the
+//      backend's text-content validation accepts them and replay
+//      recreates them, and
 //      the POSIX mode/executable bit rides each file entry for replay
 //      (stored-and-ignored on Windows). Redaction also scrubs
 //      credentials embedded in URLs (e.g. .git/config remotes).
@@ -105,13 +107,13 @@ type SnapshotType = "start" | "change" | "trace" | "end";
 
 export type CollectorFile = {
   path: string;
-  /** utf8 text (default) or base64 when encoding is "base64". Absent for
-   *  symlink records, which carry `target` instead. */
-  content?: string;
-  /** Absent = utf8 text. "base64" for binary content. */
-  encoding?: "base64";
-  /** Symlink record: the link target as stored on disk. */
-  target?: string;
+  /** utf8 text by default. For binaries: base64. For symlinks: the link
+   *  target verbatim (the backend requires text content on every file
+   *  entry, so symlink records are text entries with a marker). */
+  content: string;
+  /** Absent = utf8 text. "base64" for binary content, "symlink" for
+   *  symlink records (content = link target). */
+  encoding?: "base64" | "symlink";
   /** POSIX mode bits (octal string, e.g. "755"). Absent for symlinks. */
   mode?: string;
 };
@@ -127,8 +129,7 @@ export type ChangeJournalEntry = {
   path: string;
   status: "present" | "deleted";
   content?: string;
-  encoding?: "base64";
-  target?: string;
+  encoding?: "base64" | "symlink";
   mode?: string;
   /** Present when the record carries one slice of a bigger file. */
   slice?: { index: number; total: number; bytes: number; sha256: string };
@@ -587,9 +588,11 @@ async function readContentChunks(absolute: string, size: number): Promise<Conten
  * text is redacted, binaries base64-encoded ("encoding": "base64"), and
  * the POSIX mode rides along (octal string) so replay can restore the
  * executable bit (stored-and-ignored on Windows). Content bigger than
- * MAX_SLICE_BYTES is sliced (see buildFileEntries). Symlinks become
- * records { path, target } (target verbatim; replay recreates the link).
- * Returns [] when the entry vanished or is a special file.
+ * MAX_SLICE_BYTES is sliced (see buildFileEntries). Symlinks become text
+ * entries { path, content: <target>, encoding: "symlink" } — the
+ * backend's per-entry validation requires text content, and replay
+ * recreates the actual link from the target. Returns [] when the entry
+ * vanished or is a special file.
  */
 async function readWorkspaceEntries(root: string, path: string): Promise<CollectorFile[]> {
   try {
@@ -598,7 +601,7 @@ async function readWorkspaceEntries(root: string, path: string): Promise<Collect
     const file = await lstat(absolute);
     if (file.isSymbolicLink()) {
       const target = await readlink(absolute);
-      return [{ path, target }];
+      return [{ path, content: target, encoding: "symlink" }];
     }
     if (!file.isFile()) return [];
     const mode = file.mode & 0o777;
@@ -672,7 +675,7 @@ export async function collectFiles(
   for (const path of paths) {
     if (used >= byteLimit) break;
     for (const file of await readWorkspaceEntries(root, path)) {
-      const size = Buffer.byteLength(file.content ?? file.target ?? "");
+      const size = Buffer.byteLength(file.content ?? "");
       if (used + size > byteLimit) continue;
       files.push(file);
       used += size;
@@ -778,7 +781,7 @@ export async function packEnvelopeParts(
       const lone = batchToFit.pop()!;
       log?.("OmniRush file exceeds the upload limits and cannot be shipped as a single part; skipped", {
         path: lone.path,
-        bytes: Buffer.byteLength(lone.content ?? lone.target ?? ""),
+        bytes: Buffer.byteLength(lone.content ?? ""),
       });
       return { measured: null, carry };
     }
@@ -810,6 +813,26 @@ export async function packEnvelopeParts(
 }
 
 export class WorkspaceCollector {
+  /**
+   * Bounded first-chunk read of an error response body for diagnostics:
+   * at most 512 bytes, decoded and whitespace-collapsed. Never throws.
+   * Error bodies are small JSON from the manager; the bound exists so a
+   * pathological response cannot balloon a log line (or memory).
+   */
+  private static async errorBodySnippet(response: any): Promise<string> {
+    try {
+      const reader = response?.body?.getReader?.();
+      if (!reader) return "";
+      const { value } = await reader.read();
+      reader.cancel().catch(() => undefined);
+      if (!value) return "";
+      const text = Buffer.from(value).toString("utf8").replace(/\s+/g, " ").trim();
+      return text.length > 200 ? `${text.slice(0, 200)}…` : text;
+    } catch {
+      return "";
+    }
+  }
+
   private readonly collectUrl: string | null;
   private token: string;
   private readonly fetcher: typeof fetch;
@@ -1110,9 +1133,16 @@ export class WorkspaceCollector {
       if (!options?.force && Math.floor(file.mtimeMs) <= state.watcherStartedAtMs) return;
       state.knownPaths.add(path);
       if (file.isSymbolicLink()) {
-        // Symlink record: path + target so replay recreates the link.
+        // Symlink record: the target as text content with the symlink
+        // encoding — replay recreates the actual link from it.
         const target = await readlink(absolute);
-        entry = { path, at: new Date().toISOString(), status: "present", target };
+        entry = {
+          path,
+          at: new Date().toISOString(),
+          status: "present",
+          content: target,
+          encoding: "symlink",
+        };
       } else if (!file.isFile()) {
         return;
       } else {
@@ -1171,7 +1201,7 @@ export class WorkspaceCollector {
     // identical re-capture adds upload fat without a state change. The
     // replay result is identical either way.
     const journalSignature = (record: ChangeJournalEntry) =>
-      JSON.stringify([record.status, record.content, record.encoding, record.target, record.mode]);
+      JSON.stringify([record.status, record.content, record.encoding, record.mode]);
     const pendingRecords = [entry, ...records];
     for (const record of pendingRecords) {
       let duplicate = false;
@@ -1247,7 +1277,7 @@ export class WorkspaceCollector {
       return { files, payload, compressed: await compressZstd(payload) };
     };
     await this.packAndUpload(state, snapshotType, this.iterTreeFiles(state, paths), {
-      sizeOf: (file) => Buffer.byteLength(file.content ?? file.target ?? "") + file.path.length + 64,
+      sizeOf: (file) => Buffer.byteLength(file.content ?? "") + file.path.length + 64,
       measure,
       upload: async (measured) => {
         const ok = await this.uploadEnvelope(state, snapshotType, measured.files, measured);
@@ -1258,12 +1288,12 @@ export class WorkspaceCollector {
         this.log("warn", "OmniRush file exceeds the upload rail and cannot be shipped as a single part; skipped", {
           sessionId: state.id,
           path: file.path,
-          bytes: Buffer.byteLength(file.content ?? file.target ?? ""),
+          bytes: Buffer.byteLength(file.content ?? ""),
         });
         state.trace.push({
           at: new Date().toISOString(),
           type: "file.unshippable",
-          data: { path: file.path, bytes: Buffer.byteLength(file.content ?? file.target ?? "") },
+          data: { path: file.path, bytes: Buffer.byteLength(file.content ?? "") },
         });
       },
     });
@@ -1292,9 +1322,7 @@ export class WorkspaceCollector {
       const slicedByPath = new Map<string, ChangeJournalEntry[]>();
       for (const entry of entries) {
         if (entry.status !== "present") continue;
-        if (entry.target !== undefined) {
-          lastByPath.set(entry.path, { path: entry.path, target: entry.target });
-        } else if (entry.slice) {
+        if (entry.slice) {
           const group = slicedByPath.get(entry.path) ?? [];
           group.push(entry);
           slicedByPath.set(entry.path, group);
@@ -1346,7 +1374,7 @@ export class WorkspaceCollector {
     const bySequence = () => ({ id: state.id, segment: state.segment, resumed: state.resumed, sequence: state.sequence });
     await this.packAndUpload(state, "change", snapshot, {
       sizeOf: (entry) =>
-        Buffer.byteLength(entry.content ?? entry.target ?? "") + entry.path.length + 96,
+        Buffer.byteLength(entry.content ?? "") + entry.path.length + 96,
       measure: async (batch) => {
         const files = filesForSlice(batch);
         const payload = buildEnvelopePayload(bySequence(), "change", files);
@@ -1361,7 +1389,7 @@ export class WorkspaceCollector {
         this.log("warn", "OmniRush change record exceeds the upload limits and cannot be shipped; skipped", {
           sessionId: state.id,
           path: entry.path,
-          bytes: Buffer.byteLength(entry.content ?? entry.target ?? ""),
+          bytes: Buffer.byteLength(entry.content ?? ""),
         });
         state.trace.push({
           at: new Date().toISOString(),
@@ -1561,8 +1589,15 @@ export class WorkspaceCollector {
       }
     }
     if (!response.ok) {
-      await response.body?.cancel().catch(() => undefined);
-      throw new Error(`collector upload failed with status ${response.status}`);
+      // Diagnosable from a tester's screenshot alone: status, context,
+      // and (bounded) the server's error body. A 401 here means the
+      // refresh-retry above also failed — the caller should re-login.
+      const snippet = await WorkspaceCollector.errorBodySnippet(response);
+      throw new Error(
+        `collector upload failed: HTTP ${response.status}` +
+          `${snippet ? ` — ${snippet}` : ""}` +
+          ` (session ${state.id}, ${snapshotType}, sequence ${state.sequence + 1})`,
+      );
     }
     state.sentBytes += payload.length;
     state.sequence += 1;

package/assets/extensions/omnirush/collector.ts

@@ -42,10 +42,18 @@ export default function (pi: any) {
           return ok ? refresher.auth?.accessToken ?? null : null;
         }
       : undefined,
-    log: (level, message) => {
+    log: (level, message, attributes) => {
       if (level === "warn") {
         try {
-          process.stderr.write(`omnirush collector: ${message}\n`);
+          // Attributes carry the diagnosis (HTTP status, error message,
+          // path, byte counts) — without them a remote failure is
+          // undebuggable ("collection operation failed" and nothing
+          // else). Attribute values are telemetry-safe (ids, sizes,
+          // error strings; never tokens).
+          const detail = attributes && Object.keys(attributes).length > 0
+            ? ` ${JSON.stringify(attributes)}`
+            : "";
+          process.stderr.write(`omnirush collector: ${message}${detail}\n`);
         } catch {
           /* stderr may be closed late in shutdown */
         }

package/assets/extensions/omnirush/commands.ts

@@ -1,48 +1,173 @@
 /**
- * Omnirush commands: /grant (today's token grant + usage) and /verify
- * (prove the served model is genuine — full implementation lands with the
- * gateway's model-attestation endpoint), plus the footer status line that
- * keeps grant/model info visible while the agent runs.
+ * Omnirush commands:
+ *   /grant   today's token grant + usage (headers when a request ran,
+ *            /device/me otherwise)
+ *   /usage   full usage from the manager (grant date, token counters,
+ *            devices)
+ *   /status  one-screen session summary (identity, model/effort, grant,
+ *            collector, origin, version)
+ *   /verify  prove the served model is genuine — full implementation
+ *            lands with the gateway's model-attestation endpoint (M2)
+ * plus the footer status line that keeps grant/model info visible while
+ * the agent runs.
+ *
+ * Handler contract (pi): handler(args: string, ctx: ExtensionCommandContext)
+ * — the FIRST parameter is the argument string, ctx comes SECOND. Getting
+ * this wrong silently no-ops the command (ctx.ui is undefined on a string),
+ * which is exactly how /grant and /verify broke the first time.
  */
 
+import { readSessionLedger, SESSION_LEDGER_FILE } from "./collector-lib";
+import { deviceMe, omniDir, resolveOrigin } from "./auth";
+import { sharedRefresher } from "./refresh";
+import { formatCollectorLine, formatStatusLines } from "./status-lib";
+import {
+  formatDeviceLines,
+  formatGrantLines,
+  formatGrantStatusLine,
+  formatTokenCount,
+  formatUsageDetails,
+  formatUsageSummary,
+  gatewayUsage,
+  grantFromUsage,
+} from "./usage";
+
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { deviceMe, resolveOrigin } from "./auth";
-import { formatGrantLines, formatGrantStatusLine, gatewayUsage } from "./usage";
 
-/** Fetch the signed-in identity + server-side usage, best effort. */
-async function fetchIdentity(): Promise<any> {
-  const token = (process.env.OMNIRUSH_TOKEN || "").trim();
-  if (!token) return null;
+const CLI_VERSION = (process.env.OMNIRUSH_VERSION || "").trim() || "unknown";
+
+interface MeResult {
+  me: any;
+  error?: string;
+}
+
+/**
+ * Fetch the signed-in identity + server-side usage with the broker
+ * pattern: 401 triggers one single-flight refresh (both tokens rotate,
+ * persisted 0600) and a single retry with the rotated token. Never
+ * throws; errors come back as `error` strings safe to display.
+ */
+async function fetchMe(): Promise<MeResult> {
+  const origin = resolveOrigin(process.env);
+  const refresher = sharedRefresher();
+  // Prefer the refresher's live token — it is already rotated after any
+  // in-flight 401 recovery — and fall back to the launcher-provided one.
+  const token = refresher.auth?.accessToken || (process.env.OMNIRUSH_TOKEN || "").trim();
+  if (!token) return { me: null, error: "not signed in — run `omnirush login` first" };
   try {
-    return await deviceMe(resolveOrigin(process.env), {
-      accessToken: token,
-      fetchImpl: globalThis.fetch,
-    });
-  } catch {
-    return null;
+    let me = await deviceMe(origin, { accessToken: token, fetchImpl: globalThis.fetch });
+    if (me !== null) return { me };
+    // 401: single-flight refresh, retry once with the rotated token.
+    const refreshed = await refresher.refresh(token).catch(() => false);
+    const next = refresher.auth?.accessToken;
+    if (refreshed && next && next !== token) {
+      me = await deviceMe(origin, { accessToken: next, fetchImpl: globalThis.fetch });
+      if (me !== null) return { me };
+    }
+    return { me: null, error: "credentials rejected — run `omnirush login` again" };
+  } catch (error) {
+    return { me: null, error: `manager unreachable (${error?.message ?? error})` };
   }
 }
 
+function identityOf(me: any): string | null {
+  if (!me || typeof me !== "object") return null;
+  for (const key of ["email", "device_name", "user_id", "id"] as const) {
+    const value = me[key];
+    if (typeof value === "string" && value) return value;
+  }
+  return null;
+}
+
+/** The grant summary string shared by /grant and /status, or null. */
+function grantSummary(me: any): { text: string; date?: string } | null {
+  const usage = gatewayUsage();
+  const fromHeaders = grantFromUsage(usage);
+  const meUsage = me?.usage ?? null;
+  const limit = fromHeaders?.limitTokens ?? Number(meUsage?.token_limit);
+  const remaining = fromHeaders?.remainingTokens ?? Number(meUsage?.remaining_tokens);
+  if (!Number.isFinite(limit) || !Number.isFinite(remaining)) return null;
+  const used = Number(meUsage?.used_tokens);
+  const usedPart = Number.isFinite(used) ? ` (used ${formatTokenCount(used)})` : "";
+  return {
+    text: `${formatTokenCount(remaining)} of ${formatTokenCount(limit)} tokens remaining${usedPart}`,
+    date: typeof meUsage?.grant_date === "string" ? meUsage.grant_date : undefined,
+  };
+}
+
+function notify(ctx: any, text: string, level: "info" | "error" = "info"): void {
+  ctx?.ui?.notify?.(text, level);
+}
+
 export default function (pi: ExtensionAPI) {
   pi.registerCommand("grant", {
     description: "Show today's Omnirush token grant and usage",
-    handler: async (ctx: any) => {
+    handler: async (_args: string, ctx: any) => {
       const usage = gatewayUsage();
-      const me = await fetchIdentity();
+      const { me } = await fetchMe();
       const sessionId = ctx?.sessionManager?.getSessionId?.() ?? undefined;
       const lines = formatGrantLines({ usage, me, sessionId });
-      ctx.ui?.notify?.(
-        ["Omnirush usage:", ...lines.map((line) => `  ${line}`)].join("\n"),
-      );
+      notify(ctx, ["Omnirush usage:", ...lines.map((line) => `  ${line}`)].join("\n"));
+    },
+  });
+
+  pi.registerCommand("usage", {
+    description: "Show detailed Omnirush usage from the manager (counters + devices)",
+    handler: async (_args: string, ctx: any) => {
+      const { me, error } = await fetchMe();
+      if (!me) {
+        notify(ctx, `Omnirush usage unavailable: ${error}`, "error");
+        return;
+      }
+      const lines = [
+        "Omnirush usage (from the manager):",
+        ...formatUsageDetails({ me }).map((line) => `  ${line}`),
+      ];
+      const summary = formatUsageSummary(me);
+      if (summary) lines.push(`  summary: ${summary}`);
+      lines.push("", ...formatDeviceLines(me));
+      notify(ctx, lines.join("\n"));
+    },
+  });
+
+  pi.registerCommand("status", {
+    description: "Show the Omnirush session status (identity, model, grant, collector)",
+    handler: async (_args: string, ctx: any) => {
+      const { me } = await fetchMe();
+      const usage = gatewayUsage();
+      const grant = grantSummary(me);
+      const sessionId = String(ctx?.sessionManager?.getSessionId?.() ?? "");
+      let record = null;
+      try {
+        const ledger = await readSessionLedger(`${omniDir()}/${SESSION_LEDGER_FILE}`);
+        record = ledger.sessions[sessionId] ?? null;
+      } catch {
+        /* collector state is best effort */
+      }
+      const model = ctx?.model;
+      const statusLines = formatStatusLines({
+        signedIn: Boolean(me),
+        identity: identityOf(me),
+        model: model ? `${model.provider ?? "omnirush"}/${model.id}` : null,
+        thinkingLevel: typeof ctx?.thinkingLevel === "string" ? ctx.thinkingLevel : null,
+        effort: usage?.["x-omnirush-effort"] ?? null,
+        grant: grant?.text ?? null,
+        grantDate: grant?.date ?? null,
+        collector: { sessionId, record },
+        origin: resolveOrigin(process.env),
+        version: CLI_VERSION,
+      });
+      notify(ctx, ["Omnirush status:", ...statusLines.map((line) => `  ${line}`)].join("\n"));
     },
   });
 
   pi.registerCommand("verify", {
     description: "Verify the model serving your requests is genuine GPT-6 Astra",
-    handler: async (ctx: any) => {
+    handler: async (_args: string, ctx: any) => {
       // M2: POST /omnirush/verify → signed attestation compared against
       // observed model behavior. v0 placeholder.
-      ctx.ui?.notify?.(
+      notify(
+        ctx,
         "verify: model attestation arrives with the gateway lane (M2).",
       );
     },

package/assets/extensions/omnirush/index.ts

@@ -3,10 +3,13 @@
 // pi discovers either extensions/*.ts files or extensions/<dir>/index.ts —
 // this index makes the whole omnirush extension directory load as one
 // extension (without it, none of these files were ever registered).
+// EVERY module that registers commands/tools/handlers must be wired here:
+// a module left out of this list is silently dead in sessions.
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import collector from "./collector";
 import commands from "./commands";
+import mcp from "./mcp";
 import recorder from "./recorder";
 import sota from "./sota";
 
@@ -15,4 +18,5 @@ export default function (pi: ExtensionAPI) {
   recorder(pi as any);
   sota(pi as any);
   collector(pi as any);
+  mcp(pi as any);
 }