@vybestack/llxprt-code 0.10.0 → 0.11.0-nightly.260728.ffaa8d5d7

package/src/ui/commands/permissionsCommand.ts

@@ -5,13 +5,22 @@
  */
 
 import * as path from 'node:path';
+import * as process from 'node:process';
 import type {
   OpenDialogActionReturn,
   SlashCommand,
   MessageActionReturn,
 } from './types.js';
 import { CommandKind } from './types.js';
-import { loadTrustedFolders, TrustLevel } from '../../config/trustedFolders.js';
+import {
+  loadTrustedFolders,
+  resolveLocalWorkspaceTrust,
+  TrustLevel,
+} from '../../config/trustedFolders.js';
+import {
+  combineTrustUpdateFailure,
+  getTrustCommitErrorMessage,
+} from '../trustDialogHelpers.js';
 
 const VALID_TRUST_LEVELS = [
   TrustLevel.TRUST_FOLDER,
@@ -25,6 +34,7 @@ const VALID_TRUST_LEVELS = [
  */
 function parsePermissionsArgs(
   args: string,
+  workingDirectory: string,
 ): { trustLevel: TrustLevel; targetPath: string } | { error: string } {
   const trimmed = args.trim();
 
@@ -68,7 +78,7 @@ function parsePermissionsArgs(
   if (path.isAbsolute(targetPath)) {
     normalizedPath = path.normalize(targetPath);
   } else {
-    normalizedPath = path.resolve(process.cwd(), targetPath);
+    normalizedPath = path.resolve(workingDirectory, targetPath);
   }
 
   return { trustLevel, targetPath: normalizedPath };
@@ -78,8 +88,11 @@ export const permissionsCommand: SlashCommand = {
   name: 'permissions',
   description: 'manage folder trust settings',
   kind: CommandKind.BUILT_IN,
-  action: (_context, args): OpenDialogActionReturn | MessageActionReturn => {
-    const parsed = parsePermissionsArgs(args);
+  action: (context, args) => {
+    const parsed = parsePermissionsArgs(
+      args,
+      context.services.config?.getWorkingDir() ?? process.cwd(),
+    );
 
     // If error is empty string, open dialog (no args case)
     if ('error' in parsed) {
@@ -100,21 +113,65 @@ export const permissionsCommand: SlashCommand = {
     // We have valid trust level and path, modify trust
     const { trustLevel, targetPath } = parsed;
 
-    try {
-      const trustedFolders = loadTrustedFolders();
-      trustedFolders.setValue(targetPath, trustLevel);
-
-      return {
-        type: 'message',
-        messageType: 'info',
-        content: `Trust level set to ${trustLevel} for: ${targetPath}`,
-      };
-    } catch (error) {
-      return {
-        type: 'message',
-        messageType: 'error',
-        content: `Failed to save trust settings: ${error instanceof Error ? error.message : String(error)}`,
-      };
-    }
+    return (async (): Promise<OpenDialogActionReturn | MessageActionReturn> => {
+      let trustedFolders: ReturnType<typeof loadTrustedFolders> | undefined;
+      let savedSnapshot:
+        | ReturnType<ReturnType<typeof loadTrustedFolders>['snapshotValue']>
+        | undefined;
+      const config = context.services.config;
+      const previousLiveTrust = config?.isTrustedFolder() ?? false;
+      let failedPhase: 'persistence' | 'live' = 'persistence';
+      try {
+        trustedFolders = loadTrustedFolders();
+        savedSnapshot = trustedFolders.snapshotValue(targetPath);
+        trustedFolders.setValue(targetPath, trustLevel);
+        if (config) {
+          failedPhase = 'live';
+          const cwd = config.getWorkingDir();
+          await config.setTrustedFolderLive(
+            resolveLocalWorkspaceTrust(
+              { folderTrust: config.getFolderTrust() },
+              trustedFolders,
+              cwd,
+            ) ?? false,
+          );
+        }
+        return {
+          type: 'message',
+          messageType: 'info',
+          content: `Trust level set to ${trustLevel} for: ${targetPath}`,
+        };
+      } catch (error) {
+        const rollbackFailures: unknown[] = [];
+        if (trustedFolders !== undefined && savedSnapshot !== undefined) {
+          try {
+            trustedFolders.restoreSnapshot(savedSnapshot);
+          } catch (rollbackError) {
+            rollbackFailures.push(rollbackError);
+          }
+        }
+        if (config && failedPhase === 'live') {
+          try {
+            await config.setTrustedFolderLive(previousLiveTrust);
+          } catch (rollbackError) {
+            rollbackFailures.push(rollbackError);
+          }
+        }
+        const failure = combineTrustUpdateFailure(
+          error,
+          rollbackFailures,
+          'Trust update and rollback failed',
+        );
+        return {
+          type: 'message',
+          messageType: 'error',
+          content: getTrustCommitErrorMessage(
+            failedPhase,
+            failure.error,
+            failure.rollbackSucceeded,
+          ),
+        };
+      }
+    })();
   },
 };

package/src/ui/commands/policiesCommand.ts

@@ -37,6 +37,7 @@ function getTierBand(priority: number): string {
 interface PolicyRuleDisplay {
   priority?: number;
   toolName?: string;
+  toolNamePrefix?: string;
   decision: PolicyDecision;
   argsPatternSource?: string;
   source?: string;
@@ -45,6 +46,7 @@ interface PolicyRuleDisplay {
 interface PolicyRuleBase {
   priority?: number;
   toolName?: string;
+  toolNamePrefix?: string;
   decision: PolicyDecision;
   source?: string;
 }
@@ -56,6 +58,7 @@ function toPolicyRuleDisplay<T extends PolicyRuleBase>(
   return {
     priority: rule.priority,
     toolName: rule.toolName,
+    toolNamePrefix: rule.toolNamePrefix,
     decision: rule.decision,
     argsPatternSource: extractPattern(rule),
     source: rule.source,
@@ -107,7 +110,9 @@ function formatPolicyOutput(
     lines.push(`${tier}:`);
 
     for (const rule of tierRules) {
-      const toolName = rule.toolName ?? '*';
+      const toolName =
+        rule.toolName ??
+        (rule.toolNamePrefix !== undefined ? `${rule.toolNamePrefix}*` : '*');
       const decision = formatDecision(rule.decision);
       const priority = rule.priority ?? 0;
       const argsPattern = rule.argsPatternSource

package/src/ui/commands/quotaCommand.ts

@@ -0,0 +1,501 @@
+/**
+ * @license
+ * Copyright 2025 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  CommandKind,
+  type SlashCommand,
+  type CommandContext,
+  type SlashCommandActionReturn,
+  type ConfirmActionReturn,
+} from './types.js';
+import { MessageType } from '../types.js';
+import { getRuntimeApi } from '../contexts/RuntimeContext.js';
+import { fetchAllQuotaInfo } from './statsQuota.js';
+import {
+  CodexRateLimitResetCreditsResponseSchema,
+  consumeCodexRateLimitResetCredit,
+  formatCodexResetCredits,
+} from '@vybestack/llxprt-code-providers';
+import type { CodexRateLimitResetCreditsResponse } from '@vybestack/llxprt-code-providers';
+import type { OAuthManager } from '@vybestack/llxprt-code-providers/auth.js';
+import { CodexOAuthTokenSchema } from '@vybestack/llxprt-code-auth';
+import type { CommandArgumentSchema } from './schema/types.js';
+import { randomUUID } from 'node:crypto';
+
+// Non-interactive mode (`llxprt-code --command "/quota reset"`) does not load
+// BuiltinCommandLoader (only FileCommandLoader) and createNonInteractiveUI is
+// a no-op sink, so NO built-in slash command works non-interactively today.
+// Making /quota reset work there requires a cross-cutting change to load
+// built-ins + provide a real non-interactive UI sink, which affects every
+// built-in and is out of scope for this issue.
+
+const NO_RESET_CREDITS_MSG =
+  'No Codex reset credits available. Reset credits are earned via referrals or purchased.';
+const NOT_AUTHED_CODEX_MSG =
+  'Not authenticated with Codex. Run /auth codex to login.';
+const NO_REDEEMABLE_CREDITS_MSG =
+  'No reset credits available to redeem. Reset credits are earned via referrals or purchased.';
+
+interface BucketCredits {
+  readonly bucket: string;
+  readonly availableCount: number;
+  readonly firstCreditId: string | null;
+}
+
+/**
+ * A bucket + credit guaranteed to be redeemable (non-null credit id).
+ * Returned by findRedeemableCredit so callers need no null-narrowing guard.
+ */
+interface RedeemableCredit {
+  readonly bucket: string;
+  readonly firstCreditId: string;
+}
+
+interface RedeemableCreditWithToken extends RedeemableCredit {
+  readonly accessToken: string;
+  readonly accountId: string;
+}
+
+interface BucketTokenInfo {
+  readonly accessToken: string | null;
+  readonly accountId: string | null;
+}
+
+/**
+ * Parse a raw reset-credits payload via the Zod schema once.
+ * Returns the validated response or null when the shape does not validate.
+ */
+function safeParseResetCredits(
+  raw: Record<string, unknown>,
+): CodexRateLimitResetCreditsResponse | null {
+  const parsed = CodexRateLimitResetCreditsResponseSchema.safeParse(raw);
+  return parsed.success ? parsed.data : null;
+}
+
+/**
+ * Resolve the OAuthManager via the runtime API, returning null when the
+ * runtime infrastructure is not registered (mirrors authCommand.getOAuthManager
+ * but degrades to null instead of throwing).
+ */
+function resolveOAuthManager(): OAuthManager | null {
+  try {
+    return getRuntimeApi().getCliOAuthManager();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve the trimmed base-url ephemeral setting, or undefined when blank.
+ */
+function resolveBaseUrl(): string | undefined {
+  const value = getRuntimeApi().getEphemeralSetting('base-url');
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed === '' ? undefined : trimmed;
+}
+
+function addInfo(context: CommandContext, text: string): void {
+  context.ui.addItem({ type: MessageType.INFO, text }, Date.now());
+}
+
+function addError(context: CommandContext, text: string): void {
+  context.ui.addItem({ type: MessageType.ERROR, text }, Date.now());
+}
+
+/**
+ * Status (and default) action: show quota/rate-limit info for all providers.
+ */
+async function statusAction(context: CommandContext): Promise<void> {
+  try {
+    const runtimeApi = getRuntimeApi();
+    const quotaLines = await fetchAllQuotaInfo(runtimeApi);
+
+    if (quotaLines.length === 0) {
+      addInfo(
+        context,
+        'No quota information available. Supported providers: Claude Code (OAuth), Codex (OAuth), Z.ai, Synthetic, Chutes, Kimi.',
+      );
+      return;
+    }
+
+    addInfo(context, quotaLines.join('\n'));
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : 'Unknown error';
+    addError(context, `Failed to retrieve quota information: ${msg}`);
+  }
+}
+
+/**
+ * Parse a single bucket's reset-credits payload via the Zod schema.
+ * Returns null when the shape does not validate.
+ */
+function parseBucketCredits(
+  bucket: string,
+  raw: Record<string, unknown>,
+): BucketCredits | null {
+  const parsed = safeParseResetCredits(raw);
+  if (parsed === null) {
+    return null;
+  }
+  const credits = parsed.rate_limit_reset_credits;
+  const availableCount = credits?.available_count ?? 0;
+  const creditList = credits?.credits ?? [];
+  const firstCreditId =
+    creditList.length > 0 && creditList[0]?.id ? creditList[0].id : null;
+  return { bucket, availableCount, firstCreditId };
+}
+
+/**
+ * Format a single bucket's reset credits into display lines (with optional
+ * bucket header), or null when there is nothing to show.
+ */
+function formatOneBucket(
+  bucket: string,
+  parsed: CodexRateLimitResetCreditsResponse,
+  multiBucket: boolean,
+): string[] | null {
+  const lines = formatCodexResetCredits(parsed);
+  if (lines.length === 0) {
+    return null;
+  }
+  const result: string[] = [];
+  if (multiBucket) {
+    result.push(`### Bucket: ${bucket}\n`);
+  }
+  result.push(...lines);
+  result.push('');
+  return result;
+}
+
+/**
+ * Format all bucket reset-credits into display lines with bucket headers.
+ * Each bucket is parsed once via the schema; buckets that fail to validate
+ * are skipped.
+ */
+function formatAllResetCreditsLines(
+  creditsMap: Map<string, Record<string, unknown>>,
+): string[] {
+  const output: string[] = [];
+  const multiBucket = creditsMap.size > 1;
+
+  for (const [bucket, raw] of creditsMap.entries()) {
+    const parsed = safeParseResetCredits(raw);
+    if (parsed === null) {
+      continue;
+    }
+    const bucketLines = formatOneBucket(bucket, parsed, multiBucket);
+    if (bucketLines !== null) {
+      output.push(...bucketLines);
+    }
+  }
+
+  if (output[output.length - 1] === '') {
+    output.pop();
+  }
+  return output;
+}
+
+/**
+ * Credits subcommand action: show available Codex reset credits.
+ */
+async function creditsAction(context: CommandContext): Promise<void> {
+  const oauthManager = resolveOAuthManager();
+  if (!oauthManager) {
+    addInfo(context, NO_RESET_CREDITS_MSG);
+    return;
+  }
+
+  try {
+    const creditsMap = await oauthManager.getAllCodexRateLimitResetCredits();
+
+    if (creditsMap.size === 0) {
+      addInfo(context, NO_RESET_CREDITS_MSG);
+      return;
+    }
+
+    const lines = formatAllResetCreditsLines(creditsMap);
+    if (lines.length === 0) {
+      addInfo(context, NO_RESET_CREDITS_MSG);
+      return;
+    }
+
+    addInfo(context, lines.join('\n'));
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : 'Unknown error';
+    addError(context, `Failed to retrieve reset credits: ${msg}`);
+  }
+}
+
+/**
+ * Determine whether the user is authenticated with Codex.
+ */
+async function isCodexAuthed(oauthManager: OAuthManager): Promise<boolean> {
+  const token = await oauthManager.getToken('codex');
+  if (token !== null) {
+    return true;
+  }
+  const buckets = await oauthManager.listBuckets('codex');
+  return buckets.length > 0;
+}
+
+/**
+ * Find all buckets with a credit that can be redeemed.
+ */
+async function findRedeemableCredits(
+  oauthManager: OAuthManager,
+): Promise<readonly RedeemableCredit[]> {
+  const creditsMap = await oauthManager.getAllCodexRateLimitResetCredits();
+  const redeemableCredits: RedeemableCredit[] = [];
+
+  for (const [bucket, raw] of creditsMap.entries()) {
+    const parsed = parseBucketCredits(bucket, raw);
+    if (
+      parsed !== null &&
+      parsed.availableCount > 0 &&
+      parsed.firstCreditId !== null
+    ) {
+      redeemableCredits.push({
+        bucket: parsed.bucket,
+        firstCreditId: parsed.firstCreditId,
+      });
+    }
+  }
+  return redeemableCredits;
+}
+
+/**
+ * Resolve the access token + account_id for a Codex bucket.
+ */
+async function resolveBucketToken(
+  oauthManager: OAuthManager,
+  bucket: string,
+): Promise<BucketTokenInfo> {
+  const tokenStore = oauthManager.getTokenStore();
+  const token = await tokenStore.getToken('codex', bucket);
+  if (token === null) {
+    return { accessToken: null, accountId: null };
+  }
+  const parsed = CodexOAuthTokenSchema.safeParse(token);
+  if (!parsed.success) {
+    return { accessToken: null, accountId: null };
+  }
+  // Guard against a token that expired between the credit-listing call and
+  // this resolve — sending an expired token to consume would yield a 401 and
+  // a misleading generic error.
+  if (parsed.data.expiry <= Math.floor(Date.now() / 1000)) {
+    return { accessToken: null, accountId: null };
+  }
+  return {
+    accessToken: parsed.data.access_token,
+    accountId: parsed.data.account_id,
+  };
+}
+
+async function findRedeemableCreditWithToken(
+  oauthManager: OAuthManager,
+  redeemableCredits: readonly RedeemableCredit[],
+): Promise<RedeemableCreditWithToken | null> {
+  for (const redeemable of redeemableCredits) {
+    const tokenInfo = await resolveBucketToken(oauthManager, redeemable.bucket);
+    if (tokenInfo.accessToken !== null && tokenInfo.accountId !== null) {
+      return {
+        ...redeemable,
+        accessToken: tokenInfo.accessToken,
+        accountId: tokenInfo.accountId,
+      };
+    }
+  }
+  return null;
+}
+
+const RESET_CONFIRMATION_PROMPT =
+  'Redeem a Codex rate-limit-reset credit to reset your rate-limit window? This consumes one earned/purchased reset credit.';
+
+/**
+ * Build the confirm_action return value for /quota reset, deriving the
+ * original raw invocation (falling back to a canonical form when the
+ * invocation context is absent or blank).
+ */
+function buildResetConfirmation(context: CommandContext): ConfirmActionReturn {
+  const rawInvocation =
+    context.invocation?.raw && context.invocation.raw.trim() !== ''
+      ? context.invocation.raw
+      : '/quota reset codex';
+  return {
+    type: 'confirm_action',
+    prompt: RESET_CONFIRMATION_PROMPT,
+    originalInvocation: { raw: rawInvocation },
+  };
+}
+
+/**
+ * Consume the redeemable credit and render the result (success / already
+ * redeemed / failure) plus a refreshed quota snapshot. Returns void — all
+ * user feedback flows through addInfo/addError.
+ */
+async function redeemResetCredit(
+  context: CommandContext,
+  accessToken: string,
+  accountId: string,
+  creditId: string,
+): Promise<void> {
+  // Both the credit listing (getAllCodexRateLimitResetCredits) and this
+  // consume call resolve base-url from the same runtime settings source, so
+  // list and consume always target the same backend host.
+  const baseUrl = resolveBaseUrl();
+  const redeemRequestId = randomUUID();
+  const consumeResult = await consumeCodexRateLimitResetCredit(
+    accessToken,
+    accountId,
+    creditId,
+    redeemRequestId,
+    baseUrl,
+  );
+
+  if (consumeResult === null) {
+    addError(
+      context,
+      'Failed to reset rate-limit window. Please try again later.',
+    );
+    return;
+  }
+
+  if (consumeResult.code === 'reset') {
+    addInfo(context, 'Rate-limit window reset successfully.');
+  } else {
+    addInfo(context, 'Credit already redeemed.');
+  }
+
+  // fetchAllQuotaInfo has its own internal error handling and returns [] on
+  // failure, so it never throws — no extra guard is needed here.
+  const runtimeApi = getRuntimeApi();
+  const quotaLines = await fetchAllQuotaInfo(runtimeApi);
+  if (quotaLines.length > 0) {
+    addInfo(context, quotaLines.join('\n'));
+  }
+}
+
+/**
+ * Reset subcommand action: redeem a Codex rate-limit-reset credit.
+ */
+async function resetAction(
+  context: CommandContext,
+  args: string,
+): Promise<SlashCommandActionReturn | void> {
+  const tokens = args
+    .trim()
+    .split(/\s+/)
+    .filter((t) => t !== '');
+  const provider = tokens[0] ?? '';
+
+  if (provider !== '' && provider !== 'codex') {
+    addError(context, "Only 'codex' supports reset.");
+    return undefined;
+  }
+  if (tokens.length > 1) {
+    addError(context, 'Too many arguments. Usage: /quota reset [codex]');
+    return undefined;
+  }
+
+  const oauthManager = resolveOAuthManager();
+  if (!oauthManager) {
+    addInfo(context, NOT_AUTHED_CODEX_MSG);
+    return undefined;
+  }
+
+  try {
+    const authed = await isCodexAuthed(oauthManager);
+    if (!authed) {
+      addInfo(context, NOT_AUTHED_CODEX_MSG);
+      return undefined;
+    }
+
+    const redeemableCredits = await findRedeemableCredits(oauthManager);
+    if (redeemableCredits.length === 0) {
+      addInfo(context, NO_REDEEMABLE_CREDITS_MSG);
+      return undefined;
+    }
+
+    const redeemable = await findRedeemableCreditWithToken(
+      oauthManager,
+      redeemableCredits,
+    );
+    if (redeemable === null) {
+      addError(
+        context,
+        'Codex credentials for all credit-bearing buckets are unavailable or expired. Run /auth codex to re-authenticate.',
+      );
+      return undefined;
+    }
+
+    // Confirmation gate: redeeming consumes a paid/referral-earned resource,
+    // so — like other mutating commands — prompt before performing the
+    // mutation. The confirmed re-invocation arrives with
+    // overwriteConfirmed === true and skips this gate to actually consume.
+    if (context.overwriteConfirmed !== true) {
+      return buildResetConfirmation(context);
+    }
+
+    await redeemResetCredit(
+      context,
+      redeemable.accessToken,
+      redeemable.accountId,
+      redeemable.firstCreditId,
+    );
+    return undefined;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : 'Unknown error';
+    addError(context, `Failed to reset rate-limit window: ${msg}`);
+    return undefined;
+  }
+}
+
+/**
+ * Schema for /quota reset autocomplete: offers 'codex' as the provider.
+ */
+const resetSchema: CommandArgumentSchema = [
+  {
+    kind: 'value',
+    name: 'provider',
+    description: 'Provider to reset',
+    options: [{ value: 'codex', description: 'Codex (ChatGPT)' }],
+  },
+];
+
+export const quotaCommand: SlashCommand = {
+  name: 'quota',
+  description:
+    'Manage quota and rate-limit reset. Usage: /quota [status|credits|reset]',
+  kind: CommandKind.BUILT_IN,
+  action: statusAction,
+  subCommands: [
+    {
+      name: 'status',
+      description: 'Show quota/rate-limit status for all providers.',
+      kind: CommandKind.BUILT_IN,
+      autoExecute: true,
+      action: statusAction,
+    },
+    {
+      name: 'credits',
+      description: 'Show available Codex rate-limit-reset credits.',
+      kind: CommandKind.BUILT_IN,
+      autoExecute: true,
+      action: creditsAction,
+    },
+    {
+      name: 'reset',
+      description:
+        'Redeem a Codex rate-limit-reset credit to reset the rate-limit window.',
+      kind: CommandKind.BUILT_IN,
+      schema: resetSchema,
+      action: resetAction,
+    },
+  ],
+};

package/src/ui/commands/statsCommand.ts

@@ -74,7 +74,7 @@ async function quotaSubcommandAction(context: CommandContext): Promise<void> {
       context.ui.addItem(
         {
           type: MessageType.INFO,
-          text: 'No quota information available. Supported providers: Anthropic (OAuth), Codex (OAuth), Z.ai, Synthetic, Chutes, Kimi.',
+          text: 'No quota information available. Supported providers: Claude Code (OAuth), Codex (OAuth), Z.ai, Synthetic, Chutes, Kimi.',
         },
         Date.now(),
       );
@@ -278,7 +278,7 @@ export const statsCommand: SlashCommand = {
     {
       name: 'quota',
       description:
-        'Show quota/usage information for OAuth providers (Anthropic, Codex) and API-key providers (Z.ai, Synthetic, Chutes, Kimi).',
+        'Show quota/usage information for OAuth providers (Claude Code, Codex) and API-key providers (Z.ai, Synthetic, Chutes, Kimi).',
       kind: CommandKind.BUILT_IN,
       action: quotaSubcommandAction,
     },

package/src/ui/commands/statsQuota.ts

@@ -305,7 +305,7 @@ async function fetchOAuthQuotaLines(
 
   const anthropicLines = formatAnthropicLines(anthropicUsageInfo);
   if (anthropicLines.length > 0) {
-    output.push('## Anthropic Quota Information\n');
+    output.push('## Claude Code Quota Information\n');
     output.push(...anthropicLines);
   }