@phnx-labs/agents-cli 1.22.120 → 1.22.121

package/dist/lib/session/claude-accounts.js

@@ -1,9 +1,3 @@
-/**
- * Claude quota attribution, separate from the stable login identity in accountId.
- * Launch-recorded identity wins over current credentials in a reused home.
- * Older rows retain their evidence-labelled path/version inference for historical
- * quota reports; recovery never treats that org-scoped accountKey as login proof.
- */
 import * as os from 'os';
 import * as path from 'path';
 import * as fs from 'fs';
@@ -11,7 +5,6 @@ import { readClaudeHomeConfig } from '../agents.js';
 import { getAgentsDir, getHistoryDir } from '../state.js';
 const HOME = os.homedir();
 const VERSIONS_ROOTS = [getHistoryDir(), getAgentsDir()];
-/** `claude_team` → "Team", `claude_max` → "Max". Mirrors lib/agents.ts's label logic. */
 function planFromOrgType(orgType) {
     if (!orgType)
         return null;
@@ -25,8 +18,6 @@ function bucketForHome(home, evidence) {
     if (!cfg)
         return null;
     const { email, organizationName: orgName, usageKey, accountKey, organizationType } = cfg.identity;
-    // No org uuid means no quota bucket to key on. Fall back to the narrower account key,
-    // then the email — an identity we cannot key is not one we should guess at.
     const key = usageKey ?? accountKey ?? (email ? `claude:email=${email}` : null);
     if (!key)
         return null;
@@ -40,7 +31,6 @@ function bucketForHome(home, evidence) {
         evidence,
     };
 }
-/** A dark bucket, labelled by why it is dark so two dark sources never merge. */
 function unattributed(reason) {
     return {
         key: `unattributed:${reason}`,
@@ -62,11 +52,6 @@ function listDirs(dir) {
         return [];
     }
 }
-/**
- * Enumerate every Claude home that could own an indexed transcript. Includes retired
- * `trash/` snapshots: they keep their `.claude.json`, so a transcript indexed before
- * its version was rotated out stays attributable.
- */
 export function buildClaudeAccountIndex() {
     const entries = [];
     const darkHomes = [];
@@ -76,8 +61,6 @@ export function buildClaudeAccountIndex() {
     const addHome = (home, version, retired) => {
         const bucket = bucketForHome(home, 'version-home');
         if (!bucket) {
-            // The home exists on disk but has no usable identity. Record its prefix so
-            // resolution can name it instead of guessing from a recorded version.
             if (fs.existsSync(path.join(home, '.claude'))) {
                 darkHomes.push({ prefix: path.join(home, '.claude'), version });
             }
@@ -101,24 +84,12 @@ export function buildClaudeAccountIndex() {
             addHome(path.join(versionsBase, version, 'home'), version, false);
         }
     }
-    // Retired homes: <historyDir>/trash/versions/claude/<version>/<timestamp>/home
     const trashBase = path.join(getHistoryDir(), 'trash', 'versions', 'claude');
     for (const version of listDirs(trashBase)) {
         for (const stamp of listDirs(path.join(trashBase, version))) {
             addHome(path.join(trashBase, version, stamp, 'home'), version, true);
         }
     }
-    // Account slots (PHNX-3940): a named account gets its own HOME-shaped dir at
-    // <historyDir>/accounts/claude/<accountId>/, sharing the one managed install
-    // rather than owning a version home of its own (lib/accounts/slots.ts
-    // `slotDir`). Each slot's `.claude.json` proves ITS identity exactly as
-    // directly as a version home's — tier 1 evidence in `resolveClaudeAccount` —
-    // so without this, every transcript a slot-launched session wrote was
-    // discoverable (the account is registered and runnable) yet permanently
-    // unattributed here, and `isManagedSessionFile`/`getAgentSessionDirs` would
-    // never even have scanned it in the first place. An unconfigured slot (never
-    // signed in) yields no bucket and is simply skipped, not recorded dark — a
-    // slot with nothing written to it yet owns no transcript to misattribute.
     const accountsBase = path.join(getHistoryDir(), 'accounts', 'claude');
     for (const accountId of listDirs(accountsBase)) {
         const home = path.join(accountsBase, accountId);
@@ -128,8 +99,6 @@ export function buildClaudeAccountIndex() {
         entries.push({ prefix: path.join(home, '.claude'), bucket });
         byAccountId.set(accountId, bucket);
     }
-    // A live home is authoritative for its version. Otherwise the retired snapshots
-    // decide, but only when they agree — disagreement is reported, not resolved.
     const byVersion = new Map();
     for (const [version, list] of trashByVersion) {
         const keys = new Set(list.map((b) => b.key));
@@ -138,7 +107,6 @@ export function buildClaudeAccountIndex() {
     for (const [version, bucket] of liveByVersion) {
         byVersion.set(version, { ...bucket, evidence: 'recorded-version' });
     }
-    // Longest prefix first so a nested home beats a shorter ancestor.
     entries.sort((a, b) => b.prefix.length - a.prefix.length);
     darkHomes.sort((a, b) => b.prefix.length - a.prefix.length);
     return {
@@ -150,33 +118,23 @@ export function buildClaudeAccountIndex() {
         symlinkPrefix: path.join(HOME, '.claude'),
     };
 }
-/** Version segment of a versions/ or trash/ path, for labelling dark buckets. */
 function versionFromPath(filePath) {
     const m = /[/\\]versions[/\\]claude[/\\]([^/\\]+)[/\\]/.exec(filePath);
     return m ? m[1] : null;
 }
-/** Resolve a quota bucket without replacing recorded login provenance. */
 export function resolveClaudeAccount(index, filePath, recordedVersion, launchAccountId) {
-    // Launch provenance survives credential changes and transcript relocation.
     if (launchAccountId) {
         return index.byAccountId.get(launchAccountId) ?? unattributed(`recorded account ${launchAccountId}`);
     }
-    // Tier 1 — the file physically lives in a home we can identify.
     for (const entry of index.entries) {
         if (filePath.startsWith(entry.prefix + path.sep))
             return entry.bucket;
     }
-    // Tier 1b — it lives in a home that exists but is signed out. The location proves
-    // which config dir Claude used, so this beats any recorded version: reporting it
-    // against a *different* version's account would be a guess dressed as evidence.
     for (const dark of index.darkHomes) {
         if (filePath.startsWith(dark.prefix + path.sep)) {
             return unattributed(dark.version ? `signed-out home ${dark.version}` : 'signed-out home');
         }
     }
-    // Tier 2 — outside every known home. The recorded version names the home that ran,
-    // which covers both the mutable ~/.claude symlink and the routine/run archives under
-    // <historyDir>/runs that readRoutineArchiveMeta feeds through this same path.
     if (recordedVersion) {
         const byVersion = index.byVersion.get(recordedVersion);
         if (byVersion === 'ambiguous') {
@@ -184,15 +142,8 @@ export function resolveClaudeAccount(index, filePath, recordedVersion, launchAcc
         }
         if (byVersion)
             return byVersion;
-        // Recorded but unresolvable — the version was uninstalled and its trash snapshot
-        // pruned. Stay dark. Falling through to the symlink's current target would move
-        // these rows onto whichever account happens to be default now, which is the
-        // inference tier 2 exists to avoid.
         return unattributed(`no home for version ${recordedVersion}`);
     }
-    // Tier 3 — under the live symlink with no recorded version at all. Its current
-    // target is the only evidence that exists. A recorded-but-unresolvable version
-    // returned dark from tier 2 above and never arrives here.
     if (filePath.startsWith(index.symlinkPrefix + path.sep) && index.symlinkBucket) {
         return index.symlinkBucket;
     }

package/dist/lib/session/cloud.d.ts

@@ -1,28 +1,6 @@
-/**
- * Rush Cloud session source.
- *
- * Fetches cloud-captured sessions from the cloud proxy (api.prix.dev) and caches
- * them locally so the existing filesystem-based parse pipeline works unchanged.
- *
- * Endpoints consumed by the cloud proxy:
- *   GET /api/v1/cloud-runs                  → list executions
- *   GET /api/v1/cloud-runs/:id              → get one (used for meta)
- *   GET /api/v1/cloud-runs/:id/session.jsonl → raw captured jsonl
- */
-import type { SessionMeta } from './types.js';
-/**
- * List cloud executions the user has captured sessions for. Includes
- * completed + needs_review + failed; an empty session_path means capture
- * never ran, so those are silently dropped.
- */
+import type { SessionMeta } from '@phnx-labs/sessions-cli/reader';
 export declare function discoverCloudSessions(options?: {
     limit?: number;
 }): Promise<SessionMeta[]>;
-/**
- * Fetch the jsonl for one cloud execution and stash it in the local cache.
- * Returns the local file path. Re-fetches on every call (cheap — executions
- * are immutable once complete). Callers may pass an already-known filePath.
- */
 export declare function ensureCloudSessionCached(executionId: string, destPath?: string): Promise<string>;
-/** True if filePath points into the cloud session cache dir. */
 export declare function isCloudSessionPath(filePath: string): boolean;

package/dist/lib/session/cloud.js

@@ -1,14 +1,3 @@
-/**
- * Rush Cloud session source.
- *
- * Fetches cloud-captured sessions from the cloud proxy (api.prix.dev) and caches
- * them locally so the existing filesystem-based parse pipeline works unchanged.
- *
- * Endpoints consumed by the cloud proxy:
- *   GET /api/v1/cloud-runs                  → list executions
- *   GET /api/v1/cloud-runs/:id              → get one (used for meta)
- *   GET /api/v1/cloud-runs/:id/session.jsonl → raw captured jsonl
- */
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -43,7 +32,6 @@ async function api(method, endpoint, token) {
         headers: { Authorization: `Bearer ${token}` },
     });
 }
-/** Coerce the `agent` field on a cloud-run row to a SessionAgentId. */
 function agentToFormat(agent) {
     if (agent === 'claude')
         return 'claude';
@@ -75,11 +63,6 @@ function cachePathForExecution(executionId, agent) {
     const id = validateCloudExecutionId(executionId);
     return assertContained(path.join(id, `session.${agent}.jsonl`), CLOUD_CACHE_DIR);
 }
-/**
- * List cloud executions the user has captured sessions for. Includes
- * completed + needs_review + failed; an empty session_path means capture
- * never ran, so those are silently dropped.
- */
 export async function discoverCloudSessions(options) {
     const token = readToken();
     const limit = options?.limit ?? 50;
@@ -97,9 +80,6 @@ export async function discoverCloudSessions(options) {
         const id = validateCloudExecutionId(row.execution_id);
         const timestamp = row.updated_at || row.created_at || new Date().toISOString();
         const project = row.repo_owner && row.repo_name ? `${row.repo_owner}/${row.repo_name}` : undefined;
-        // filePath doubles as the sink path for the cached jsonl. parseSession
-        // dispatches on detectAgent which recognizes the `session.<format>.jsonl`
-        // suffix — so the local cache file name must preserve it.
         const filePath = cachePathForExecution(id, agent);
         out.push({
             id,
@@ -115,11 +95,6 @@ export async function discoverCloudSessions(options) {
     out.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
     return out;
 }
-/**
- * Fetch the jsonl for one cloud execution and stash it in the local cache.
- * Returns the local file path. Re-fetches on every call (cheap — executions
- * are immutable once complete). Callers may pass an already-known filePath.
- */
 export async function ensureCloudSessionCached(executionId, destPath) {
     const id = validateCloudExecutionId(executionId);
     const callerPath = destPath ? assertContained(destPath, CLOUD_CACHE_DIR) : undefined;
@@ -139,7 +114,6 @@ export async function ensureCloudSessionCached(executionId, destPath) {
     fs.writeFileSync(finalPath, body);
     return finalPath;
 }
-/** True if filePath points into the cloud session cache dir. */
 export function isCloudSessionPath(filePath) {
     const root = path.resolve(CLOUD_CACHE_DIR);
     const resolved = path.resolve(filePath);