@prohost/cli 0.10.2 → 0.10.4

package/CHANGELOG.md

@@ -4,6 +4,29 @@ Versions follow [semver](https://semver.org/). Publishing is automated: merging
 a version bump to `main` triggers `.github/workflows/npm-publish-cli.yml`, which
 builds via `prepack`, runs the suite, publishes, and tags `cli-v<version>`.
 
+## 0.10.4
+
+- **A day's rebuilt totals wait for its 0.10.1 rows to land.** If the server
+  takes the rows 0.10.1 never uploaded only in part (a throttle, or a partial
+  acceptance), the rebuilt rows for that (day, login) are held back until those
+  rows are accepted or permanently skipped. Sending the rebuild first could let
+  the stale rows, retried on a later tick, overwrite the right total.
+
+## 0.10.3
+
+Two fixes to the 0.10.2 repository attribution.
+
+- **A bare repository is named without `.git`.** A session whose working
+  directory is a bare repository (`tools.git`, with `HEAD`, `objects/` and
+  `refs/` and no `.git` inside), or a directory within it, counts toward
+  `tools`, the same name its linked worktrees get. A plain folder that only
+  ends in `.git` keeps its name.
+- **Days 0.10.1 had not uploaded yet are not lost in the upgrade.** The rows
+  of any (day, login) still waiting to upload when the scan state was rebuilt
+  are sent as 0.10.1 had them, before any rebuilt row. A day whose log has
+  since been removed, or reads back smaller, still reaches the server with
+  the total 0.10.1 counted.
+
 ## 0.10.2
 
 Token totals are attributed to the repository, not the directory a session ran in.

package/dist/usage/project.d.ts

@@ -12,6 +12,8 @@
  * 3. A `.git` file is a linked worktree (or a submodule): its `gitdir:` names
  *    `<repo>/.git/worktrees/<name>`, whose `commondir` leads back to
  *    `<repo>/.git`. A submodule's gitdir has neither, so it is its own project.
+ *    A bare repository (`HEAD`, `objects/`, `refs/` and no `.git`) is its own
+ *    root, named without a `.git` suffix: `tools.git` is `tools`.
  * 4. A directory that no longer exists (a removed worktree) is recognised by
  *    its layout — `…/.worktrees/<repo>/<name>` or `…/<repo>/.claude/worktrees/<name>`
  *    — and is otherwise named by its basename.

package/dist/usage/project.js

@@ -12,6 +12,8 @@
  * 3. A `.git` file is a linked worktree (or a submodule): its `gitdir:` names
  *    `<repo>/.git/worktrees/<name>`, whose `commondir` leads back to
  *    `<repo>/.git`. A submodule's gitdir has neither, so it is its own project.
+ *    A bare repository (`HEAD`, `objects/`, `refs/` and no `.git`) is its own
+ *    root, named without a `.git` suffix: `tools.git` is `tools`.
  * 4. A directory that no longer exists (a removed worktree) is recognised by
  *    its layout — `…/.worktrees/<repo>/<name>` or `…/<repo>/.claude/worktrees/<name>`
  *    — and is otherwise named by its basename.
@@ -69,7 +71,7 @@ function resolveProjectRoot(dir) {
     }
     return dir;
 }
-/** The main repository root when `dir` holds a `.git`; `undefined` when it holds none. */
+/** The main repository root when `dir` holds a `.git` or is a bare repository; `undefined` otherwise. */
 function repoRootAt(dir) {
     const dotGit = path.join(dir, '.git');
     let stat;
@@ -77,7 +79,7 @@ function repoRootAt(dir) {
         stat = statSync(dotGit);
     }
     catch {
-        return undefined;
+        return isBareRepo(dir) ? withoutGitSuffix(dir) : undefined;
     }
     if (stat.isDirectory())
         return dir;
@@ -115,7 +117,22 @@ function mainRepoOf(gitDir) {
     // `<repo>/.git` → `<repo>`; a bare `<repo>.git` common dir names the repo itself.
     if (path.basename(common) === '.git')
         return path.dirname(common);
-    return common.replace(/\.git$/, '') || common;
+    return withoutGitSuffix(common);
+}
+/** `<repo>.git` → `<repo>`; anything else as it is. */
+function withoutGitSuffix(dir) {
+    return dir.replace(/\.git$/, '') || dir;
+}
+/** A bare repository's own directory: `HEAD`, `objects/` and `refs/` with no worktree. */
+function isBareRepo(dir) {
+    try {
+        return (statSync(path.join(dir, 'HEAD')).isFile() &&
+            statSync(path.join(dir, 'objects')).isDirectory() &&
+            statSync(path.join(dir, 'refs')).isDirectory());
+    }
+    catch {
+        return false;
+    }
 }
 /** The repository a removed worktree path belonged to, from the two layouts agents use. */
 function removedWorktreeRepo(dir) {

package/dist/usage/scanner.d.ts

@@ -82,6 +82,13 @@ export interface ScanState {
      * the pair is replaced whole on the server, or is given up on.
      */
     legacy: Record<string, Totals>;
+    /**
+     * Bucket key → totals: the version-1 rows of pairs version 1 had not
+     * uploaded yet (still dirty). The server never took them, so its copy is
+     * not the right total; they go out as they were, before any rebuilt row,
+     * and an entry goes once the server takes its pair or never will.
+     */
+    legacyUnsent: Record<string, Totals>;
 }
 /** A dirty entry: one account's rows for one day. */
 export declare function pendingKey(day: string, accountKey: string): string;
@@ -116,7 +123,8 @@ export declare function emptyScanState(): ScanState;
 /**
  * Load the scan state. A version-1 state (per-directory projects) is replaced
  * by an empty one that re-reads every log, keeping its per-pair totals as
- * {@link ScanState.legacy}.
+ * {@link ScanState.legacy} and the rows it had not uploaded as
+ * {@link ScanState.legacyUnsent}.
  */
 export declare function loadScanState(file: string): ScanState;
 /**
@@ -137,6 +145,10 @@ export declare function bucketKey(day: string, accountKey: string, runtime: Acco
 export declare function scanUsage(accounts: ScanAccount[], state: ScanState, options?: ScanOptions): ScanSummary;
 /** The rows for the given days, in upload shape. Zero-token buckets are left out. */
 export declare function rowsForDays(state: ScanState, days: Iterable<string>): TokenRow[];
+/** The version-1 rows not yet uploaded ({@link ScanState.legacyUnsent}), in upload shape. */
+export declare function legacyUnsentRows(state: ScanState): TokenRow[];
+/** The day/account pairs ({@link pendingKey}) that still have version-1 rows to upload, zero-token ones aside. */
+export declare function legacyUnsentPairs(state: ScanState): Set<string>;
 /** The rows for the given `day|accountKey` pairs, in upload shape. */
 export declare function rowsForPending(state: ScanState, pairs: Iterable<string>): TokenRow[];
 /** One `POST /v1/usage/token-totals` body's rows, and what it says about each (day, account) pair. */

package/dist/usage/scanner.js

@@ -65,7 +65,7 @@ export function pendingDays(state) {
     return [...new Set(state.dirty.map(pendingDay))].sort();
 }
 export function emptyScanState() {
-    return { version: 2, files: {}, buckets: {}, seen: {}, dirty: [], strikes: {}, legacy: {} };
+    return { version: 2, files: {}, buckets: {}, seen: {}, dirty: [], strikes: {}, legacy: {}, legacyUnsent: {} };
 }
 const pairList = (value) => Array.isArray(value) ? value.filter((d) => typeof d === 'string' && d.includes('|')) : [];
 const isTotals = (value) => Array.isArray(value) && value.length === 4 && value.every((n) => typeof n === 'number' && Number.isFinite(n));
@@ -95,10 +95,42 @@ function legacyTotals(buckets) {
     }
     return out;
 }
+/** The version-1 buckets of the pairs it still had dirty. */
+function legacyUnsentBuckets(buckets, dirty) {
+    const out = {};
+    if (!buckets || typeof buckets !== 'object' || dirty.length === 0)
+        return out;
+    const wanted = new Set(dirty);
+    for (const [key, totals] of Object.entries(buckets)) {
+        if (!isTotals(totals) || !isBucketKey(key))
+            continue;
+        const [day, accountKey] = JSON.parse(key);
+        if (wanted.has(pendingKey(day, accountKey)))
+            out[key] = totals;
+    }
+    return out;
+}
+/** A {@link bucketKey}: `[day, accountKey, runtime, model, project]`. */
+function isBucketKey(key) {
+    try {
+        const parts = JSON.parse(key);
+        return (Array.isArray(parts) &&
+            parts.length === 5 &&
+            parts.slice(0, 4).every((part) => typeof part === 'string') &&
+            (parts[4] === null || typeof parts[4] === 'string'));
+    }
+    catch {
+        return false;
+    }
+}
+const totalsRecord = (value, validKey) => value && typeof value === 'object'
+    ? Object.fromEntries(Object.entries(value).filter(([key, t]) => validKey(key) && isTotals(t)))
+    : {};
 /**
  * Load the scan state. A version-1 state (per-directory projects) is replaced
  * by an empty one that re-reads every log, keeping its per-pair totals as
- * {@link ScanState.legacy}.
+ * {@link ScanState.legacy} and the rows it had not uploaded as
+ * {@link ScanState.legacyUnsent}.
  */
 export function loadScanState(file) {
     let parsed;
@@ -108,8 +140,13 @@ export function loadScanState(file) {
     catch {
         return emptyScanState();
     }
-    if (parsed?.version === 1)
-        return { ...emptyScanState(), legacy: legacyTotals(parsed.buckets) };
+    if (parsed?.version === 1) {
+        return {
+            ...emptyScanState(),
+            legacy: legacyTotals(parsed.buckets),
+            legacyUnsent: legacyUnsentBuckets(parsed.buckets, pairList(parsed.dirty)),
+        };
+    }
     if (parsed?.version !== 2)
         return emptyScanState();
     return {
@@ -119,9 +156,8 @@ export function loadScanState(file) {
         seen: parsed.seen && typeof parsed.seen === 'object' ? parsed.seen : {},
         dirty: pairList(parsed.dirty),
         strikes: parsed.strikes && typeof parsed.strikes === 'object' ? parsed.strikes : {},
-        legacy: parsed.legacy && typeof parsed.legacy === 'object'
-            ? Object.fromEntries(Object.entries(parsed.legacy).filter(([pair, t]) => pair.includes('|') && isTotals(t)))
-            : {},
+        legacy: totalsRecord(parsed.legacy, (pair) => pair.includes('|')),
+        legacyUnsent: totalsRecord(parsed.legacyUnsent, isBucketKey),
     };
 }
 /**
@@ -421,6 +457,10 @@ export function scanUsage(accounts, state, options = {}) {
     for (const pair of Object.keys(state.legacy))
         if (pendingDay(pair) < pass.cutoffDay)
             delete state.legacy[pair];
+    for (const key of Object.keys(state.legacyUnsent)) {
+        if (dayOfBucket(key) < pass.cutoffDay)
+            delete state.legacyUnsent[key];
+    }
     for (const pair of Object.keys(state.strikes))
         if (!state.dirty.includes(pair))
             delete state.strikes[pair];
@@ -449,9 +489,20 @@ function prune(state, cutoffDay, cutoffMs) {
 /** The rows for the given days, in upload shape. Zero-token buckets are left out. */
 export function rowsForDays(state, days) {
     const wanted = new Set(days);
+    return bucketRows(state.buckets, (key) => wanted.has(dayOfBucket(key)));
+}
+/** The version-1 rows not yet uploaded ({@link ScanState.legacyUnsent}), in upload shape. */
+export function legacyUnsentRows(state) {
+    return bucketRows(state.legacyUnsent, () => true);
+}
+/** The day/account pairs ({@link pendingKey}) that still have version-1 rows to upload, zero-token ones aside. */
+export function legacyUnsentPairs(state) {
+    return new Set(legacyUnsentRows(state).map((r) => pendingKey(r.day, r.accountKey)));
+}
+function bucketRows(buckets, include) {
     const rows = [];
-    for (const [key, totals] of Object.entries(state.buckets)) {
-        if (!wanted.has(dayOfBucket(key)) || isZero(totals))
+    for (const [key, totals] of Object.entries(buckets)) {
+        if (!include(key) || isZero(totals))
             continue;
         const [day, accountKey, runtime, model, project] = JSON.parse(key);
         rows.push({

package/dist/usage/service.d.ts

@@ -132,8 +132,20 @@ export declare class UsageService {
      * {@link REPLACE_PROBE_INTERVAL_MS}; other pairs go out meanwhile. A pair
      * whose rebuild counted less than version 1 had (a log removed or rewritten
      * since) is not sent at all: its old rows are mis-attributed but total right.
+     *
+     * First, though, the version-1 rows version 1 never uploaded
+     * (`scan.legacyUnsent`) go out as they were, without `completeDays` — the
+     * server's copy of those pairs is behind, so it is not the right total
+     * until they land. A rebuilt complete pair sent after them replaces them.
      */
     private uploadDirty;
+    /**
+     * Upload the version-1 rows version 1 had not uploaded, as plain rows (the
+     * upsert version 1 would have sent). A pair's rows go once the server takes
+     * them or never will (a permanent skip); `not_reported` waits for a report.
+     * Returns `false` when a call failed, so nothing else is sent this tick.
+     */
+    private uploadLegacyUnsent;
     /**
      * Whether the server deletes the rows a complete day no longer carries: an
      * empty body is answered with `replacedDays` only by one that does. A yes

package/dist/usage/service.js

@@ -17,7 +17,7 @@ import { Backoff } from './backoff.js';
 import { resolveUsageKey, usageStateDir, writePrivateFile } from './config.js';
 import { accountConfigDir } from './discovery.js';
 import { buildReportFrame, defaultProber, probeAccounts } from './quota.js';
-import { loadScanState, pendingAccount, pendingDay, pendingKey, rebuildFellShort, rowsForPending, saveScanState, scanUsage, uploadBatches, } from './scanner.js';
+import { loadScanState, pendingAccount, pendingDay, legacyUnsentPairs, legacyUnsentRows, pendingKey, rebuildFellShort, rowsForPending, saveScanState, scanUsage, uploadBatches, } from './scanner.js';
 export const REPORTS_PATH = '/v1/usage/reports';
 export const TOKEN_TOTALS_PATH = '/v1/usage/token-totals';
 /** Tick cadence. */
@@ -193,7 +193,8 @@ export class UsageService {
             // The state can run to megabytes; rewrite it only when a file was read.
             if (scanned.filesRead > 0)
                 saveScanState(scanStatePath(this.env), this.scan);
-            if (this.totalsBackoff.ready() && this.scan.dirty.length > 0) {
+            const pending = this.scan.dirty.length > 0 || Object.keys(this.scan.legacyUnsent).length > 0;
+            if (this.totalsBackoff.ready() && pending) {
                 result.uploadedRows = await this.uploadDirty(api, machineId, machine);
             }
         }
@@ -236,6 +237,11 @@ export class UsageService {
      * {@link REPLACE_PROBE_INTERVAL_MS}; other pairs go out meanwhile. A pair
      * whose rebuild counted less than version 1 had (a log removed or rewritten
      * since) is not sent at all: its old rows are mis-attributed but total right.
+     *
+     * First, though, the version-1 rows version 1 never uploaded
+     * (`scan.legacyUnsent`) go out as they were, without `completeDays` — the
+     * server's copy of those pairs is behind, so it is not the right total
+     * until they land. A rebuilt complete pair sent after them replaces them.
      */
     async uploadDirty(api, machineId, machine) {
         const scan = this.scan;
@@ -247,6 +253,16 @@ export class UsageService {
         for (const pair of scan.dirty)
             if (!pendingWithRows.has(pair))
                 done.add(pair);
+        if (!(await this.uploadLegacyUnsent(api, machineId, machine))) {
+            saveScanState(scanStatePath(this.env), scan);
+            return 0;
+        }
+        // A pair whose version-1 rows are still pending (throttled, partly accepted, or waiting for a
+        // report) holds its rebuilt rows back: sent now, they could be overwritten by those stale rows
+        // landing on a later tick. They stay dirty and go once the legacy rows settle.
+        const heldByLegacy = legacyUnsentPairs(scan);
+        if (heldByLegacy.size > 0)
+            ready = ready.filter((r) => !heldByLegacy.has(pendingKey(r.day, r.accountKey)));
         const legacyReady = new Set(ready.map((r) => pendingKey(r.day, r.accountKey)).filter((pair) => scan.legacy[pair] !== undefined));
         if (legacyReady.size > 0) {
             if (!(await this.serverReplacesDays(api, machineId, machine))) {
@@ -341,6 +357,41 @@ export class UsageService {
         saveScanState(scanStatePath(this.env), scan);
         return sent;
     }
+    /**
+     * Upload the version-1 rows version 1 had not uploaded, as plain rows (the
+     * upsert version 1 would have sent). A pair's rows go once the server takes
+     * them or never will (a permanent skip); `not_reported` waits for a report.
+     * Returns `false` when a call failed, so nothing else is sent this tick.
+     */
+    async uploadLegacyUnsent(api, machineId, machine) {
+        const scan = this.scan;
+        const rows = legacyUnsentRows(scan).filter((r) => this.reportedKeys.has(r.accountKey));
+        for (const batch of uploadBatches(rows)) {
+            const body = { machineId, machine, days: batch.rows };
+            const response = await postJson(api, TOKEN_TOTALS_PATH, body, undefined, true);
+            this.note(this.totalsBackoff, response);
+            const acceptance = response.ok ? parseAcceptance(response.body, batch.rows.length) : { accepted: 0 };
+            this.status.lastTotals = { ...this.callRecord(response, batch.rows.length), accepted: acceptance.accepted };
+            if (!response.ok)
+                return false;
+            const settled = new Set();
+            for (const row of batch.rows) {
+                const pair = pendingKey(row.day, row.accountKey);
+                const taken = acceptance.keys ? acceptance.keys.has(row.accountKey) : acceptance.accepted >= batch.rows.length;
+                const reason = acceptance.skipped?.get(row.accountKey);
+                if ((taken && batch.last.includes(pair)) || (reason && PERMANENT_SKIPS.has(reason)))
+                    settled.add(pair);
+                else if (!taken && reason !== 'throttled')
+                    this.reportedKeys.delete(row.accountKey);
+            }
+            for (const key of Object.keys(scan.legacyUnsent)) {
+                const [day, accountKey] = JSON.parse(key);
+                if (settled.has(pendingKey(day, accountKey)))
+                    delete scan.legacyUnsent[key];
+            }
+        }
+        return true;
+    }
     /**
      * Whether the server deletes the rows a complete day no longer carries: an
      * empty body is answered with `replacedDays` only by one that does. A yes

package/dist/version.d.ts

@@ -7,6 +7,6 @@
  * `package.json`, so a release bump that forgets this file fails the suite
  * instead of shipping a `User-Agent` that lies about which build is calling.
  */
-export declare const CLI_VERSION = "0.10.2";
+export declare const CLI_VERSION = "0.10.4";
 /** Sent on every HTTP request the CLI makes back into ProhostAI. */
-export declare const USER_AGENT = "prohost-cli/0.10.2";
+export declare const USER_AGENT = "prohost-cli/0.10.4";

package/dist/version.js

@@ -7,6 +7,6 @@
  * `package.json`, so a release bump that forgets this file fails the suite
  * instead of shipping a `User-Agent` that lies about which build is calling.
  */
-export const CLI_VERSION = '0.10.2';
+export const CLI_VERSION = '0.10.4';
 /** Sent on every HTTP request the CLI makes back into ProhostAI. */
 export const USER_AGENT = `prohost-cli/${CLI_VERSION}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prohost/cli",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "description": "Run your own AI agent as a ProhostAI teammate, and stream your account's webhooks to your laptop.",
   "type": "module",
   "license": "MIT",