kob-cli 1.0.0

package/src/utils/api.ts

@@ -0,0 +1,208 @@
+import type { CliConfig } from '../types/index.js';
+import { ApiError } from './errors.js';
+
+export interface ChatCompletionChunk {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    provider?: string;
+    choices: {
+        index: number;
+        delta: { content?: string; role?: string };
+        finish_reason: string | null;
+    }[];
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+
+export interface ChatCompletionResult {
+    content: string;
+    model: string;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        total_tokens: number;
+    };
+}
+
+export class KobApiClient {
+    private baseUrl: string;
+    private apiKey: string;
+    private apiToken?: string;
+    private bearerToken?: string;
+
+    constructor(config: CliConfig) {
+        this.baseUrl = config.baseUrl;
+        this.apiKey = config.apiKey;
+        this.apiToken = config.apiToken;
+        this.bearerToken = config.bearerToken;
+    }
+
+    private getHeaders(): Record<string, string> {
+        return {
+            'Content-Type': 'application/json',
+        };
+    }
+
+    private getAuthBody(): Record<string, string> {
+        const auth: Record<string, string> = {
+            api_key: this.apiKey,
+        };
+        if (this.apiToken) {
+            auth.api_token = this.apiToken;
+        }
+        return auth;
+    }
+
+    private getBearerHeaders(): Record<string, string> {
+        return {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${this.bearerToken || this.apiKey}`,
+        };
+    }
+
+    // V2 streaming chat completions (OpenAI-compatible)
+    async *chatStream(model: string, messages: { role: string; content: string }[], options?: {
+        temperature?: number;
+        max_tokens?: number;
+        system_prompt?: string;
+    }): AsyncGenerator<ChatCompletionChunk> {
+        const url = `${this.baseUrl}/api/v2/chat/completions`;
+
+        const body: any = {
+            model,
+            messages: [...messages],
+            stream: true,
+        };
+        if (options?.temperature !== undefined) body.temperature = options.temperature;
+        if (options?.max_tokens !== undefined) body.max_tokens = options.max_tokens;
+        if (options?.system_prompt) {
+            body.messages.unshift({ role: 'system', content: options.system_prompt });
+        }
+
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: this.getBearerHeaders(),
+            body: JSON.stringify(body),
+        });
+
+        if (!response.ok) {
+            const text = await response.text();
+            let msg = 'Request failed';
+            try { const d = JSON.parse(text); msg = d.error?.message || d.message || msg; } catch {}
+            throw new ApiError(msg, response.status);
+        }
+
+        if (!response.body) {
+            throw new ApiError('No response body', 500);
+        }
+
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+
+                for (const line of lines) {
+                    if (!line.startsWith('data: ')) continue;
+                    const jsonStr = line.slice(6).trim();
+                    if (jsonStr === '[DONE]') return;
+                    try {
+                        const chunk: ChatCompletionChunk = JSON.parse(jsonStr);
+                        yield chunk;
+                    } catch {}
+                }
+            }
+        } finally {
+            reader.releaseLock();
+        }
+    }
+
+    // V2 chat completions (accumulates stream, returns final result)
+    async chatComplete(model: string, messages: { role: string; content: string }[], options?: {
+        temperature?: number;
+        max_tokens?: number;
+        system_prompt?: string;
+    }): Promise<ChatCompletionResult> {
+        let content = '';
+        let finalModel = model;
+        let usage = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
+
+        for await (const chunk of this.chatStream(model, messages, options)) {
+            const delta = chunk.choices?.[0]?.delta?.content;
+            if (delta) content += delta;
+            if (chunk.model) finalModel = chunk.model;
+            if (chunk.usage) {
+                usage = {
+                    input_tokens: chunk.usage.prompt_tokens || 0,
+                    output_tokens: chunk.usage.completion_tokens || 0,
+                    total_tokens: chunk.usage.total_tokens || 0,
+                };
+            }
+        }
+
+        return { content, model: finalModel, usage };
+    }
+
+    // Old methods (for auth:verify, models, etc.)
+    async post<T>(endpoint: string, body: Record<string, any> = {}): Promise<T> {
+        const url = `${this.baseUrl}${endpoint}`;
+        const requestBody = { ...this.getAuthBody(), ...body };
+
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify(requestBody),
+        });
+
+        const text = await response.text();
+        let data: any;
+        try { data = JSON.parse(text); } catch {
+            throw new ApiError(
+                `Server returned non-JSON response (${response.status}). Expected API endpoint, got HTML. Check KOB_API_BASE_URL and endpoint path.`,
+                response.status
+            );
+        }
+
+        if (!response.ok) {
+            throw new ApiError(data.message || 'Request failed', response.status);
+        }
+        if (!data.success) {
+            throw new ApiError(data.message || 'Request failed', response.status);
+        }
+        return data as T;
+    }
+
+    async get<T>(endpoint: string, params: Record<string, string> = {}): Promise<T> {
+        const queryParams = new URLSearchParams({ api_key: this.apiKey, ...params });
+        if (this.apiToken) queryParams.set('api_token', this.apiToken);
+
+        const response = await fetch(`${this.baseUrl}${endpoint}?${queryParams.toString()}`, {
+            method: 'GET', headers: this.getHeaders(),
+        });
+
+        const text = await response.text();
+        let data: any;
+        try { data = JSON.parse(text); } catch {
+            throw new ApiError(
+                `Server returned non-JSON response (${response.status}). Expected API endpoint, got HTML. Check KOB_API_BASE_URL and endpoint path.`,
+                response.status
+            );
+        }
+
+        if (!response.ok) throw new ApiError(data.message || 'Request failed', response.status);
+        if (!data.success) throw new ApiError(data.message || 'Request failed', response.status);
+        return data as T;
+    }
+}

package/src/utils/config.ts

@@ -0,0 +1,45 @@
+import type { CliConfig } from '../types/index.js';
+
+export function getConfig(): CliConfig {
+    let baseUrl = process.env.KOB_API_BASE_URL || 'https://www.kob-ai.dev';
+
+    // Normalize base URL: strip /v1 /v2 etc. if present (Next.js subpath)
+    // API endpoints use /api/ prefix directly, not under /v1/
+    baseUrl = baseUrl.replace(/\/v\d+\/?$/, '').replace(/\/+$/, '');
+
+    const rawKey = process.env.KOB_API_KEY || '';
+    const modelId = process.env.KOB_MODEL_ID;
+
+    if (!rawKey) {
+        console.error('❌ Error: KOB_API_KEY environment variable is required');
+        console.error('Please set it in your .env file or export it in your shell');
+        console.error('Example:');
+        console.error('  export KOB_API_KEY=kob_your_key');
+        process.exit(1);
+    }
+
+    // Support combined format: "kob_xxx:token" or just "kob_xxx"
+    const colonIndex = rawKey.indexOf(':');
+    const apiKey = colonIndex !== -1 ? rawKey.substring(0, colonIndex) : rawKey;
+    const apiToken = colonIndex !== -1 ? rawKey.substring(colonIndex + 1) : undefined;
+
+    return {
+        baseUrl,
+        apiKey,
+        apiToken,
+        bearerToken: rawKey,
+        modelId: modelId || undefined,
+    };
+}
+
+export function validateConfig(config: CliConfig): void {
+    if (!config.baseUrl) {
+        console.error('❌ Error: KOB_API_BASE_URL is not set');
+        process.exit(1);
+    }
+
+    if (!config.apiKey) {
+        console.error('❌ Error: KOB_API_KEY is not set');
+        process.exit(1);
+    }
+}

package/src/utils/errors.ts

@@ -0,0 +1,43 @@
+import chalk from 'chalk';
+
+export class ApiError extends Error {
+    public statusCode?: number;
+    public success: boolean = false;
+
+    constructor(message: string, statusCode?: number) {
+        super(message);
+        this.name = 'ApiError';
+        this.statusCode = statusCode;
+    }
+}
+
+export function handleApiError(error: unknown): never {
+    if (error instanceof ApiError) {
+        console.error(chalk.red(`\n❌ API Error: ${error.message}`));
+
+        if (error.statusCode === 401) {
+            console.error(chalk.yellow('\nAuthentication failed. Please check your API credentials.'));
+            console.error(chalk.yellow('Make sure KOB_API_KEY is correct (format: kob_xxx:your_token).'));
+        } else if (error.statusCode === 402) {
+            console.error(chalk.yellow('\nInsufficient credits. Please top up your account.'));
+        } else if (error.statusCode === 404) {
+            console.error(chalk.yellow('\nResource not found.'));
+        } else if (error.statusCode && error.statusCode >= 500) {
+            console.error(chalk.yellow('\nServer error. Please try again later.'));
+        }
+    } else if (error instanceof Error) {
+        console.error(chalk.red(`\n❌ Error: ${error.message}`));
+    } else {
+        console.error(chalk.red('\n❌ An unexpected error occurred'));
+    }
+
+    process.exit(1);
+}
+
+export function validateRequired(value: string | undefined, fieldName: string): string {
+    if (!value || value.trim() === '') {
+        console.error(chalk.red(`\n❌ Error: ${fieldName} is required`));
+        process.exit(1);
+    }
+    return value;
+}

package/src/utils/format.ts

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+
+// Format date to readable string
+export function formatDate(dateString: string): string {
+    const date = new Date(dateString);
+    return date.toLocaleString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+    });
+}
+
+// Format usage statistics
+export function formatUsage(usage: any, creditBalance: number): string {
+    const lines: string[] = [];
+    lines.push(chalk.dim('─'.repeat(80)));
+    lines.push(chalk.bold.cyan('📊 Usage Statistics:'));
+    lines.push(`   Input Tokens: ${chalk.yellow(usage.input_tokens?.toString() || '0')}`);
+    lines.push(`   Output Tokens: ${chalk.yellow(usage.output_tokens?.toString() || '0')}`);
+    lines.push(`   Total Tokens: ${chalk.yellow(usage.total_tokens?.toString() || '0')}`);
+    lines.push(`   Cost: $${chalk.yellow((usage.cost_usd || 0).toFixed(6))}`);
+    lines.push(`   Credits Used: ${chalk.red(usage.credits_used?.toString() || '0')}`);
+    lines.push(`   Credits Remaining: ${chalk.green(creditBalance.toString())}`);
+    return lines.join('\n');
+}