@phnx-labs/agents-cli 1.22.44 → 1.22.46

package/dist/lib/entitlement.d.ts

@@ -1,31 +0,0 @@
-/** How long a cached tier is trusted before the next call re-fetches. */
-export declare const ENTITLEMENT_CACHE_TTL_MS: number;
-export type EntitlementSource = 'live' | 'cache' | 'offline' | 'no-session';
-export interface EntitlementTier {
-    /** The raw tier name from the backend ('free', 'admin', or a paid tier name). */
-    tierName: string;
-    /** true for 'admin' or any tier name other than 'free'. */
-    isPaid: boolean;
-    /** Where this value came from — mainly for diagnostics/tests. */
-    source: EntitlementSource;
-}
-export declare function setEntitlementUserYamlPathForTest(value: string | null): void;
-export declare function setEntitlementCachePathForTest(value: string | null): void;
-export declare function setEntitlementFetchForTest(fn: typeof globalThis.fetch): void;
-export declare function entitlementCachePath(): string;
-/**
- * The live plan tier, cache-first with a TTL.
- *
- * - No `~/.rush/user.yaml` at all → free, no network call.
- * - A fresh cache entry (within {@link ENTITLEMENT_CACHE_TTL_MS}) is returned
- *   with no network call.
- * - A stale or missing cache triggers a live fetch; on success the result is
- *   cached and returned.
- * - A failed fetch (offline, timeout, non-2xx) falls back to a stale cache if
- *   one exists — never silently drops a known-paid account to free just
- *   because the network hiccuped — and only falls back to free when there is
- *   no cache at all to fall back to.
- */
-export declare function getTier(): Promise<EntitlementTier>;
-/** Per-harness account cap for a tier: 3 on free, 10 on paid/admin. */
-export declare function accountCapForTier(tier: Pick<EntitlementTier, 'isPaid'>): number;

package/dist/lib/entitlement.js

@@ -1,137 +0,0 @@
-/**
- * Plan-tier entitlement — the one place agents-cli reads a user's live billing
- * tier for plan gates (the `agents accounts` per-harness cap, the `agents
- * insights` paid split). Fetches `GET /api/v1/billing/subscription?agent=agi-cli`
- * using the Rush session token from `~/.rush/user.yaml` (same read pattern as
- * `lib/cloud/rush.ts` / `lib/secrets/drivers/rush.ts` — this module does not
- * import either, since neither exports its token reader), caches the result on
- * disk with a TTL, and stays offline-tolerant: a stale cache is honored over a
- * failed network call rather than silently dropping a paid account to free, and
- * no session file at all resolves straight to the free tier with no request.
- */
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import * as yaml from 'yaml';
-import { getCacheDir } from './state.js';
-import { atomicWriteFileSync, ensureLockTarget, withFileLock } from './fs-atomic.js';
-const PROXY_BASE = process.env.RUSH_PROXY_BASE ?? 'https://api.prix.dev';
-const SUBSCRIPTION_PATH = '/api/v1/billing/subscription?agent=agi-cli';
-/** How long a cached tier is trusted before the next call re-fetches. */
-export const ENTITLEMENT_CACHE_TTL_MS = 15 * 60_000;
-/** Same shape as bootstrap.ts's fetchNpmPackageMetadata — a hung connection
- * (dead peer, a firewall dropping packets silently) must not block every
- * `accounts add`/`insights` call indefinitely once the cache goes stale. */
-const FETCH_TIMEOUT_MS = 5000;
-const FREE_TIER = { tierName: 'free', isPaid: false };
-// ─── Injectable seams (tests only — the lib's own real read/write paths) ────
-let userYamlPathOverride = null;
-let cachePathOverride = null;
-let fetchImpl = globalThis.fetch;
-export function setEntitlementUserYamlPathForTest(value) {
-    userYamlPathOverride = value;
-}
-export function setEntitlementCachePathForTest(value) {
-    cachePathOverride = value;
-}
-export function setEntitlementFetchForTest(fn) {
-    fetchImpl = fn;
-}
-function userYamlPath() {
-    return userYamlPathOverride ?? path.join(os.homedir(), '.rush', 'user.yaml');
-}
-export function entitlementCachePath() {
-    return cachePathOverride ?? path.join(getCacheDir(), '.entitlement-cache.json');
-}
-function readRushToken() {
-    const file = userYamlPath();
-    if (!fs.existsSync(file))
-        return null;
-    try {
-        const data = yaml.parse(fs.readFileSync(file, 'utf-8'));
-        return data?.session?.access_token || null;
-    }
-    catch {
-        return null;
-    }
-}
-function readCache() {
-    try {
-        const parsed = JSON.parse(fs.readFileSync(entitlementCachePath(), 'utf-8'));
-        if (parsed?.version === 1 && typeof parsed.tierName === 'string' && typeof parsed.fetchedAt === 'number')
-            return parsed;
-    }
-    catch {
-        // missing or corrupt — treat as no cache
-    }
-    return null;
-}
-/** Best-effort write; a failed cache write just means the next call re-fetches. */
-function writeCache(tierName, isPaid) {
-    try {
-        const target = entitlementCachePath();
-        ensureLockTarget(target);
-        withFileLock(target, () => {
-            const entry = { version: 1, tierName, isPaid, fetchedAt: Date.now() };
-            atomicWriteFileSync(target, JSON.stringify(entry, null, 2));
-        });
-    }
-    catch {
-        // best-effort
-    }
-}
-/**
- * Only `tierName: "free"` (or an absent tier name) reads as free — every other
- * name (`admin`, or a real paid-tier name once agi-cli has a pricing manifest,
- * see the integration spec §4.4 G3) is treated as paid. Backend tier config for
- * agi-cli doesn't exist yet, so this deliberately does not lean on
- * `hasSubscription`/`needsUpgrade` nuance the backend isn't populating meaningfully
- * for this agent today.
- */
-function classifySubscription(sub) {
-    const tierName = typeof sub.tierName === 'string' && sub.tierName ? sub.tierName : 'free';
-    return { tierName, isPaid: tierName !== 'free' };
-}
-/**
- * The live plan tier, cache-first with a TTL.
- *
- * - No `~/.rush/user.yaml` at all → free, no network call.
- * - A fresh cache entry (within {@link ENTITLEMENT_CACHE_TTL_MS}) is returned
- *   with no network call.
- * - A stale or missing cache triggers a live fetch; on success the result is
- *   cached and returned.
- * - A failed fetch (offline, timeout, non-2xx) falls back to a stale cache if
- *   one exists — never silently drops a known-paid account to free just
- *   because the network hiccuped — and only falls back to free when there is
- *   no cache at all to fall back to.
- */
-export async function getTier() {
-    const token = readRushToken();
-    if (!token)
-        return { ...FREE_TIER, source: 'no-session' };
-    const cached = readCache();
-    if (cached && Date.now() - cached.fetchedAt < ENTITLEMENT_CACHE_TTL_MS) {
-        return { tierName: cached.tierName, isPaid: cached.isPaid, source: 'cache' };
-    }
-    try {
-        const res = await fetchImpl(`${PROXY_BASE}${SUBSCRIPTION_PATH}`, {
-            headers: { Authorization: `Bearer ${token}` },
-            signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
-        });
-        if (!res.ok)
-            throw new Error(`billing/subscription responded ${res.status}`);
-        const sub = (await res.json());
-        const { tierName, isPaid } = classifySubscription(sub);
-        writeCache(tierName, isPaid);
-        return { tierName, isPaid, source: 'live' };
-    }
-    catch {
-        if (cached)
-            return { tierName: cached.tierName, isPaid: cached.isPaid, source: 'offline' };
-        return { ...FREE_TIER, source: 'offline' };
-    }
-}
-/** Per-harness account cap for a tier: 3 on free, 10 on paid/admin. */
-export function accountCapForTier(tier) {
-    return tier.isPaid ? 10 : 3;
-}

package/dist/lib/prix-account.d.ts

@@ -1,159 +0,0 @@
-/**
- * Client for the Rush account layer (`api.prix.dev`) — backs `agents auth` and
- * `agents auth space` (canonical) / `agents org` (deprecated alias). `agents auth space`
- * maps to `/api/v1/spaces`, not `/api/v1/orgs`: spaces
- * already carry the free-tier caps (1 owned space, 3 members) and can exist
- * standalone with no parent organization, matching a "just want a team" CLI flow
- * better than the heavier enterprise-tenancy `orgs` routes (domain, SSO). See
- * `.agents/artifacts/2026-08-20/agi-cli-client-integration-spec.md` §4.2 in the
- * agi-cli-web repo for the full reasoning and the live-confirmed route/shape audit.
- *
- * Token custody: `agents auth login` writes its own session file
- * (`getPrixSessionFile()`), separate from `~/.rush/user.yaml`, so `agents auth
- * logout` never signs the user out of `rush` (the two CLIs share a backend
- * account, not a credential store). Reads fall back to `~/.rush/user.yaml`
- * (the pattern `readRushToken` in `lib/secrets/drivers/rush.ts` already uses)
- * so a user who is only signed in via `rush login` still gets a working
- * `agents auth whoami` / `agents org` with zero extra login step.
- */
-export declare const PRIX_API_BASE = "https://api.prix.dev";
-/** The session `agents auth login` owns. */
-export interface PrixSession {
-    access_token: string;
-    refresh_token?: string;
-    /** Unix ms. */
-    expires_at?: number;
-    email?: string;
-    userId?: string;
-}
-export declare function getPrixSessionFile(): string;
-export declare function readPrixSession(): PrixSession | null;
-export declare function writePrixSession(session: PrixSession): void;
-export declare function clearPrixSession(): boolean;
-/** Where the caller's Bearer token came from — surfaced by `whoami` so the user knows which login is live. */
-export type PrixTokenSource = 'agents' | 'rush';
-export declare function resolvePrixToken(): {
-    token: string;
-    source: PrixTokenSource;
-} | null;
-export declare class PrixApiError extends Error {
-    status: number;
-    constructor(status: number, message: string);
-}
-export interface WhoAmI {
-    userId: string;
-    email: string;
-    valid: true;
-}
-/** `GET /api/v1/auth/me` — live-confirmed shape: `{email, userId, valid}`. */
-export declare function fetchWhoAmI(token?: string): Promise<WhoAmI>;
-export interface DeviceAuthorization {
-    device_code: string;
-    user_code: string;
-    verification_uri: string;
-    verification_uri_complete: string;
-    expires_in: number;
-    interval: number;
-}
-/** `POST /api/v1/auth/device/authorization` — public, no token. */
-export declare function startDeviceAuthorization(): Promise<DeviceAuthorization>;
-export type DeviceTokenPoll = {
-    status: 'authorized';
-    access_token: string;
-    refresh_token?: string;
-    expires_in?: number;
-    user: {
-        email: string;
-        id: string;
-    };
-} | {
-    status: 'pending';
-} | {
-    status: 'slow_down';
-} | {
-    status: 'expired';
-} | {
-    status: 'denied';
-};
-/** `POST /api/v1/auth/device/token` — one poll attempt. Callers own the interval loop. */
-export declare function pollDeviceToken(deviceCode: string): Promise<DeviceTokenPoll>;
-export interface SpaceSummary {
-    id: string;
-    slug: string;
-    name: string;
-    organization_id: string | null;
-    owner_user_id: string;
-    invite_code?: string;
-    user_role: 'owner' | 'admin' | 'member';
-    created_at: string;
-}
-export interface SpaceMember {
-    user_id: string;
-    email: string;
-    name?: string;
-    avatar_url?: string;
-    role: 'owner' | 'admin' | 'member';
-    joined_at: string;
-}
-/** `GET /api/v1/spaces` — live-confirmed: array of `SpaceSummary`. */
-export declare function listSpaces(): Promise<SpaceSummary[]>;
-/** `POST /api/v1/spaces` — 403 if the caller already owns a space (free tier: 1). */
-export declare function createSpace(input: {
-    name: string;
-    slug: string;
-    description?: string;
-}): Promise<SpaceSummary>;
-/** `GET /api/v1/spaces/:id` — requires membership. */
-export declare function getSpace(spaceId: string): Promise<SpaceSummary>;
-/** `GET /api/v1/spaces/:id/members`. */
-export declare function listSpaceMembers(spaceId: string): Promise<SpaceMember[]>;
-export type CreateSpaceInviteResult = {
-    invited: true;
-    email: string;
-    role: string;
-    member_added: true;
-} | {
-    invited: true;
-    email: string;
-    role: string;
-    invite_code: string;
-    member_added?: false;
-};
-/** `POST /api/v1/spaces/:id/invites` — sends a real email for the pending-invite path. */
-export declare function createSpaceInvite(spaceId: string, email: string, role?: 'admin' | 'member'): Promise<CreateSpaceInviteResult>;
-export interface SpaceInvite {
-    id: string;
-    space_id: string;
-    email: string;
-    role: 'admin' | 'member';
-    invite_code: string;
-    created_at: string;
-}
-/** `GET /api/v1/spaces/:id/invites`. */
-export declare function listSpaceInvites(spaceId: string): Promise<SpaceInvite[]>;
-/** `DELETE /api/v1/spaces/:id/invites/:inviteId`. */
-export declare function revokeSpaceInvite(spaceId: string, inviteId: string): Promise<{
-    revoked: true;
-}>;
-/** `PATCH /api/v1/spaces/:id/members/:userId` — owner-only for admin changes. Route takes userId, not email. */
-export declare function updateSpaceMemberRole(spaceId: string, userId: string, role: 'admin' | 'member'): Promise<{
-    user_id: string;
-    role: string;
-    updated: true;
-}>;
-/** `DELETE /api/v1/spaces/:id/members/:userId` — owner, admin, or the member themself (leave). */
-export declare function removeSpaceMember(spaceId: string, userId: string): Promise<void>;
-/** `DELETE /api/v1/spaces/:id` — soft delete, 30-day restore window. */
-export declare function deleteSpace(spaceId: string): Promise<void>;
-/** `agents-cli-space-name` -> `agi-cli-space-name`; lowercase, hyphenated, matches the backend's `^[a-z0-9-]+$` slug rule. */
-export declare function slugify(name: string): string;
-/**
- * Resolve the `--space` a command should act on: an explicit id/slug match
- * against the caller's own space list, or — with nothing passed — the
- * caller's sole space (free tier caps ownership at one, so this is almost
- * always unambiguous). Pure over an already-fetched list so it's cheaply
- * unit-testable with a fixture.
- */
-export declare function resolveSpaceFromList(spaces: SpaceSummary[], explicit?: string): SpaceSummary;
-/** Resolve a member's email to their `user_id` from an already-fetched member list. */
-export declare function resolveMemberFromList(members: SpaceMember[], email: string): SpaceMember;

package/dist/lib/prix-account.js

@@ -1,215 +0,0 @@
-/**
- * Client for the Rush account layer (`api.prix.dev`) — backs `agents auth` and
- * `agents auth space` (canonical) / `agents org` (deprecated alias). `agents auth space`
- * maps to `/api/v1/spaces`, not `/api/v1/orgs`: spaces
- * already carry the free-tier caps (1 owned space, 3 members) and can exist
- * standalone with no parent organization, matching a "just want a team" CLI flow
- * better than the heavier enterprise-tenancy `orgs` routes (domain, SSO). See
- * `.agents/artifacts/2026-08-20/agi-cli-client-integration-spec.md` §4.2 in the
- * agi-cli-web repo for the full reasoning and the live-confirmed route/shape audit.
- *
- * Token custody: `agents auth login` writes its own session file
- * (`getPrixSessionFile()`), separate from `~/.rush/user.yaml`, so `agents auth
- * logout` never signs the user out of `rush` (the two CLIs share a backend
- * account, not a credential store). Reads fall back to `~/.rush/user.yaml`
- * (the pattern `readRushToken` in `lib/secrets/drivers/rush.ts` already uses)
- * so a user who is only signed in via `rush login` still gets a working
- * `agents auth whoami` / `agents org` with zero extra login step.
- */
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import * as yaml from 'yaml';
-import { getRuntimeStateDir } from './state.js';
-export const PRIX_API_BASE = 'https://api.prix.dev';
-const RUSH_USER_YAML = path.join(os.homedir(), '.rush', 'user.yaml');
-/** Computed per-call (not cached at module load) so `AGENTS_STATE_DIR` overrides in tests take effect. */
-function prixSessionFile() {
-    return path.join(getRuntimeStateDir(), 'prix-account.json');
-}
-/** Read the token `rush login` wrote, with no expiry check — the same shape `readRushToken` reads. */
-function readRushSessionToken() {
-    if (!fs.existsSync(RUSH_USER_YAML))
-        return null;
-    try {
-        const data = yaml.parse(fs.readFileSync(RUSH_USER_YAML, 'utf-8'));
-        return data?.session?.access_token ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-export function getPrixSessionFile() {
-    return prixSessionFile();
-}
-export function readPrixSession() {
-    const file = prixSessionFile();
-    if (!fs.existsSync(file))
-        return null;
-    try {
-        const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
-        if (!parsed || typeof parsed.access_token !== 'string')
-            return null;
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
-export function writePrixSession(session) {
-    const file = prixSessionFile();
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    const tmp = `${file}.${process.pid}.tmp`;
-    fs.writeFileSync(tmp, JSON.stringify(session, null, 2), { mode: 0o600 });
-    fs.renameSync(tmp, file);
-}
-export function clearPrixSession() {
-    const file = prixSessionFile();
-    if (!fs.existsSync(file))
-        return false;
-    fs.rmSync(file);
-    return true;
-}
-export function resolvePrixToken() {
-    const own = readPrixSession();
-    if (own?.access_token)
-        return { token: own.access_token, source: 'agents' };
-    const rushToken = readRushSessionToken();
-    if (rushToken)
-        return { token: rushToken, source: 'rush' };
-    return null;
-}
-export class PrixApiError extends Error {
-    status;
-    constructor(status, message) {
-        super(message);
-        this.status = status;
-        this.name = 'PrixApiError';
-    }
-}
-async function prixRequest(method, endpoint, opts = {}) {
-    const auth = opts.auth !== false;
-    let token = opts.token;
-    if (auth && !token) {
-        const resolved = resolvePrixToken();
-        if (!resolved)
-            throw new Error("Not signed in. Run 'agents auth login' first.");
-        token = resolved.token;
-    }
-    const headers = { 'Content-Type': 'application/json' };
-    if (token)
-        headers.Authorization = `Bearer ${token}`;
-    const res = await fetch(`${PRIX_API_BASE}${endpoint}`, {
-        method,
-        headers,
-        body: opts.body === undefined ? undefined : JSON.stringify(opts.body),
-    });
-    const text = await res.text();
-    const data = text ? JSON.parse(text) : undefined;
-    if (!res.ok) {
-        const message = (data && typeof data === 'object' && 'error' in data) ? String(data.error) : `${res.status} ${res.statusText}`;
-        throw new PrixApiError(res.status, message);
-    }
-    return data;
-}
-/** `GET /api/v1/auth/me` — live-confirmed shape: `{email, userId, valid}`. */
-export async function fetchWhoAmI(token) {
-    return prixRequest('GET', '/api/v1/auth/me', { token });
-}
-/** `POST /api/v1/auth/device/authorization` — public, no token. */
-export async function startDeviceAuthorization() {
-    return prixRequest('POST', '/api/v1/auth/device/authorization', { auth: false, body: {} });
-}
-/** `POST /api/v1/auth/device/token` — one poll attempt. Callers own the interval loop. */
-export async function pollDeviceToken(deviceCode) {
-    try {
-        const data = await prixRequest('POST', '/api/v1/auth/device/token', { auth: false, body: { grant_type: 'urn:ietf:params:oauth:grant-type:device_code', device_code: deviceCode } });
-        return { status: 'authorized', ...data };
-    }
-    catch (err) {
-        if (err instanceof PrixApiError) {
-            if (err.message.includes('authorization_pending'))
-                return { status: 'pending' };
-            if (err.message.includes('slow_down'))
-                return { status: 'slow_down' };
-            if (err.message.includes('expired_token'))
-                return { status: 'expired' };
-            if (err.message.includes('access_denied'))
-                return { status: 'denied' };
-        }
-        throw err;
-    }
-}
-/** `GET /api/v1/spaces` — live-confirmed: array of `SpaceSummary`. */
-export async function listSpaces() {
-    return prixRequest('GET', '/api/v1/spaces');
-}
-/** `POST /api/v1/spaces` — 403 if the caller already owns a space (free tier: 1). */
-export async function createSpace(input) {
-    return prixRequest('POST', '/api/v1/spaces', { body: input });
-}
-/** `GET /api/v1/spaces/:id` — requires membership. */
-export async function getSpace(spaceId) {
-    return prixRequest('GET', `/api/v1/spaces/${encodeURIComponent(spaceId)}`);
-}
-/** `GET /api/v1/spaces/:id/members`. */
-export async function listSpaceMembers(spaceId) {
-    return prixRequest('GET', `/api/v1/spaces/${encodeURIComponent(spaceId)}/members`);
-}
-/** `POST /api/v1/spaces/:id/invites` — sends a real email for the pending-invite path. */
-export async function createSpaceInvite(spaceId, email, role = 'member') {
-    return prixRequest('POST', `/api/v1/spaces/${encodeURIComponent(spaceId)}/invites`, { body: { email, role } });
-}
-/** `GET /api/v1/spaces/:id/invites`. */
-export async function listSpaceInvites(spaceId) {
-    return prixRequest('GET', `/api/v1/spaces/${encodeURIComponent(spaceId)}/invites`);
-}
-/** `DELETE /api/v1/spaces/:id/invites/:inviteId`. */
-export async function revokeSpaceInvite(spaceId, inviteId) {
-    return prixRequest('DELETE', `/api/v1/spaces/${encodeURIComponent(spaceId)}/invites/${encodeURIComponent(inviteId)}`);
-}
-/** `PATCH /api/v1/spaces/:id/members/:userId` — owner-only for admin changes. Route takes userId, not email. */
-export async function updateSpaceMemberRole(spaceId, userId, role) {
-    return prixRequest('PATCH', `/api/v1/spaces/${encodeURIComponent(spaceId)}/members/${encodeURIComponent(userId)}`, { body: { role } });
-}
-/** `DELETE /api/v1/spaces/:id/members/:userId` — owner, admin, or the member themself (leave). */
-export async function removeSpaceMember(spaceId, userId) {
-    await prixRequest('DELETE', `/api/v1/spaces/${encodeURIComponent(spaceId)}/members/${encodeURIComponent(userId)}`);
-}
-/** `DELETE /api/v1/spaces/:id` — soft delete, 30-day restore window. */
-export async function deleteSpace(spaceId) {
-    await prixRequest('DELETE', `/api/v1/spaces/${encodeURIComponent(spaceId)}`);
-}
-/** `agents-cli-space-name` -> `agi-cli-space-name`; lowercase, hyphenated, matches the backend's `^[a-z0-9-]+$` slug rule. */
-export function slugify(name) {
-    const slug = name.toLowerCase().trim().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
-    return slug || 'space';
-}
-/**
- * Resolve the `--space` a command should act on: an explicit id/slug match
- * against the caller's own space list, or — with nothing passed — the
- * caller's sole space (free tier caps ownership at one, so this is almost
- * always unambiguous). Pure over an already-fetched list so it's cheaply
- * unit-testable with a fixture.
- */
-export function resolveSpaceFromList(spaces, explicit) {
-    if (explicit) {
-        const match = spaces.find(s => s.id === explicit || s.slug === explicit);
-        if (!match)
-            throw new Error(`No space matching '${explicit}'. Run 'agents org list' to see your spaces.`);
-        return match;
-    }
-    if (spaces.length === 0)
-        throw new Error("You have no spaces. Create one with 'agents org create <name>'.");
-    if (spaces.length > 1) {
-        throw new Error(`You belong to ${spaces.length} spaces — pass --space <id-or-slug>: ${spaces.map(s => s.slug).join(', ')}`);
-    }
-    return spaces[0];
-}
-/** Resolve a member's email to their `user_id` from an already-fetched member list. */
-export function resolveMemberFromList(members, email) {
-    const match = members.find(m => m.email.toLowerCase() === email.toLowerCase());
-    if (!match)
-        throw new Error(`'${email}' is not a member of this space. Run 'agents org members' to see who is.`);
-    return match;
-}