@whatcanirun/cli 0.1.0

package/src/runtime/types.ts

@@ -0,0 +1,40 @@
+// -----------------------------------------------------------------------------
+// Types
+// -----------------------------------------------------------------------------
+
+export interface RuntimeInfo {
+  name: string;
+  version: string;
+  build_flags?: string;
+}
+
+export interface BenchTrial {
+  promptTps: number;
+  generationTps: number;
+  peakMemoryGb: number;
+}
+
+export interface BenchResult {
+  promptTokens: number;
+  completionTokens: number;
+  trials: BenchTrial[];
+  averages: {
+    promptTps: number;
+    generationTps: number;
+    peakMemoryGb: number;
+  };
+}
+
+export interface BenchOpts {
+  model: string;
+  promptTokens: number;
+  genTokens: number;
+  numTrials: number;
+  onProgress?: (msg: string) => void;
+}
+
+export interface RuntimeAdapter {
+  name: string;
+  detect(): Promise<RuntimeInfo | null>;
+  benchmark(opts: BenchOpts): Promise<BenchResult>;
+}

package/src/upload/client.ts

@@ -0,0 +1,56 @@
+import { readFileSync } from 'node:fs';
+
+import { getToken } from '../auth/token';
+
+// -----------------------------------------------------------------------------
+// Types
+// -----------------------------------------------------------------------------
+
+export interface UploadResult {
+  run_id: string;
+  status: string;
+  run_url: string;
+}
+
+// -----------------------------------------------------------------------------
+// Constants
+// -----------------------------------------------------------------------------
+
+const API_BASE = process.env.WCIR_API_URL || 'https://whatcani.run';
+
+// -----------------------------------------------------------------------------
+// Functions
+// -----------------------------------------------------------------------------
+
+export async function uploadBundle(bundlePath: string): Promise<UploadResult> {
+  // 1. Read the bundle zip and compute its SHA-256
+  const zipBytes = readFileSync(bundlePath);
+  const hashBuffer = await crypto.subtle.digest('SHA-256', zipBytes);
+  const bundleSha256 = Array.from(new Uint8Array(hashBuffer))
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('');
+  const blob = new Blob([zipBytes], { type: 'application/zip' });
+
+  // 2. Build multipart form
+  const form = new FormData();
+  form.append('bundle', blob, bundlePath.split('/').pop() || 'bundle.zip');
+  form.append('bundle_sha256', bundleSha256);
+
+  const token = getToken();
+  if (token) {
+    form.append('token', token);
+  }
+
+  // 3. Submit
+  const res = await fetch(`${API_BASE}/api/v0/runs`, {
+    method: 'POST',
+    body: form,
+  });
+
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Upload failed (${res.status}): ${body}`);
+  }
+
+  return (await res.json()) as UploadResult;
+}

package/src/utils/id.ts

@@ -0,0 +1,77 @@
+import { randomBytes } from 'crypto';
+import { existsSync, readdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+// -----------------------------------------------------------------------------
+// Constants
+// -----------------------------------------------------------------------------
+
+export const DEFAULT_BUNDLES_DIR = join(homedir(), '.whatcanirun', 'bundles');
+
+const RUNTIME_SLUGS: Record<string, string> = {
+  mlx_lm: 'mlx',
+  'llama.cpp': 'llamacpp',
+};
+
+// -----------------------------------------------------------------------------
+// Slugification
+// -----------------------------------------------------------------------------
+
+export function slugifyRuntime(name: string): string {
+  return RUNTIME_SLUGS[name] ?? name.replace(/[^a-z0-9]/gi, '').toLowerCase();
+}
+
+export function slugifyModel(displayName: string): string {
+  return displayName
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 40)
+    .replace(/-$/, '');
+}
+
+// -----------------------------------------------------------------------------
+// Bundle ID & Filename
+// -----------------------------------------------------------------------------
+
+export function generateBundleId(opts: { runtime: string; model: string }): string {
+  const rt = slugifyRuntime(opts.runtime);
+  const model = slugifyModel(opts.model);
+  const hex = randomBytes(3).toString('hex');
+  return `${rt}-${model}-${hex}`;
+}
+
+export function bundleFilename(bundleId: string): string {
+  return `${bundleId}.zip`;
+}
+
+// -----------------------------------------------------------------------------
+// Bundle Path Resolution
+// -----------------------------------------------------------------------------
+
+export function resolveBundlePath(bundleArg: string): string {
+  // Direct path
+  if (existsSync(bundleArg)) return bundleArg;
+
+  // Exact ID match
+  const exact = join(DEFAULT_BUNDLES_DIR, `${bundleArg}.zip`);
+  if (existsSync(exact)) return exact;
+
+  // Substring match in bundles dir
+  if (existsSync(DEFAULT_BUNDLES_DIR)) {
+    const files = readdirSync(DEFAULT_BUNDLES_DIR).filter((f) => f.endsWith('.zip'));
+    const matches = files.filter((f) => f.replace(/\.zip$/, '').includes(bundleArg));
+
+    if (matches.length === 1) {
+      return join(DEFAULT_BUNDLES_DIR, matches[0]!);
+    }
+    if (matches.length > 1) {
+      const names = matches.map((m) => m.replace(/\.zip$/, '')).join(', ');
+      throw new Error(`Multiple bundles match "${bundleArg}": ${names}`);
+    }
+  }
+
+  throw new Error(`Bundle not found: ${bundleArg}`);
+}

package/src/utils/log.ts

@@ -0,0 +1,125 @@
+// -----------------------------------------------------------------------------
+// Constants
+// -----------------------------------------------------------------------------
+
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const CYAN = '\x1b[36m';
+
+// -----------------------------------------------------------------------------
+// Functions
+// -----------------------------------------------------------------------------
+
+export function info(msg: string) {
+  console.log(`${DIM}${msg}${RESET}`);
+}
+
+export function success(msg: string) {
+  console.log(`${GREEN}${msg}${RESET}`);
+}
+
+export function warn(msg: string) {
+  console.error(`${YELLOW}warning:${RESET} ${msg}`);
+}
+
+export function error(msg: string) {
+  console.error(`${RED}error:${RESET} ${msg}`);
+}
+
+export function header(msg: string) {
+  console.log(`${BOLD}${msg}${RESET}`);
+}
+
+export function label(key: string, value: string) {
+  console.log(`${CYAN}${key}:${RESET} ${value}`);
+}
+
+export function bundleSaved(path: string) {
+  console.log(`${DIM}Bundle saved to${RESET} ${CYAN}${path}${RESET}`);
+}
+
+export function blank() {
+  console.log();
+}
+
+// -----------------------------------------------------------------------------
+// Spinner
+// -----------------------------------------------------------------------------
+
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+export class Spinner {
+  private frame = 0;
+  private interval: ReturnType<typeof setInterval> | null = null;
+  private text: string;
+  private total = 0;
+  private current = 0;
+  private detail = '';
+
+  constructor(text: string) {
+    this.text = text;
+  }
+
+  start(): this {
+    this.render();
+    this.interval = setInterval(() => this.render(), 80);
+    return this;
+  }
+
+  update(text: string) {
+    this.text = text;
+  }
+
+  setTotal(total: number) {
+    this.total = total;
+    this.current = 0;
+  }
+
+  tick(detail?: string) {
+    this.current = Math.min(this.current + 1, this.total);
+    if (detail) this.detail = detail;
+  }
+
+  stop(finalText?: string) {
+    if (this.interval) clearInterval(this.interval);
+    process.stderr.write('\r\x1b[K');
+    if (finalText) {
+      console.log(`${DIM}${finalText}${RESET}`);
+    }
+  }
+
+  private render() {
+    const f = SPINNER_FRAMES[this.frame % SPINNER_FRAMES.length];
+
+    if (this.total <= 0) {
+      process.stderr.write(`\r\x1b[K${DIM}${f} ${this.text}${RESET}`);
+      this.frame++;
+      return;
+    }
+
+    const pulse = Math.sin(this.frame * 0.15) * 0.5 + 0.5; // 0..1
+    const bright = Math.round(138 + pulse * 117); // 138..255
+    const pulseColor = `\x1b[38;2;${bright};${bright};${bright}m`;
+
+    const WHITE = '\x1b[97m';
+
+    // Progress bar: filled is white, empty is dim.
+    const width = 20;
+    const filled = Math.round((this.current / this.total) * width);
+    const empty = width - filled;
+    const bar = ` ${WHITE}${'█'.repeat(filled)}${RESET}${DIM}${'░'.repeat(empty)}${RESET}`;
+
+    // Counter: N is white, /total is dim.
+    const counter = ` ${WHITE}${this.current}${RESET}${DIM}/${this.total}${RESET}`;
+
+    // Detail pulses.
+    const detail = this.detail ? `  ${pulseColor}${this.detail}${RESET}` : '';
+
+    process.stderr.write(`\r\x1b[K${DIM}${f} ${this.text}${RESET}${bar}${counter}${detail}`);
+    this.frame++;
+  }
+}