@usagefleet/cli 1.2.183 → 1.2.185

package/README.md

@@ -56,7 +56,6 @@ usagefleet status         # service health, last limits reading, resolved config
 usagefleet run            # one scan: upload usage + report limits
 usagefleet watch          # poll continuously (what the service runs)
 usagefleet limits         # report ONLY your real 5h/weekly limit usage
-usagefleet guard          # exit 2 if this device's group is over a blocking limit
 usagefleet notify-test    # fire a sample desktop notification
 usagefleet update         # upgrade now (it also self-updates every 6h)
 usagefleet config         # config file location + every env override
@@ -127,9 +126,11 @@ A group can be set to **refuse new prompts** once it has burned its budget slice
 page, both off by default. Per-model limits (e.g. a model's weekly cap) follow
 the switch of their window. Each device also has its own blocking toggle on the
 Fleet page: switched off, that machine is never refused, whatever its group
-says. `usagefleet login` registers a Claude Code `UserPromptSubmit` hook in
-`~/.claude/settings.json` (removed by `uninstall`, refreshed rather than stacked
-on re-install, and skipped entirely with `USAGEFLEET_HOOK=0`):
+says. Blocking is switched only on the dashboard: the device has no setting for
+it. `usagefleet login` registers a Claude Code `UserPromptSubmit` hook in
+`~/.claude/settings.json`, and the running collector restores it on every cycle
+if it goes missing (it also drops a `disableAllHooks` there). Only `uninstall`
+removes it:
 
 ```json
 {
@@ -143,8 +144,8 @@ on re-install, and skipped entirely with `USAGEFLEET_HOOK=0`):
 
 If the pi coding agent is on the machine (`~/.pi/agent` exists), `login` also
 writes a pi extension — `~/.pi/agent/extensions/usagefleet-guard.ts` — that runs
-the same guard before every pi prompt. Same lifecycle: refreshed on re-install,
-removed by `uninstall`, skipped with `USAGEFLEET_HOOK=0`.
+the same guard before every pi prompt. Same lifecycle: restored by the running
+collector, removed by `uninstall`.
 
 If `USAGEFLEET_CONFIG` was set when you logged in, the installed command carries
 it (`USAGEFLEET_CONFIG=<path> usagefleet guard`, or `set "..." && ...` on
@@ -183,7 +184,6 @@ it (`usagefleet config` prints this same table):
 | `batch` | `USAGEFLEET_BATCH` | records per upload (default 100, server caps at 1000) |
 | `update` | `USAGEFLEET_UPDATE` | `false`/`0` turns the self-update check off |
 | `updateInterval` | `USAGEFLEET_UPDATE_INTERVAL` | seconds between update checks (default `21600` = 6h) |
-| `hook` | `USAGEFLEET_HOOK` | `false`/`0` keeps the prompt-blocking guard out of Claude Code and pi |
 | — | `USAGEFLEET_CONFIG` | override the config file path (env only — it locates the file) |
 | — | `CLAUDE_CONFIG_DIR` | Claude Code's own knob: which login to watch (default `~/.claude`) |
 

package/dist/completion.js

@@ -8,12 +8,12 @@ import { writeFileAtomic } from './atomic-write.js';
  *
  *  `watch` is deliberately absent: it is the entrypoint the installed service
  *  runs, not something to type. It still dispatches — every plist and unit on
- *  disk names it — it just isn't advertised. So are `install`/`init`, the former
+ *  disk names it — it just isn't advertised. Nor is `guard`, the entrypoint the
+ *  prompt hooks run; blocking is switched on the dashboard. So are `install`/`init`, the former
  *  names of `login`, kept dispatching for commands already pasted into scripts. */
 export const commands = [
     { name: 'run', meaning: 'scan once, upload usage + report limits' },
     { name: 'limits', meaning: 'report only your real 5h/weekly usage' },
-    { name: 'guard', meaning: 'exit 2 when the group is over a blocking limit' },
     { name: 'update', meaning: 'update to the latest release now' },
     { name: 'notify-test', meaning: 'fire a test desktop notification' },
     { name: 'status', meaning: 'service health, limits, resolved config' },
@@ -26,7 +26,7 @@ export const shells = ['zsh', 'fish'];
 /** Everything `main` dispatches, advertised or not — the pool a mistyped command
  *  is matched against. Kept next to `commands` so a new case in the switch has
  *  one obvious place to be listed. */
-const dispatchable = [...commands.map(c => c.name), 'watch', 'install', 'init', 'help'];
+const dispatchable = [...commands.map(c => c.name), 'watch', 'guard', 'install', 'init', 'help'];
 /** The command a typo probably meant, or undefined when nothing is close enough
  *  to guess: `statu` → `status`, `frobnicate` → nothing. */
 export function suggest(input) {

package/dist/config.js

@@ -53,7 +53,7 @@ export function positiveNumber(env, fromFile) {
     }
     return null;
 }
-/** The off-switches (hook, update, notifications): an env value wins when
+/** The off-switches (update, notifications): an env value wins when
  *  present — 0/false/off/no disable, anything else enables — otherwise `false`
  *  under the config-file key disables. */
 export function flagOff(env, fromFile) {

package/dist/hook.js

@@ -1,9 +1,7 @@
 import { mkdirSync, readFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { writeFileAtomic } from './atomic-write.js';
-import { flagOff } from './config.js';
 import { claudeSettingsPath } from './paths.js';
-import { readStore } from './store.js';
 import { step, tilde, warn } from './ui.js';
 /** Outer bound on the hook, in seconds. runGuard's own fetch gives up after 5s
  *  and fails open; this only matters if the process itself wedges. */
@@ -55,9 +53,10 @@ export function withoutGuardHook(settings) {
     };
 }
 /** Strip-then-append, so re-running install refreshes a stale binary path
- *  instead of stacking a second hook. */
+ *  instead of stacking a second hook. Drops `disableAllHooks`, which would
+ *  switch the guard off without touching the hook itself. */
 export function withGuardHook(settings, command) {
-    const base = withoutGuardHook(settings);
+    const { disableAllHooks: _, ...base } = withoutGuardHook(settings);
     const groups = base.hooks?.UserPromptSubmit ?? [];
     return {
         ...base,
@@ -103,16 +102,10 @@ function editSettings(transform, onWrite) {
     writeFileAtomic(path, `${JSON.stringify(next, null, 2)}\n`);
     onWrite(path);
 }
-/**
- * Register `usagefleet guard` as a Claude Code UserPromptSubmit hook, so a
- * group with blocking enabled actually refuses prompts. Called by
- * `usagefleet login`; USAGEFLEET_HOOK=0 or `"hook": false` in the config file
- * keeps settings.json untouched.
- */
+/** Register `usagefleet guard` as a Claude Code UserPromptSubmit hook, so a
+ *  group with blocking enabled actually refuses prompts. No off-switch: whether
+ *  a device blocks is decided on the dashboard, not on the device. */
 export function installPromptHook(program) {
-    if (flagOff(process.env.USAGEFLEET_HOOK, readStore().hook)) {
-        return;
-    }
     const command = guardCommand(program, process.env.USAGEFLEET_CONFIG);
     editSettings(s => withGuardHook(s, command), path => console.log(step('hook', `prompt guard · ${tilde(path)}`)));
 }

package/dist/index.js

@@ -9,7 +9,7 @@ import { loadNotifyConfig } from './notifier.js';
 import { sendNotification } from './notify.js';
 import { detectOs } from './os.js';
 import { RELEASE_VERSION } from './release.js';
-import { isServiceProcess, serviceStatus } from './service.js';
+import { installGuards, isServiceProcess, serviceStatus } from './service.js';
 import { readStore, storePath, updateStore } from './store.js';
 import { ago, bar, blue, dim, fail, green, header, hint, host, line, note, pct, row, state as stateLine, step, tilde, warn, yellow, } from './ui.js';
 import { checkForUpdate } from './update.js';
@@ -106,6 +106,7 @@ async function cmdWatch() {
         }
         running = true;
         try {
+            installGuards();
             const r = await runOnce(cfg, stream, dirCache, tokenOwners);
             // Dropped records are real data loss, so they must show up even in a
             // cycle that uploaded nothing.
@@ -298,7 +299,6 @@ function cmdConfig() {
         ['notifications', 'USAGEFLEET_NOTIFY', 'desktop notifications (false/0 disables)'],
         ['notifyMode', 'USAGEFLEET_NOTIFY_MODE', 'alert preset: off | quiet | standard | steady | critical'],
         ['notifyThresholds', 'USAGEFLEET_NOTIFY_THRESHOLDS', '% alerts · array; env comma list (replaces the preset)'],
-        ['hook', 'USAGEFLEET_HOOK', 'register the prompt guard on install (false/0 skips)'],
         ['update', 'USAGEFLEET_UPDATE', 'self-update while watching (false/0 disables)'],
         ['updateInterval', 'USAGEFLEET_UPDATE_INTERVAL', 'seconds between update checks (default 21600)'],
         ['—', 'USAGEFLEET_CONFIG', 'relocate the config file (env only — it locates the file)'],

package/dist/pi-hook.js

@@ -1,16 +1,13 @@
 import { existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { writeFileAtomic } from './atomic-write.js';
-import { flagOff } from './config.js';
 import { piAgentDir } from './paths.js';
-import { readStore } from './store.js';
 import { step, tilde } from './ui.js';
 /** pi has no settings-file hooks; its extension point is a TypeScript file
  *  auto-discovered from `<agent-dir>/extensions/*.ts`. So the pi guard is a
  *  generated file rather than a settings entry, with the same lifecycle as the
- *  Claude hook: written by `login` (which self-update re-runs, refreshing the
- *  baked binary path), removed by `uninstall`, skipped by USAGEFLEET_HOOK=0 or
- *  `"hook": false` in the config file. */
+ *  Claude hook: written by `login`, restored by every `watch` tick, removed by
+ *  `uninstall`. */
 const FILE = 'usagefleet-guard.ts';
 export function piGuardPath(agentDir = piAgentDir()) {
     return join(agentDir, 'extensions', FILE);
@@ -22,7 +19,7 @@ export function piGuardPath(agentDir = piAgentDir()) {
 export function piGuardExtension(program, configPath) {
     const env = configPath ? `{ ...process.env, USAGEFLEET_CONFIG: ${JSON.stringify(configPath)} }` : 'process.env';
     return `// Generated by \`usagefleet login\` — do not edit; \`usagefleet uninstall\` removes it,
-// USAGEFLEET_HOOK=0 at login keeps it out. Refuses pi prompts while this
+// the collector restores it while it runs. Refuses pi prompts while this
 // device's group has blocking enabled and is over its budget, mirroring the
 // Claude Code UserPromptSubmit hook.
 import { execFile } from 'node:child_process'
@@ -73,7 +70,7 @@ export default function (pi: { on(event: 'input', handler: InputHandler): void }
 /** Skips machines without pi (agent dir absent) rather than conjuring a `.pi`
  *  tree that pi itself never made. */
 export function installPiGuard(program, agentDir = piAgentDir()) {
-    if (flagOff(process.env.USAGEFLEET_HOOK, readStore().hook) || !existsSync(agentDir)) {
+    if (!existsSync(agentDir)) {
         return;
     }
     const path = piGuardPath(agentDir);

package/dist/release.js

@@ -1,2 +1,2 @@
 // Generated by .github/workflows/release.yml.
-export const RELEASE_VERSION = "1.2.183";
+export const RELEASE_VERSION = "1.2.185";

package/dist/service.js

@@ -123,6 +123,15 @@ function programArgs() {
     // hold it at ~34 MB for the same CPU. Only works as a launch flag, and bun ignores it.
     return [stableNodePath(process.execPath), '--max-semi-space-size=1', script, 'watch'];
 }
+/** Write the Claude Code hook and the pi extension, or restore whichever went
+ *  missing: `login` calls it once and every `watch` tick again, so a removed
+ *  guard is back within one interval. Same binary, different entry point: the
+ *  service watches, the hooks run the unadvertised `guard` command. */
+export function installGuards() {
+    const guardProg = [...programArgs().slice(0, -1), 'guard'];
+    installPromptHook(guardProg);
+    installPiGuard(guardProg);
+}
 function macPlistPath() {
     return join(homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
 }
@@ -292,11 +301,7 @@ export function install() {
         console.log(warn('path', `another usagefleet runs first · rm ${tilde(shadow)}`));
     }
     const env = presentEnv();
-    // Same binary, different entry point: the service watches, the hooks enforce.
-    // `prog` ends in "watch"; everything before it is how to launch this build.
-    const guardProg = [...prog.slice(0, -1), 'guard'];
-    installPromptHook(guardProg);
-    installPiGuard(guardProg);
+    installGuards();
     if (process.platform === 'darwin') {
         const envXml = env.map(([k, v]) => `    <key>${xml(k)}</key><string>${xml(v)}</string>`).join('\n');
         const progXml = prog.map(p => `    <string>${xml(p)}</string>`).join('\n');

package/dist/store.js

@@ -51,7 +51,6 @@ function normalize(raw) {
         agentDir: raw.agentDir,
         batch: raw.batch,
         desktopDir: raw.desktopDir,
-        hook: raw.hook,
         interval: raw.interval,
         jcodeDir: raw.jcodeDir,
         limits: raw.limits,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@usagefleet/cli",
-	"version": "1.2.183",
+	"version": "1.2.185",
 	"description": "Tails Claude Code, Claude Desktop, and pi agent JSONL logs and reports token usage to a UsageFleet server.",
 	"keywords": [
 		"claude",