@pungoyal/kite-cli 0.1.0 → 0.2.0

package/dist/core/api.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { UsageError } from './errors.js';
-import { AuctionSchema, BasketMarginSchema, CandlesSchema, GttCreateResultSchema, GttSchema, HoldingSchema, LtpMapSchema, MarginsSchema, MfHoldingSchema, MfOrderSchema, MfSipSchema, OhlcMapSchema, OrderMarginSchema, OrderSchema, PlaceOrderResultSchema, PositionsSchema, ProfileSchema, QuoteMapSchema, SessionSchema, TradeSchema, } from './schemas.js';
+import { AlertHistoryEntrySchema, AlertSchema, AuctionSchema, BasketMarginSchema, CandlesSchema, GttCreateResultSchema, GttSchema, HoldingSchema, LtpMapSchema, MarginsSchema, MfHoldingSchema, MfOrderSchema, MfSipSchema, OhlcMapSchema, OrderMarginSchema, OrderSchema, PlaceOrderResultSchema, PositionsSchema, ProfileSchema, QuoteMapSchema, SessionSchema, TradeSchema, } from './schemas.js';
 export const VARIETIES = ['regular', 'amo', 'co', 'iceberg', 'auction'];
 export const ORDER_TYPES = ['MARKET', 'LIMIT', 'SL', 'SL-M'];
 export const PRODUCTS = ['CNC', 'NRML', 'MIS', 'MTF'];
@@ -184,6 +184,67 @@ export class KiteApi {
         });
     }
     // -------------------------------------------------------------------------
+    // Alerts
+    // -------------------------------------------------------------------------
+    async getAlerts(signal) {
+        return this.client.request({
+            method: 'GET',
+            path: '/alerts',
+            schema: z.array(AlertSchema),
+            signal,
+        });
+    }
+    async getAlert(uuid, signal) {
+        return this.client.request({
+            method: 'GET',
+            path: `/alerts/${encodeURIComponent(uuid)}`,
+            schema: AlertSchema,
+            signal,
+        });
+    }
+    async getAlertHistory(uuid, signal) {
+        return this.client.request({
+            method: 'GET',
+            path: `/alerts/${encodeURIComponent(uuid)}/history`,
+            schema: z.array(AlertHistoryEntrySchema),
+            signal,
+        });
+    }
+    async createAlert(params, signal) {
+        return this.client.request({
+            method: 'POST',
+            path: '/alerts',
+            schema: AlertSchema,
+            form: serialiseAlert(params),
+            signal,
+        });
+    }
+    async modifyAlert(uuid, params, signal) {
+        return this.client.request({
+            method: 'PUT',
+            path: `/alerts/${encodeURIComponent(uuid)}`,
+            schema: AlertSchema,
+            form: serialiseAlert(params),
+            signal,
+        });
+    }
+    /**
+     * Delete one or more alerts.
+     *
+     * Kite takes the uuids as *repeated query parameters* (`?uuid=a&uuid=b`) on a
+     * DELETE, not a path segment or a form body — an easy thing to carry over
+     * wrongly from the GTT delete, which is path-keyed by a numeric id.
+     */
+    async deleteAlerts(uuids, signal) {
+        return this.client.request({
+            method: 'DELETE',
+            path: '/alerts',
+            query: { uuid: uuids },
+            schema: z.unknown(),
+            signal,
+        });
+    }
+    // -------------------------------------------------------------------------
     // Portfolio
     // -------------------------------------------------------------------------
     async getHoldings(signal) {
@@ -393,6 +454,44 @@ function serialiseGtt(params) {
     };
 }
 // ---------------------------------------------------------------------------
+// Alert serialisation
+// ---------------------------------------------------------------------------
+export const ALERT_TYPES = ['simple', 'ato'];
+/** Kite's raw comparison operators. The CLI accepts friendlier aliases and
+ * normalises to these before they reach the wire. */
+export const ALERT_OPERATORS = ['<=', '>=', '<', '>', '=='];
+export const ALERT_RHS_TYPES = ['constant', 'instrument'];
+/** The only left/right attribute Kite documents for alerts. */
+export const ALERT_DEFAULT_ATTRIBUTE = 'LastTradedPrice';
+/**
+ * Alert fields are plain form values — EXCEPT `basket`, which is a JSON-encoded
+ * string inside a form field, the same asymmetry as `serialiseGtt`. The right
+ * side is sent as either a constant or an instrument reference, never both.
+ */
+function serialiseAlert(params) {
+    const form = {
+        name: params.name,
+        type: params.type,
+        lhs_exchange: params.lhs_exchange,
+        lhs_tradingsymbol: params.lhs_tradingsymbol,
+        lhs_attribute: params.lhs_attribute,
+        operator: params.operator,
+        rhs_type: params.rhs_type,
+    };
+    if (params.rhs_type === 'constant') {
+        form.rhs_constant = params.rhs_constant;
+    }
+    else {
+        form.rhs_exchange = params.rhs_exchange;
+        form.rhs_tradingsymbol = params.rhs_tradingsymbol;
+        form.rhs_attribute = params.rhs_attribute;
+    }
+    if (params.basket) {
+        form.basket = JSON.stringify(params.basket);
+    }
+    return form;
+}
+// ---------------------------------------------------------------------------
 // Historical helpers
 // ---------------------------------------------------------------------------
 export const HISTORICAL_INTERVALS = [

package/dist/core/config.d.ts

@@ -12,6 +12,46 @@ export declare const EnvironmentSchema: z.ZodEnum<{
     sandbox: "sandbox";
 }>;
 export type Environment = z.infer<typeof EnvironmentSchema>;
+export declare const TradingSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+    maxOrderValue: z.ZodOptional<z.ZodNumber>;
+    strictConfirmAbove: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type TradingConfig = z.infer<typeof TradingSchema>;
+/**
+ * Per-profile trading overrides. Every field is optional with NO default:
+ * an absent field means "inherit the global setting", never "no limit". That
+ * inheritance is deliberately fail-closed — a profile that omits a cap must
+ * still be bound by the global cap, or the one guard the user configured would
+ * silently stop applying to their other accounts.
+ */
+export declare const ProfileTradingSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+    maxOrderValue: z.ZodOptional<z.ZodNumber>;
+    strictConfirmAbove: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ProfileTradingOverrides = z.infer<typeof ProfileTradingSchema>;
+/**
+ * A named account. Each real Zerodha account has its own Kite Connect app, so a
+ * profile carries its own (semi-public) api key and env; its api secret and
+ * access token live in the keyring / encrypted file, namespaced by profile.
+ */
+export declare const ProfileConfigSchema: z.ZodObject<{
+    apiKey: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodEnum<{
+        production: "production";
+        sandbox: "sandbox";
+    }>>;
+    trading: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        confirm: z.ZodOptional<z.ZodBoolean>;
+        maxOrderValue: z.ZodOptional<z.ZodNumber>;
+        strictConfirmAbove: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ProfileConfig = z.infer<typeof ProfileConfigSchema>;
 export declare const ConfigSchema: z.ZodObject<{
     apiKey: z.ZodOptional<z.ZodString>;
     env: z.ZodDefault<z.ZodEnum<{
@@ -24,10 +64,24 @@ export declare const ConfigSchema: z.ZodObject<{
         maxOrderValue: z.ZodOptional<z.ZodNumber>;
         strictConfirmAbove: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
+    defaultProfile: z.ZodOptional<z.ZodString>;
+    profiles: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        apiKey: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodEnum<{
+            production: "production";
+            sandbox: "sandbox";
+        }>>;
+        trading: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            confirm: z.ZodOptional<z.ZodBoolean>;
+            maxOrderValue: z.ZodOptional<z.ZodNumber>;
+            strictConfirmAbove: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
     output: z.ZodPrefault<z.ZodObject<{
         color: z.ZodDefault<z.ZodEnum<{
-            auto: "auto";
             always: "always";
+            auto: "auto";
             never: "never";
         }>>;
         compact: z.ZodDefault<z.ZodBoolean>;
@@ -51,44 +105,44 @@ export declare function saveConfig(config: Config): Promise<void>;
  */
 export declare const SETTABLE_KEYS: {
     readonly apiKey: {
-        readonly type: "string";
-        readonly description: "Kite Connect API key";
+        readonly type: 'string';
+        readonly description: 'Kite Connect API key';
     };
     readonly env: {
-        readonly type: "string";
-        readonly description: "production or sandbox";
+        readonly type: 'string';
+        readonly description: 'production or sandbox';
     };
     readonly 'trading.enabled': {
-        readonly type: "boolean";
-        readonly description: "Master kill switch for all order commands";
+        readonly type: 'boolean';
+        readonly description: 'Master kill switch for all order commands';
     };
     readonly 'trading.confirm': {
-        readonly type: "boolean";
-        readonly description: "Require confirmation before money-moving actions";
+        readonly type: 'boolean';
+        readonly description: 'Require confirmation before money-moving actions';
     };
     readonly 'trading.maxOrderValue': {
-        readonly type: "number";
-        readonly description: "Refuse any single order above this rupee value";
+        readonly type: 'number';
+        readonly description: 'Refuse any single order above this rupee value';
     };
     readonly 'trading.strictConfirmAbove': {
-        readonly type: "number";
-        readonly description: "Above this rupee value, require typing the symbol to confirm";
+        readonly type: 'number';
+        readonly description: 'Above this rupee value, require typing the symbol to confirm';
     };
     readonly 'output.color': {
-        readonly type: "string";
-        readonly description: "auto, always, or never";
+        readonly type: 'string';
+        readonly description: 'auto, always, or never';
     };
     readonly 'output.compact': {
-        readonly type: "boolean";
-        readonly description: "Render tables without borders";
+        readonly type: 'boolean';
+        readonly description: 'Render tables without borders';
     };
     readonly redirectPort: {
-        readonly type: "number";
-        readonly description: "Loopback port for the login callback";
+        readonly type: 'number';
+        readonly description: 'Loopback port for the login callback';
     };
     readonly redirectPath: {
-        readonly type: "string";
-        readonly description: "Path component of the login callback URL";
+        readonly type: 'string';
+        readonly description: 'Path component of the login callback URL';
     };
 };
 export type SettableKey = keyof typeof SETTABLE_KEYS;
@@ -107,8 +161,8 @@ export interface Endpoints {
 export declare function endpointsFor(env: Environment): Endpoints;
 /** Public sandbox credentials, documented at https://kite.trade/docs/connect/v3/sandbox/ */
 export declare const SANDBOX_CREDENTIALS: {
-    readonly apiKey: "sandboxdemo";
-    readonly apiSecret: "sandboxdemo-secret";
+    readonly apiKey: 'sandboxdemo';
+    readonly apiSecret: 'sandboxdemo-secret';
 };
 /** Resolve the effective environment: --env flag > KITE_ENV > config > production. */
 export declare function resolveEnv(flag: string | undefined, config: Config): Environment;

package/dist/core/config.js

@@ -11,31 +11,63 @@ import { configDir, configFile, ensurePrivateDir } from './paths.js';
  * is exactly how an accidental order gets placed.
  */
 export const EnvironmentSchema = z.enum(['production', 'sandbox']);
+export const TradingSchema = z.object({
+    /**
+     * Local kill switch. When false, every order-placing, order-modifying and
+     * GTT-mutating command refuses before touching the network.
+     */
+    enabled: z.boolean().default(true),
+    /** Require an interactive confirmation before any money-moving action. */
+    confirm: z.boolean().default(true),
+    /**
+     * Refuse any single order whose notional value exceeds this (rupees).
+     * Undefined means no cap.
+     */
+    maxOrderValue: z.number().positive().optional(),
+    /**
+     * Above this notional value, require typing a literal token to confirm
+     * rather than a single keystroke.
+     */
+    strictConfirmAbove: z.number().positive().default(100_000),
+});
+/**
+ * Per-profile trading overrides. Every field is optional with NO default:
+ * an absent field means "inherit the global setting", never "no limit". That
+ * inheritance is deliberately fail-closed — a profile that omits a cap must
+ * still be bound by the global cap, or the one guard the user configured would
+ * silently stop applying to their other accounts.
+ */
+export const ProfileTradingSchema = z.object({
+    enabled: z.boolean().optional(),
+    confirm: z.boolean().optional(),
+    maxOrderValue: z.number().positive().optional(),
+    strictConfirmAbove: z.number().positive().optional(),
+});
+/**
+ * A named account. Each real Zerodha account has its own Kite Connect app, so a
+ * profile carries its own (semi-public) api key and env; its api secret and
+ * access token live in the keyring / encrypted file, namespaced by profile.
+ */
+export const ProfileConfigSchema = z.object({
+    apiKey: z.string().min(1).optional(),
+    env: EnvironmentSchema.optional(),
+    trading: ProfileTradingSchema.optional(),
+});
 export const ConfigSchema = z.object({
     /** Kite Connect API key. Semi-public (it appears in login URLs), so not a keyring secret. */
     apiKey: z.string().min(1).optional(),
     env: EnvironmentSchema.default('production'),
-    trading: z
-        .object({
-        /**
-         * Local kill switch. When false, every order-placing, order-modifying and
-         * GTT-mutating command refuses before touching the network.
-         */
-        enabled: z.boolean().default(true),
-        /** Require an interactive confirmation before any money-moving action. */
-        confirm: z.boolean().default(true),
-        /**
-         * Refuse any single order whose notional value exceeds this (rupees).
-         * Undefined means no cap.
-         */
-        maxOrderValue: z.number().positive().optional(),
-        /**
-         * Above this notional value, require typing a literal token to confirm
-         * rather than a single keystroke.
-         */
-        strictConfirmAbove: z.number().positive().default(100_000),
-    })
-        .prefault({}),
+    trading: TradingSchema.prefault({}),
+    /**
+     * The profile used when none is named on the command line or in KITE_PROFILE.
+     * Absent means the reserved `default` profile (top-level apiKey/env above).
+     */
+    defaultProfile: z.string().min(1).optional(),
+    /**
+     * Named accounts beyond `default`. The `default` and `sandbox` profiles are
+     * reserved and synthesised, so they never need an entry here.
+     */
+    profiles: z.record(z.string(), ProfileConfigSchema).default({}),
     output: z
         .object({
         color: z.enum(['auto', 'always', 'never']).default('auto'),

package/dist/core/credentials.d.ts

@@ -7,7 +7,8 @@ export interface CredentialLookup {
 /** True when an OS keyring is present and usable on this machine. */
 export declare function keyringAvailable(): Promise<boolean>;
 export interface CredentialStoreOptions {
-    env: string;
+    /** Profile storage prefix, e.g. '' (default), 'sandbox:', 'profile:<name>:'. */
+    scope: string;
     /** Passphrase for the file backend when the keyring is unavailable. */
     passphrase?: string | undefined;
 }
@@ -21,7 +22,7 @@ export interface CredentialStoreOptions {
 export declare function getSecret(name: SecretName, opts: CredentialStoreOptions): Promise<CredentialLookup | null>;
 export declare function setSecret(name: SecretName, value: string, opts: CredentialStoreOptions): Promise<Backend>;
 export declare function deleteSecret(name: SecretName, opts: CredentialStoreOptions): Promise<void>;
-/** Remove every stored secret for an environment. Used by `kite logout --all`. */
+/** Remove every stored secret for a profile. Used by `kite logout --all`. */
 export declare function deleteAllSecrets(opts: CredentialStoreOptions): Promise<void>;
 /** True when secrets are being supplied entirely by the environment. */
 export declare function usingEnvCredentials(): boolean;

package/dist/core/credentials.js

@@ -105,9 +105,15 @@ function filePassphrase() {
     const value = process.env['KITE_CREDENTIALS_PASSPHRASE'];
     return value && value !== '' ? value : null;
 }
-/** Namespaced account key, so sandbox and production sessions coexist. */
-function accountKey(name, env) {
-    return env === 'production' ? name : `${env}:${name}`;
+/**
+ * Name the keyring entry / file key for a secret by prepending the profile's
+ * storage prefix. The prefix ('' for default, 'sandbox:', 'profile:<name>:') is
+ * computed by `storagePrefixFor` in profiles.ts and passed in, so this module
+ * stays unaware of the profile model — and the default profile keeps the exact
+ * unprefixed keys the single-account CLI has always written.
+ */
+function scopedKey(name, scope) {
+    return `${scope}${name}`;
 }
 /**
  * Read a secret, trying each backend in priority order.
@@ -122,7 +128,7 @@ export async function getSecret(name, opts) {
         registerSecret(fromEnv);
         return { value: fromEnv, backend: 'env' };
     }
-    const account = accountKey(name, opts.env);
+    const account = scopedKey(name, opts.scope);
     const fromKeyring = await keyringGet(account);
     if (fromKeyring) {
         registerSecret(fromKeyring);
@@ -141,7 +147,7 @@ export async function getSecret(name, opts) {
 }
 export async function setSecret(name, value, opts) {
     registerSecret(value);
-    const account = accountKey(name, opts.env);
+    const account = scopedKey(name, opts.scope);
     if (await keyringSet(account, value)) {
         return 'keyring';
     }
@@ -155,7 +161,7 @@ export async function setSecret(name, value, opts) {
     return 'file';
 }
 export async function deleteSecret(name, opts) {
-    const account = accountKey(name, opts.env);
+    const account = scopedKey(name, opts.scope);
     await keyringDelete(account);
     const passphrase = opts.passphrase ?? filePassphrase();
     if (passphrase) {
@@ -171,7 +177,7 @@ export async function deleteSecret(name, opts) {
         }
     }
 }
-/** Remove every stored secret for an environment. Used by `kite logout --all`. */
+/** Remove every stored secret for a profile. Used by `kite logout --all`. */
 export async function deleteAllSecrets(opts) {
     await deleteSecret('access_token', opts);
     await deleteSecret('api_secret', opts);

package/dist/core/errors.d.ts

@@ -62,7 +62,7 @@ export declare class KiteApiError extends KiteCliError {
 }
 /** The local session is missing or expired. */
 export declare class AuthRequiredError extends KiteCliError {
-    constructor(message?: string);
+    constructor(message?: string, hint?: string);
 }
 /** Bad CLI usage — distinct from Kite rejecting valid-looking input. */
 export declare class UsageError extends KiteCliError {

package/dist/core/errors.js

@@ -63,8 +63,8 @@ export class KiteApiError extends KiteCliError {
 }
 /** The local session is missing or expired. */
 export class AuthRequiredError extends KiteCliError {
-    constructor(message = 'Not logged in.') {
-        super(message, ExitCode.Auth, 'Run `kite login` to start a session.');
+    constructor(message = 'Not logged in.', hint = 'Run `kite login` to start a session.') {
+        super(message, ExitCode.Auth, hint);
     }
 }
 /** Bad CLI usage — distinct from Kite rejecting valid-looking input. */

package/dist/core/paths.d.ts

@@ -1,8 +1,15 @@
 export declare function configDir(): string;
 export declare function cacheDir(): string;
 export declare function configFile(): string;
-/** Non-secret session metadata (expiry, user id). The token itself is not here. */
-export declare function sessionFile(): string;
+/**
+ * Non-secret session metadata (expiry, user id) for a profile. The token itself
+ * is not here.
+ *
+ * The `default` profile keeps the historical `session.json` path so existing
+ * installs are untouched; every other profile gets its own `session.<name>.json`,
+ * which is what lets several accounts hold live sessions at once.
+ */
+export declare function sessionFile(profile?: string): string;
 /** Encrypted credential store, used only when the OS keyring is unavailable. */
 export declare function credentialsFile(): string;
 /** Instrument master cache, refreshed daily. */

package/dist/core/paths.js

@@ -27,9 +27,18 @@ export function cacheDir() {
 export function configFile() {
     return join(configDir(), 'config.json');
 }
-/** Non-secret session metadata (expiry, user id). The token itself is not here. */
-export function sessionFile() {
-    return join(configDir(), 'session.json');
+/**
+ * Non-secret session metadata (expiry, user id) for a profile. The token itself
+ * is not here.
+ *
+ * The `default` profile keeps the historical `session.json` path so existing
+ * installs are untouched; every other profile gets its own `session.<name>.json`,
+ * which is what lets several accounts hold live sessions at once.
+ */
+export function sessionFile(profile = 'default') {
+    if (profile === 'default')
+        return join(configDir(), 'session.json');
+    return join(configDir(), `session.${profile}.json`);
 }
 /** Encrypted credential store, used only when the OS keyring is unavailable. */
 export function credentialsFile() {

package/dist/core/profiles.d.ts

@@ -0,0 +1,78 @@
+import { type Config, type Environment, type TradingConfig } from './config.js';
+/**
+ * Multi-account resolution.
+ *
+ * A *profile* is a named Zerodha account. Selection is stateless per invocation
+ * — there is deliberately no sticky "active account" that persists across
+ * commands, because forgetting which account is active while placing real
+ * orders is exactly the mistake this feature must not introduce. Instead the
+ * target is resolved fresh every run, and the money-moving preview shows the
+ * verified user id (see `safety.ts`).
+ *
+ * Two profile names are reserved:
+ *   - `default`  — today's single-account setup (top-level apiKey/env in config,
+ *                  secrets stored unprefixed). Chosen so existing installs need
+ *                  no migration.
+ *   - `sandbox`  — Zerodha's public sandbox. One fixed identity, so there is no
+ *                  value in per-account sandbox profiles.
+ */
+export declare const DEFAULT_PROFILE = "default";
+export declare const SANDBOX_PROFILE = "sandbox";
+export declare const RESERVED_PROFILES: readonly ["default", "sandbox"];
+export interface ResolvedProfile {
+    name: string;
+    /** Semi-public Kite Connect API key. Empty until the profile is logged in. */
+    apiKey: string;
+    env: Environment;
+    /** Per-profile trading overrides, or undefined to use the global settings. */
+    trading: Config['profiles'][string]['trading'];
+    /**
+     * True when the caller named this profile explicitly (`--profile` / KITE_PROFILE),
+     * as opposed to falling back to the configured default or the `--env` alias.
+     * Drives the fail-closed guard against an ambient KITE_ACCESS_TOKEN silently
+     * overriding an explicitly chosen account.
+     */
+    explicit: boolean;
+}
+/** Reject names that could escape a filename or collide with a reserved prefix. */
+export declare function assertValidProfileName(name: string): void;
+/**
+ * Keyring / encrypted-file namespace for a profile's secrets.
+ *
+ * The reserved profiles reproduce the historical env-keyed scheme byte-for-byte
+ * (`production` unprefixed, `sandbox:` otherwise), so no stored secret has to be
+ * migrated. Every other profile gets a `profile:<name>:` namespace that cannot
+ * collide with an env name.
+ */
+export declare function storagePrefixFor(profile: Pick<ResolvedProfile, 'name' | 'env'>): string;
+/** Every profile the user has, reserved ones first, without duplicates. */
+export declare function listProfileNames(config: Config): string[];
+export declare function isKnownProfile(config: Config, name: string): boolean;
+/**
+ * Look up a profile by name without applying command-line overrides.
+ *
+ * An unknown name yields an empty, production profile rather than throwing, so
+ * `kite --profile new login` (and `profiles add`) can create it.
+ */
+export declare function getProfile(config: Config, name: string): ResolvedProfile;
+export interface ProfileSelectors {
+    /** The `--profile` flag value, if any. */
+    profileFlag?: string | undefined;
+    /** The `--env` flag value, if any. */
+    envFlag?: string | undefined;
+}
+/**
+ * Resolve the effective profile for this invocation.
+ *
+ * Precedence: `--profile` > KITE_PROFILE > (`--env sandbox` alias) >
+ * `config.defaultProfile` > `default`. An explicit `--env`/KITE_ENV then
+ * overrides the resolved profile's environment, so `--env production` still
+ * forces production the way it always has.
+ */
+export declare function resolveProfile(selectors: ProfileSelectors, config: Config): ResolvedProfile;
+/**
+ * The trading config actually in force: global settings overlaid with the
+ * profile's overrides. Fail-closed by construction — a field the profile leaves
+ * unset falls back to the global value, so an omitted cap never becomes "no cap".
+ */
+export declare function resolveTradingConfig(config: Config, profile: ResolvedProfile): TradingConfig;