@phnx-labs/agents-cli 1.22.49 → 1.22.51

package/dist/lib/traces/sync.js

@@ -9,6 +9,15 @@
  * Sync gate: `sessions.db` `file_mtime_ms` is the source of truth.  A ledger
  * at `getRuntimeStateDir()/traces-sync.json` records the last sync timestamp
  * per device so re-runs skip unchanged sessions.
+ *
+ * Retry ledger: the mtime watermark alone cannot retry failures — a later-mtime
+ * success advances it past an earlier failed row, which the next run's
+ * `file_mtime_ms > watermark` filter then skips forever. So the same ledger also
+ * records the identity + typed evidence of each failed session (`failures`), and
+ * the row query unions those retry-worthy ids back in regardless of the watermark
+ * (PHNX-3267). Failures are typed so a gone transcript (`transcript-unavailable`,
+ * expected history, aged out after a TTL and never re-read) is distinguished from a
+ * real parse/upload failure (retried until it resolves).
  */
 import fs from 'node:fs';
 import os from 'node:os';
@@ -39,17 +48,60 @@ export async function syncTraces(opts = {}) {
     // NULL machine rows are legacy local sessions (pre-machine-field). A dry-run
     // ignores the incremental watermark so the export covers every session.
     const sinceMtime = dryRun ? 0 : (ledger.lastSyncMtime ?? 0);
-    const rows = db
+    const watermarkRows = db
         .prepare('SELECT * FROM sessions WHERE (machine = ? OR machine IS NULL) AND file_mtime_ms > ? ORDER BY file_mtime_ms ASC')
         .all(device, sinceMtime);
+    // The watermark alone loses failures: a later-mtime success advances it past an
+    // earlier failed row, which the `file_mtime_ms > sinceMtime` filter then skips
+    // forever. So union in the sessions we explicitly recorded as retry-worthy
+    // failures (parse/upload — a `transcript-unavailable` file is gone, re-reading it
+    // wastes work) regardless of where the watermark sits. A dry-run ignores the
+    // ledger entirely and already selects every row.
+    const retryIds = dryRun
+        ? []
+        : (ledger.failures ?? [])
+            .filter((f) => f.kind !== 'transcript-unavailable')
+            .map((f) => f.id);
+    let rows = watermarkRows;
+    if (retryIds.length) {
+        const seen = new Set(watermarkRows.map((r) => r.id));
+        const retryRows = [];
+        for (let i = 0; i < retryIds.length; i += 400) {
+            const chunk = retryIds.slice(i, i + 400);
+            retryRows.push(...db
+                .prepare(`SELECT * FROM sessions WHERE (machine = ? OR machine IS NULL) AND id IN (${chunk.map(() => '?').join(',')})`)
+                .all(device, ...chunk));
+        }
+        const stranded = retryRows.filter((r) => !seen.has(r.id));
+        rows = [...watermarkRows, ...stranded].sort((a, b) => (a.file_mtime_ms ?? 0) - (b.file_mtime_ms ?? 0));
+    }
     const limited = opts.limit !== undefined ? rows.slice(0, opts.limit) : rows;
     const knownSecrets = knownSecretValuesFromEnv();
     let uploaded = 0;
     let skipped = 0;
-    let errors = 0;
-    // Advance the watermark only to the max mtime of successfully uploaded sessions
-    // so failures are retried on the next run.
+    let transcriptUnavailable = 0;
+    let parseFailed = 0;
+    let uploadFailed = 0;
+    // Advance the watermark only to the max mtime of successfully uploaded sessions.
+    // On its own this does NOT retry failures (a later success strands earlier ones);
+    // the failure ledger below is what actually re-selects them next run.
     let maxSuccessMtime = ledger.lastSyncMtime ?? 0;
+    // Carry prior failures forward by id so a stranded row's identity + evidence
+    // survives across syncs. A success removes the id; a repeat failure updates it.
+    const now = Date.now();
+    const failures = new Map((ledger.failures ?? []).map((f) => [f.id, f]));
+    const recordFailure = (row, kind, err) => {
+        const raw = err instanceof Error ? err.message : String(err);
+        const prev = failures.get(row.id);
+        failures.set(row.id, {
+            id: row.id,
+            mtimeMs: row.file_mtime_ms ?? 0,
+            kind,
+            detail: redactSecrets(raw.split('\n')[0] ?? '', knownSecrets).slice(0, 200),
+            firstSeen: prev?.firstSeen ?? now,
+            attempts: (prev?.attempts ?? 0) + 1,
+        });
+    };
     if (dryRun && outDir) {
         fs.mkdirSync(path.join(outDir, 'sessions'), { recursive: true });
     }
@@ -65,8 +117,17 @@ export async function syncTraces(opts = {}) {
             const events = parseSession(row.file_path, row.agent);
             traj = buildTrajectory(events, session, { redact: true, knownSecrets });
         }
-        catch {
-            errors++;
+        catch (err) {
+            // A gone/unreadable transcript is expected history, not a retry-worthy error;
+            // a file that IS present but failed to parse is a real problem to retry.
+            if (!fs.existsSync(row.file_path)) {
+                transcriptUnavailable++;
+                recordFailure(row, 'transcript-unavailable', err);
+            }
+            else {
+                parseFailed++;
+                recordFailure(row, 'parse-failed', err);
+            }
             continue;
         }
         try {
@@ -78,9 +139,11 @@ export async function syncTraces(opts = {}) {
             }
             uploaded++;
             maxSuccessMtime = Math.max(maxSuccessMtime, row.file_mtime_ms ?? 0);
+            failures.delete(row.id); // recovered — drop it from the retry set
         }
-        catch {
-            errors++;
+        catch (err) {
+            uploadFailed++;
+            recordFailure(row, 'upload-failed', err);
         }
     }
     if (!opts.skipIndex) {
@@ -114,9 +177,32 @@ export async function syncTraces(opts = {}) {
     }
     // A dry-run never advances the incremental watermark: it is a read-only export.
     if (!dryRun) {
-        writeSyncLedger({ lastSyncMtime: maxSuccessMtime });
+        // Age out long-unavailable transcripts so a corpus of deleted files cannot grow
+        // the retry set without bound; parse/upload failures persist until they resolve.
+        const persistedFailures = [...failures.values()].filter((f) => !(f.kind === 'transcript-unavailable' &&
+            now - f.firstSeen > TRANSCRIPT_UNAVAILABLE_TTL_MS));
+        writeSyncLedger({ lastSyncMtime: maxSuccessMtime, failures: persistedFailures });
+        // Register the Phoenix session with Prix so the console can fetch live data
+        // (PHNX-3257). Fire-and-forget — a link failure must not block sync.
+        // Managed backend only: the BYO path's token is a static write token that
+        // bypasses Phoenix auth (resolveTracesBackend's userId: 'byo' sentinel) —
+        // it is not a Phoenix identity credential and must never be sent to Prix.
+        if (backend && backend.userId !== 'byo') {
+            fetch('https://api.prix.dev/api/v1/traces/link', {
+                method: 'POST',
+                headers: { Authorization: `Bearer ${backend.token}` },
+                signal: AbortSignal.timeout(8_000),
+            }).catch(() => { });
+        }
     }
-    return { uploaded, skipped, errors };
+    return {
+        uploaded,
+        skipped,
+        errors: transcriptUnavailable + parseFailed + uploadFailed,
+        transcriptUnavailable,
+        parseFailed,
+        uploadFailed,
+    };
 }
 function percentile(values, ratio) {
     if (values.length === 0)
@@ -385,6 +471,13 @@ async function putIndexShard(backend, device, owner, shard) {
         throw new Error(`PUT ${url} → ${res.status}`);
     }
 }
+/**
+ * A `transcript-unavailable` failure is kept (so its count stays reportable) but
+ * not retried, because re-reading a file that is gone wastes work. Age it out of
+ * the ledger after this window so a corpus of long-deleted transcripts cannot grow
+ * the failure set without bound.
+ */
+const TRANSCRIPT_UNAVAILABLE_TTL_MS = 14 * 24 * 60 * 60 * 1000;
 function ledgerPath() {
     return path.join(getRuntimeStateDir(), 'traces-sync.json');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.49",
+  "version": "1.22.51",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",
@@ -36,11 +36,11 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/phnx-labs/agents-cli.git"
+    "url": "git+https://github.com/phnx-labs/agi-cli.git"
   },
   "homepage": "https://agents-cli.sh",
   "bugs": {
-    "url": "https://github.com/phnx-labs/agents-cli/issues"
+    "url": "https://github.com/phnx-labs/agi-cli/issues"
   },
   "scripts": {
     "build": "tsc && rm -rf 'dist/lib/secrets/AgentsKeychain.app' 'dist/lib/secrets/Agents CLI.app' 'dist/lib/menubar/MenubarHelper.app' && ([ -f 'bin/agents-macos' ] && mkdir -p dist/bin && cp -f 'bin/agents-macos' 'dist/bin/agents' && chmod 755 'dist/bin/agents' || true)",