@gaberoo/kalshitools 1.0.0

package/dist/lib/config/manager.js

@@ -0,0 +1,137 @@
+import Conf from 'conf';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { defaultConfig } from './schema.js';
+import { ConfigError } from '../errors/base.js';
+import { logger } from '../logger.js';
+/**
+ * Configuration manager for kalshitools
+ */
+export class ConfigManager {
+    store;
+    static instance = null;
+    constructor() {
+        this.store = new Conf({
+            projectName: 'kalshitools',
+            defaults: defaultConfig,
+        });
+    }
+    /**
+     * Get singleton instance
+     */
+    static getInstance() {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+    /**
+     * Get the full configuration
+     */
+    getConfig() {
+        const config = this.store.store;
+        return config;
+    }
+    /**
+     * Get the current environment (demo or production)
+     */
+    getEnvironment() {
+        return process.env.KALSHI_ENV === 'production' ? 'production' : this.store.get('environment', 'demo');
+    }
+    /**
+     * Set the environment
+     */
+    setEnvironment(env) {
+        this.store.set('environment', env);
+    }
+    /**
+     * Get API configuration for the current environment
+     */
+    getApiConfig() {
+        const env = this.getEnvironment();
+        const config = this.store.get(`api.${env}`);
+        // Override with environment variables if present
+        const keyId = process.env.KALSHI_API_KEY_ID || config.keyId;
+        const privateKeyPath = process.env.KALSHI_PRIVATE_KEY_PATH || config.privateKeyPath;
+        if (!keyId || !privateKeyPath) {
+            throw new ConfigError(`API credentials not configured for ${env} environment. Run 'kalshitools config init' to set up.`, { environment: env });
+        }
+        return {
+            baseUrl: config.baseUrl,
+            keyId,
+            privateKeyPath,
+        };
+    }
+    /**
+     * Read private key from file
+     */
+    readPrivateKey() {
+        const apiConfig = this.getApiConfig();
+        const keyPath = apiConfig.privateKeyPath;
+        // Expand ~ to home directory
+        const expandedPath = keyPath.startsWith('~') ? join(homedir(), keyPath.slice(1)) : keyPath;
+        try {
+            const privateKey = readFileSync(expandedPath, 'utf-8');
+            logger.debug({ path: expandedPath }, 'Read private key from file');
+            return privateKey;
+        }
+        catch (error) {
+            throw new ConfigError(`Failed to read private key from ${expandedPath}`, {
+                path: expandedPath,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Set API configuration for an environment
+     */
+    setApiConfig(env, config) {
+        const current = this.store.get(`api.${env}`);
+        this.store.set(`api.${env}`, { ...current, ...config });
+    }
+    /**
+     * Get output configuration
+     */
+    getOutputConfig() {
+        return this.store.get('output');
+    }
+    /**
+     * Get trading configuration
+     */
+    getTradingConfig() {
+        return this.store.get('trading');
+    }
+    /**
+     * Set a configuration value
+     */
+    set(key, value) {
+        this.store.set(key, value);
+    }
+    /**
+     * Get the configuration file path
+     */
+    getConfigPath() {
+        return this.store.path;
+    }
+    /**
+     * Reset configuration to defaults
+     */
+    reset() {
+        this.store.clear();
+    }
+    /**
+     * Check if configuration is initialized
+     */
+    isConfigured() {
+        const env = this.getEnvironment();
+        const config = this.store.get(`api.${env}`);
+        return Boolean(config.keyId && config.privateKeyPath);
+    }
+}
+/**
+ * Get the global configuration manager instance
+ */
+export function getConfig() {
+    return ConfigManager.getInstance();
+}

package/dist/lib/config/schema.d.ts

@@ -0,0 +1,175 @@
+import { z } from 'zod';
+/**
+ * API environment configuration schema
+ */
+declare const apiEnvSchema: z.ZodObject<{
+    baseUrl: z.ZodString;
+    keyId: z.ZodOptional<z.ZodString>;
+    privateKeyPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    baseUrl: string;
+    keyId?: string | undefined;
+    privateKeyPath?: string | undefined;
+}, {
+    baseUrl: string;
+    keyId?: string | undefined;
+    privateKeyPath?: string | undefined;
+}>;
+/**
+ * Output configuration schema
+ */
+declare const outputSchema: z.ZodObject<{
+    defaultFormat: z.ZodDefault<z.ZodEnum<["table", "json"]>>;
+    colors: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    defaultFormat: "json" | "table";
+    colors: boolean;
+}, {
+    defaultFormat?: "json" | "table" | undefined;
+    colors?: boolean | undefined;
+}>;
+/**
+ * Trading safety configuration schema
+ */
+declare const tradingSchema: z.ZodObject<{
+    confirmations: z.ZodDefault<z.ZodBoolean>;
+    maxOrderSize: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    confirmations: boolean;
+    maxOrderSize: number;
+}, {
+    confirmations?: boolean | undefined;
+    maxOrderSize?: number | undefined;
+}>;
+/**
+ * Main configuration schema
+ */
+export declare const configSchema: z.ZodObject<{
+    version: z.ZodLiteral<"1">;
+    environment: z.ZodDefault<z.ZodEnum<["demo", "production"]>>;
+    api: z.ZodObject<{
+        demo: z.ZodObject<{
+            baseUrl: z.ZodString;
+            keyId: z.ZodOptional<z.ZodString>;
+            privateKeyPath: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            baseUrl: string;
+            keyId?: string | undefined;
+            privateKeyPath?: string | undefined;
+        }, {
+            baseUrl: string;
+            keyId?: string | undefined;
+            privateKeyPath?: string | undefined;
+        }>;
+        production: z.ZodObject<{
+            baseUrl: z.ZodString;
+            keyId: z.ZodOptional<z.ZodString>;
+            privateKeyPath: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            baseUrl: string;
+            keyId?: string | undefined;
+            privateKeyPath?: string | undefined;
+        }, {
+            baseUrl: string;
+            keyId?: string | undefined;
+            privateKeyPath?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        demo: {
+            baseUrl: string;
+            keyId?: string | undefined;
+            privateKeyPath?: string | undefined;
+        };
+        production: {
+            baseUrl: string;
+            keyId?: string | undefined;
+            privateKeyPath?: string | undefined;
+        };
+    }, {
+        demo: {
+            baseUrl: string;
+            keyId?: string | undefined;
+            privateKeyPath?: string | undefined;
+        };
+        production: {
+            baseUrl: string;
+            keyId?: string | undefined;
+            privateKeyPath?: string | undefined;
+        };
+    }>;
+    output: z.ZodDefault<z.ZodObject<{
+        defaultFormat: z.ZodDefault<z.ZodEnum<["table", "json"]>>;
+        colors: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        defaultFormat: "json" | "table";
+        colors: boolean;
+    }, {
+        defaultFormat?: "json" | "table" | undefined;
+        colors?: boolean | undefined;
+    }>>;
+    trading: z.ZodDefault<z.ZodObject<{
+        confirmations: z.ZodDefault<z.ZodBoolean>;
+        maxOrderSize: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        confirmations: boolean;
+        maxOrderSize: number;
+    }, {
+        confirmations?: boolean | undefined;
+        maxOrderSize?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    version: "1";
+    output: {
+        defaultFormat: "json" | "table";
+        colors: boolean;
+    };
+    environment: "demo" | "production";
+    api: {
+        demo: {
+            baseUrl: string;
+            keyId?: string | undefined;
+            privateKeyPath?: string | undefined;
+        };
+        production: {
+            baseUrl: string;
+            keyId?: string | undefined;
+            privateKeyPath?: string | undefined;
+        };
+    };
+    trading: {
+        confirmations: boolean;
+        maxOrderSize: number;
+    };
+}, {
+    version: "1";
+    api: {
+        demo: {
+            baseUrl: string;
+            keyId?: string | undefined;
+            privateKeyPath?: string | undefined;
+        };
+        production: {
+            baseUrl: string;
+            keyId?: string | undefined;
+            privateKeyPath?: string | undefined;
+        };
+    };
+    output?: {
+        defaultFormat?: "json" | "table" | undefined;
+        colors?: boolean | undefined;
+    } | undefined;
+    environment?: "demo" | "production" | undefined;
+    trading?: {
+        confirmations?: boolean | undefined;
+        maxOrderSize?: number | undefined;
+    } | undefined;
+}>;
+export type Config = z.infer<typeof configSchema>;
+export type ApiEnvConfig = z.infer<typeof apiEnvSchema>;
+export type OutputConfig = z.infer<typeof outputSchema>;
+export type TradingConfig = z.infer<typeof tradingSchema>;
+/**
+ * Default configuration
+ */
+export declare const defaultConfig: Config;
+export {};

package/dist/lib/config/schema.js

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+/**
+ * API environment configuration schema
+ */
+const apiEnvSchema = z.object({
+    baseUrl: z.string().url(),
+    keyId: z.string().optional(),
+    privateKeyPath: z.string().optional(),
+});
+/**
+ * Output configuration schema
+ */
+const outputSchema = z.object({
+    defaultFormat: z.enum(['table', 'json']).default('table'),
+    colors: z.boolean().default(true),
+});
+/**
+ * Trading safety configuration schema
+ */
+const tradingSchema = z.object({
+    confirmations: z.boolean().default(true),
+    maxOrderSize: z.number().positive().default(1000),
+});
+/**
+ * Main configuration schema
+ */
+export const configSchema = z.object({
+    version: z.literal('1'),
+    environment: z.enum(['demo', 'production']).default('demo'),
+    api: z.object({
+        demo: apiEnvSchema,
+        production: apiEnvSchema,
+    }),
+    output: outputSchema.default({}),
+    trading: tradingSchema.default({}),
+});
+/**
+ * Default configuration
+ */
+export const defaultConfig = {
+    version: '1',
+    environment: 'demo',
+    api: {
+        demo: {
+            baseUrl: 'https://demo-api.kalshi.co/trade-api/v2',
+        },
+        production: {
+            baseUrl: 'https://trading-api.kalshi.com/trade-api/v2',
+        },
+    },
+    output: {
+        defaultFormat: 'table',
+        colors: true,
+    },
+    trading: {
+        confirmations: true,
+        maxOrderSize: 1000,
+    },
+};

package/dist/lib/errors/base.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Exit codes for the CLI
+ */
+export declare enum ExitCode {
+    Success = 0,
+    GeneralError = 1,
+    ConfigError = 2,
+    AuthError = 3,
+    APIError = 4,
+    ValidationError = 5,
+    RateLimitError = 6
+}
+/**
+ * Error code type for structured error responses
+ */
+export type ErrorCode = 'GENERAL_ERROR' | 'CONFIG_ERROR' | 'AUTH_ERROR' | 'API_ERROR' | 'VALIDATION_ERROR' | 'RATE_LIMIT_ERROR' | 'NETWORK_ERROR' | 'NOT_FOUND' | 'TIMEOUT';
+/**
+ * Base error class for all kalshitools errors
+ */
+export declare class KalshiToolsError extends Error {
+    readonly code: ErrorCode;
+    readonly exitCode: ExitCode;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, code?: ErrorCode, exitCode?: ExitCode, details?: Record<string, unknown>);
+    /**
+     * Convert error to JSON format for structured output
+     */
+    toJSON(): {
+        success: false;
+        error: {
+            code: ErrorCode;
+            message: string;
+            details?: Record<string, unknown>;
+        };
+    };
+}
+/**
+ * Configuration-related errors
+ */
+export declare class ConfigError extends KalshiToolsError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Authentication-related errors
+ */
+export declare class AuthError extends KalshiToolsError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * API-related errors
+ */
+export declare class APIError extends KalshiToolsError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Validation errors
+ */
+export declare class ValidationError extends KalshiToolsError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Rate limit errors
+ */
+export declare class RateLimitError extends KalshiToolsError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Network-related errors
+ */
+export declare class NetworkError extends KalshiToolsError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Resource not found errors
+ */
+export declare class NotFoundError extends KalshiToolsError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Timeout errors
+ */
+export declare class TimeoutError extends KalshiToolsError {
+    constructor(message: string, details?: Record<string, unknown>);
+}

package/dist/lib/errors/base.js

@@ -0,0 +1,106 @@
+/**
+ * Exit codes for the CLI
+ */
+export var ExitCode;
+(function (ExitCode) {
+    ExitCode[ExitCode["Success"] = 0] = "Success";
+    ExitCode[ExitCode["GeneralError"] = 1] = "GeneralError";
+    ExitCode[ExitCode["ConfigError"] = 2] = "ConfigError";
+    ExitCode[ExitCode["AuthError"] = 3] = "AuthError";
+    ExitCode[ExitCode["APIError"] = 4] = "APIError";
+    ExitCode[ExitCode["ValidationError"] = 5] = "ValidationError";
+    ExitCode[ExitCode["RateLimitError"] = 6] = "RateLimitError";
+})(ExitCode || (ExitCode = {}));
+/**
+ * Base error class for all kalshitools errors
+ */
+export class KalshiToolsError extends Error {
+    code;
+    exitCode;
+    details;
+    constructor(message, code = 'GENERAL_ERROR', exitCode = ExitCode.GeneralError, details) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.exitCode = exitCode;
+        this.details = details;
+        Error.captureStackTrace(this, this.constructor);
+    }
+    /**
+     * Convert error to JSON format for structured output
+     */
+    toJSON() {
+        return {
+            success: false,
+            error: {
+                code: this.code,
+                message: this.message,
+                ...(this.details && { details: this.details }),
+            },
+        };
+    }
+}
+/**
+ * Configuration-related errors
+ */
+export class ConfigError extends KalshiToolsError {
+    constructor(message, details) {
+        super(message, 'CONFIG_ERROR', ExitCode.ConfigError, details);
+    }
+}
+/**
+ * Authentication-related errors
+ */
+export class AuthError extends KalshiToolsError {
+    constructor(message, details) {
+        super(message, 'AUTH_ERROR', ExitCode.AuthError, details);
+    }
+}
+/**
+ * API-related errors
+ */
+export class APIError extends KalshiToolsError {
+    constructor(message, details) {
+        super(message, 'API_ERROR', ExitCode.APIError, details);
+    }
+}
+/**
+ * Validation errors
+ */
+export class ValidationError extends KalshiToolsError {
+    constructor(message, details) {
+        super(message, 'VALIDATION_ERROR', ExitCode.ValidationError, details);
+    }
+}
+/**
+ * Rate limit errors
+ */
+export class RateLimitError extends KalshiToolsError {
+    constructor(message, details) {
+        super(message, 'RATE_LIMIT_ERROR', ExitCode.RateLimitError, details);
+    }
+}
+/**
+ * Network-related errors
+ */
+export class NetworkError extends KalshiToolsError {
+    constructor(message, details) {
+        super(message, 'NETWORK_ERROR', ExitCode.GeneralError, details);
+    }
+}
+/**
+ * Resource not found errors
+ */
+export class NotFoundError extends KalshiToolsError {
+    constructor(message, details) {
+        super(message, 'NOT_FOUND', ExitCode.GeneralError, details);
+    }
+}
+/**
+ * Timeout errors
+ */
+export class TimeoutError extends KalshiToolsError {
+    constructor(message, details) {
+        super(message, 'TIMEOUT', ExitCode.GeneralError, details);
+    }
+}

package/dist/lib/kalshi/auth.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Generate HTTP signature for Kalshi API authentication
+ * Uses RSA-PSS signing as required by Kalshi API
+ */
+export declare class KalshiAuth {
+    private keyId;
+    private privateKey;
+    constructor(keyId: string, privateKey: string);
+    /**
+     * Generate authentication headers for a request
+     */
+    generateAuthHeaders(method: string, path: string, timestamp?: number): Record<string, string>;
+    /**
+     * Validate private key format
+     */
+    static validatePrivateKey(privateKey: string): boolean;
+}

package/dist/lib/kalshi/auth.js

@@ -0,0 +1,71 @@
+import crypto, { createSign } from 'node:crypto';
+import { AuthError } from '../errors/base.js';
+import { logger } from '../logger.js';
+/**
+ * Generate HTTP signature for Kalshi API authentication
+ * Uses RSA-PSS signing as required by Kalshi API
+ */
+export class KalshiAuth {
+    keyId;
+    privateKey;
+    constructor(keyId, privateKey) {
+        this.keyId = keyId;
+        this.privateKey = privateKey;
+    }
+    /**
+     * Generate authentication headers for a request
+     */
+    generateAuthHeaders(method, path, timestamp) {
+        const ts = timestamp || Date.now();
+        const timestampStr = Math.floor(ts / 1000).toString();
+        // Create signature string: METHOD + timestamp + path
+        const signaturePayload = `${timestampStr}${method}${path}`;
+        logger.debug({ method, path, timestamp: timestampStr }, 'Generating signature');
+        try {
+            // Sign using RSA-PSS
+            const sign = createSign('RSA-SHA256');
+            sign.update(signaturePayload);
+            sign.end();
+            const signature = sign.sign({
+                key: this.privateKey,
+                padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
+                saltLength: crypto.constants.RSA_PSS_SALTLEN_DIGEST,
+            }, 'base64');
+            return {
+                'KALSHI-ACCESS-KEY': this.keyId,
+                'KALSHI-ACCESS-SIGNATURE': signature,
+                'KALSHI-ACCESS-TIMESTAMP': timestampStr,
+            };
+        }
+        catch (error) {
+            logger.error({ error }, 'Failed to generate signature');
+            throw new AuthError('Failed to generate authentication signature', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Validate private key format
+     */
+    static validatePrivateKey(privateKey) {
+        try {
+            // Check if it's PEM format
+            if (!privateKey.includes('-----BEGIN') || !privateKey.includes('-----END')) {
+                return false;
+            }
+            // Try to create a sign instance to validate the key
+            const sign = createSign('RSA-SHA256');
+            sign.update('test');
+            sign.end();
+            sign.sign({
+                key: privateKey,
+                padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
+                saltLength: crypto.constants.RSA_PSS_SALTLEN_DIGEST,
+            }, 'base64');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}