@gridlock-compute/native-worker 0.1.1

package/dist/dashboard.js

@@ -0,0 +1,247 @@
+const LIME = "\x1b[38;2;182;255;60m";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+/** Fixed height — keep in sync with buildLines(). */
+const FIXED_LINES = 15;
+function shouldColorize() {
+    if (process.env.GRIDLOCK_PLAIN_LOGS === "true")
+        return false;
+    const { FORCE_COLOR, NO_COLOR } = process.env;
+    if (FORCE_COLOR !== undefined) {
+        return FORCE_COLOR !== "0" && FORCE_COLOR.toLowerCase() !== "false";
+    }
+    if (NO_COLOR !== undefined)
+        return false;
+    return process.stdout.isTTY === true;
+}
+/** Interactive TTY dashboard — suppresses startup log lines. */
+export function isDashboardMode() {
+    return shouldColorize() && process.stdout.isTTY === true;
+}
+function c(text, color) {
+    if (!shouldColorize())
+        return text;
+    return `${color}${text}${RESET}`;
+}
+function formatDuration(ms) {
+    const totalSec = Math.floor(ms / 1000);
+    const h = Math.floor(totalSec / 3600);
+    const m = Math.floor((totalSec % 3600) / 60);
+    const s = totalSec % 60;
+    if (h > 0)
+        return `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+    return `${m}:${String(s).padStart(2, "0")}`;
+}
+function activityBar(now, width = 18) {
+    const pulseWidth = 5;
+    const travel = width - pulseWidth;
+    const offset = Math.floor(now / 120) % (travel + 1);
+    const chars = Array.from({ length: width }, (_, i) => i >= offset && i < offset + pulseWidth ? "█" : "░");
+    return c(`[${chars.join("")}]`, LIME);
+}
+function connectionLabel(status) {
+    switch (status) {
+        case "connected":
+            return c("● Connected", GREEN);
+        case "disconnected":
+            return c("○ Disconnected", RED);
+        case "reconnecting":
+            return c("↻ Reconnecting", YELLOW);
+        default:
+            return c("… Starting", YELLOW);
+    }
+}
+function row(label, value, width = 76) {
+    const left = `  ${c(label, DIM)}`;
+    const gap = Math.max(1, 22 - label.length);
+    const content = left + " ".repeat(gap) + value;
+    return content.length > width ? content.slice(0, width) : content;
+}
+function topBorder(width = 76) {
+    const title = " Gridlock Worker Dashboard ";
+    const dashes = Math.max(1, width - title.length - 2);
+    return c(`┌${title}${"─".repeat(dashes)}┐`, LIME);
+}
+function bottomBorder(width = 76) {
+    return c(`└${"─".repeat(width - 2)}┘`, LIME);
+}
+export function createDashboard(initial, options = {}) {
+    const state = { ...initial };
+    const anchorRow = Math.max(1, options.anchorRow ?? 1);
+    const startedAt = Date.now();
+    let timer = null;
+    let jobTimer = null;
+    let lastNote = c("—", DIM);
+    let started = false;
+    let renderPending = false;
+    const enabled = shouldColorize() && process.stdout.isTTY;
+    function buildLines() {
+        const uptime = formatDuration(Date.now() - startedAt);
+        const jobs = `${state.jobsCompleted} session · ${state.jobsToday} today · ${state.jobsFailed} failed`;
+        const bench = `${state.benchmarkTokPerSec} tok/s`;
+        const live = state.liveTokPerSec !== null ? `${state.liveTokPerSec} tok/s` : c("—", DIM);
+        const queue = state.queueJobs !== null
+            ? `${state.queueJobs} queued · ${state.inflightJobs ?? 0} net · ${state.workerInflightJobs ?? 0} worker`
+            : c("—", DIM);
+        const tokens = state.tokensTodayBase + (state.currentJob?.tokens ?? 0);
+        const lines = [
+            topBorder(),
+            row("Wallet", state.wallet),
+            row("API", state.api),
+            row("Hardware", state.hardware),
+            row("Model", `${state.model} (${state.inference})`),
+            row("Status", `${connectionLabel(state.connection)} · ${state.workerStatus}`),
+            row("Uptime", uptime),
+            row("Jobs", jobs),
+            row("Tokens", String(tokens)),
+            row("Throughput", `bench ${bench} · live ${live}`),
+            row("Router queue", queue),
+        ];
+        if (state.currentJob) {
+            const job = state.currentJob;
+            const elapsed = formatDuration(Date.now() - job.startedAt);
+            const liveRate = state.liveTokPerSec !== null ? `${state.liveTokPerSec} tok/s` : "warming up";
+            lines.push(row("Current job", `${job.id.slice(0, 12)}… · ${elapsed}`));
+            lines.push(row("Generation", `${activityBar(Date.now())} ${job.tokens} tok · ${liveRate}`));
+        }
+        else {
+            lines.push(row("Current job", c("idle — waiting for work", DIM)));
+            lines.push(row("Generation", c("idle", DIM)));
+        }
+        lines.push(row("Last event", lastNote));
+        lines.push(bottomBorder());
+        return lines;
+    }
+    function render() {
+        if (!enabled || !started)
+            return;
+        const lines = buildLines();
+        while (lines.length < FIXED_LINES)
+            lines.push("");
+        if (lines.length > FIXED_LINES)
+            lines.length = FIXED_LINES;
+        for (let i = 0; i < FIXED_LINES; i += 1) {
+            const rowNum = anchorRow + i;
+            process.stdout.write(`\x1b[${rowNum};1H\x1b[2K${lines[i] ?? ""}`);
+        }
+        process.stdout.write(`\x1b[${anchorRow + FIXED_LINES};1H`);
+    }
+    function scheduleRender() {
+        if (!started)
+            return;
+        if (renderPending)
+            return;
+        renderPending = true;
+        setImmediate(() => {
+            renderPending = false;
+            render();
+        });
+    }
+    function startJobTicker() {
+        stopJobTicker();
+        jobTimer = setInterval(() => {
+            if (!state.currentJob)
+                return;
+            scheduleRender();
+        }, 100);
+    }
+    function stopJobTicker() {
+        if (!jobTimer)
+            return;
+        clearInterval(jobTimer);
+        jobTimer = null;
+    }
+    return {
+        update(patch) {
+            Object.assign(state, patch);
+            scheduleRender();
+        },
+        applyLiveStats(stats) {
+            state.jobsToday = Math.max(state.jobsToday, stats.jobsToday);
+            state.workerStatus = stats.workerStatus;
+            state.queueJobs = stats.queueJobs;
+            state.inflightJobs = stats.inflightJobs;
+            state.workerInflightJobs = stats.workerInflightJobs;
+            state.jobsFailed = Math.max(state.jobsFailed, stats.jobsFailedToday);
+            state.tokensTodayBase = Math.max(state.tokensTodayBase, stats.tokensToday);
+            if (!state.currentJob) {
+                state.liveTokPerSec = stats.wsTokPerSec > 0 ? stats.wsTokPerSec : null;
+            }
+            scheduleRender();
+        },
+        setJob(jobId, maxTokens) {
+            state.currentJob = {
+                id: jobId,
+                tokens: 0,
+                maxTokens: Math.max(1, maxTokens),
+                startedAt: Date.now(),
+            };
+            state.liveTokPerSec = 0;
+            startJobTicker();
+            scheduleRender();
+        },
+        setJobProgress(tokens, maxTokens) {
+            if (!state.currentJob)
+                return;
+            state.currentJob.tokens = Math.max(0, tokens);
+            if (maxTokens !== undefined)
+                state.currentJob.maxTokens = Math.max(1, maxTokens);
+            const elapsedSec = Math.max((Date.now() - state.currentJob.startedAt) / 1000, 0.001);
+            state.liveTokPerSec = Math.round((state.currentJob.tokens / elapsedSec) * 10) / 10;
+            scheduleRender();
+        },
+        clearJob(jobId, success, tokens, elapsedMs) {
+            if (success) {
+                state.jobsCompleted += 1;
+                state.tokensTodayBase += tokens;
+            }
+            else {
+                state.jobsFailed += 1;
+            }
+            if (state.currentJob?.id !== jobId) {
+                scheduleRender();
+                return;
+            }
+            if (elapsedMs > 0 && tokens > 0) {
+                state.liveTokPerSec = Math.round((tokens / (elapsedMs / 1000)) * 10) / 10;
+            }
+            state.currentJob = null;
+            stopJobTicker();
+            scheduleRender();
+        },
+        setConnection(status) {
+            state.connection = status;
+            scheduleRender();
+        },
+        note(message) {
+            lastNote = message.length > 52 ? `${message.slice(0, 49)}…` : message;
+            scheduleRender();
+        },
+        start() {
+            if (!enabled)
+                return;
+            process.stdout.write("\x1b[?25l");
+            started = true;
+            scheduleRender();
+            timer = setInterval(scheduleRender, 200);
+        },
+        stop() {
+            if (timer)
+                clearInterval(timer);
+            timer = null;
+            stopJobTicker();
+            if (!enabled || !started)
+                return;
+            started = false;
+            process.stdout.write("\x1b[?25h");
+        },
+    };
+}
+export function plainLog(msg) {
+    if (process.env.GRIDLOCK_PLAIN_LOGS === "true" || !process.stdout.isTTY) {
+        console.log(`[${new Date().toISOString()}] ${msg}`);
+    }
+}

package/dist/gpu.d.ts

@@ -0,0 +1,4 @@
+/** Detect compute hardware for router registration and startup logs. */
+export declare function detectHardwareTier(): Promise<string>;
+/** @deprecated Use detectHardwareTier() */
+export declare function detectGpuName(): Promise<string>;

package/dist/gpu.js

@@ -0,0 +1,168 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { cpus } from "node:os";
+const execFileAsync = promisify(execFile);
+async function runCmd(command, args) {
+    try {
+        const { stdout } = await execFileAsync(command, args, {
+            timeout: 8_000,
+            maxBuffer: 1024 * 1024,
+            windowsHide: true,
+        });
+        const text = stdout.trim();
+        return text || null;
+    }
+    catch {
+        return null;
+    }
+}
+function nvidiaSmiBin() {
+    const override = process.env.GRIDLOCK_NVIDIA_SMI?.trim();
+    if (override)
+        return override;
+    if (process.platform === "win32") {
+        for (const path of [
+            join(process.env.ProgramFiles ?? "", "NVIDIA Corporation", "NVSMI", "nvidia-smi.exe"),
+            join(process.env.SystemRoot ?? "C:\\Windows", "System32", "nvidia-smi.exe"),
+        ]) {
+            if (path && existsSync(path))
+                return path;
+        }
+    }
+    return "nvidia-smi";
+}
+async function rocmSmiBin() {
+    const override = process.env.GRIDLOCK_ROCM_SMI?.trim();
+    if (override && existsSync(override))
+        return override;
+    for (const candidate of ["rocm-smi", "amd-smi"]) {
+        try {
+            const cmd = process.platform === "win32" ? "where" : "which";
+            const { stdout } = await execFileAsync(cmd, [candidate], { encoding: "utf8", windowsHide: true });
+            const path = stdout.trim().split(/\r?\n/)[0]?.trim();
+            if (path)
+                return path;
+        }
+        catch {
+            /* try next */
+        }
+    }
+    return null;
+}
+async function detectCpuName() {
+    if (process.platform === "linux") {
+        try {
+            const cpuinfo = await readFile("/proc/cpuinfo", "utf8");
+            for (const line of cpuinfo.split("\n")) {
+                if (line.toLowerCase().includes("model name")) {
+                    const name = line.split(":")[1]?.trim();
+                    if (name)
+                        return name;
+                }
+            }
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    if (process.platform === "darwin") {
+        const out = await runCmd("sysctl", ["-n", "machdep.cpu.brand_string"]);
+        if (out)
+            return out;
+    }
+    if (process.platform === "win32") {
+        const out = await runCmd("wmic", ["cpu", "get", "Name", "/format:list"]);
+        if (out) {
+            for (const line of out.split("\n")) {
+                if (line.toLowerCase().startsWith("name=")) {
+                    const name = line.split("=")[1]?.trim();
+                    if (name)
+                        return name;
+                }
+            }
+        }
+    }
+    const model = cpus()[0]?.model?.trim();
+    return model || `${process.platform} CPU`;
+}
+async function detectNvidiaGpus() {
+    const out = await runCmd(nvidiaSmiBin(), [
+        "--query-gpu=index,name",
+        "--format=csv,noheader",
+    ]);
+    if (!out)
+        return [];
+    const gpus = [];
+    for (const line of out.split("\n")) {
+        const parts = line.split(",").map((p) => p.trim());
+        if (parts.length < 2)
+            continue;
+        const index = Number.parseInt(parts[0] ?? "", 10);
+        const name = parts[1] ?? "";
+        if (!name)
+            continue;
+        gpus.push({
+            vendor: "nvidia",
+            name,
+            index: Number.isFinite(index) ? index : gpus.length,
+        });
+    }
+    return gpus;
+}
+async function detectAmdGpus() {
+    const bin = await rocmSmiBin();
+    if (!bin)
+        return [];
+    const out = await runCmd(bin, ["--showproductname"]);
+    if (!out)
+        return [];
+    const gpus = [];
+    for (const line of out.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("=") || !/gpu/i.test(trimmed))
+            continue;
+        const name = trimmed.includes(":") ? trimmed.split(":").slice(1).join(":").trim() : trimmed;
+        if (!name)
+            continue;
+        gpus.push({ vendor: "amd", name, index: gpus.length });
+    }
+    return gpus;
+}
+async function detectAllGpus() {
+    const nvidia = await detectNvidiaGpus();
+    if (nvidia.length > 0)
+        return nvidia;
+    return detectAmdGpus();
+}
+function selectGpu(gpus, gpuIndex) {
+    if (gpus.length === 0)
+        return null;
+    return gpus.find((g) => g.index === gpuIndex) ?? gpus[0] ?? null;
+}
+function formatGpuLabel(gpu) {
+    const prefix = gpu.vendor === "amd" ? "AMD" : gpu.vendor === "nvidia" ? "NVIDIA" : "";
+    if (prefix && !gpu.name.toLowerCase().includes(prefix.toLowerCase())) {
+        return `${prefix} ${gpu.name}`;
+    }
+    return gpu.name;
+}
+/** Detect compute hardware for router registration and startup logs. */
+export async function detectHardwareTier() {
+    const override = process.env.GRIDLOCK_HW_TIER?.trim();
+    if (override)
+        return override;
+    const gpuIndex = Number.parseInt(process.env.GRIDLOCK_GPU_INDEX ?? "0", 10);
+    const gpus = await detectAllGpus();
+    const gpu = selectGpu(gpus, Number.isFinite(gpuIndex) ? gpuIndex : 0);
+    if (gpu)
+        return formatGpuLabel(gpu);
+    const cpuName = await detectCpuName();
+    return `CPU · ${cpuName}`;
+}
+/** @deprecated Use detectHardwareTier() */
+export async function detectGpuName() {
+    return detectHardwareTier();
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+import { getBackendUrl } from "./config.js";
+import { parseWorkerWallet } from "./wallet.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+const program = new Command();
+program
+    .name("gridlock-native-worker")
+    .description("Native headless worker for the Gridlock inference network")
+    .version(pkg.version)
+    .option("--wallet <address>", "EVM wallet address (worker identity)")
+    .option("--inference <backend>", "Inference backend: auto, ollama, or vllm", "auto")
+    .option("--model <tag>", "Ollama model tag (e.g. llama3.2:3b); prompts if multiple are installed")
+    .option("--benchmark", "Run benchmark only, then exit")
+    .action(async (opts) => {
+    const walletRaw = opts.wallet ?? process.env.GRIDLOCK_WALLET;
+    if (!walletRaw) {
+        console.error("Error: --wallet is required (or set GRIDLOCK_WALLET to your 0x EVM address).");
+        process.exit(1);
+    }
+    let wallet;
+    try {
+        wallet = parseWorkerWallet(walletRaw);
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+    const inference = opts.inference;
+    if (!["auto", "ollama", "vllm"].includes(inference)) {
+        console.error('Error: --inference must be "auto", "ollama", or "vllm".');
+        process.exit(1);
+    }
+    try {
+        const { startWorker } = await import("./worker.js");
+        await startWorker({
+            wallet,
+            backendUrl: getBackendUrl(),
+            inference,
+            model: opts.model,
+            benchmarkOnly: opts.benchmark ?? false,
+        });
+    }
+    catch (err) {
+        console.error(`Fatal: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/inference-ollama-worker.d.ts

@@ -0,0 +1,9 @@
+export interface OllamaWorkerRequest {
+    url: string;
+    model: string;
+    messages: {
+        role: string;
+        content: string;
+    }[];
+    maxTokens: number;
+}

package/dist/inference-ollama-worker.js

@@ -0,0 +1,94 @@
+import { parentPort } from "node:worker_threads";
+parentPort?.on("message", async (req) => {
+    try {
+        const start = performance.now();
+        let firstAt = null;
+        let content = "";
+        let tokens = 0;
+        const res = await fetch(`${req.url.replace(/\/$/, "")}/api/chat`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Connection: "close" },
+            body: JSON.stringify({
+                model: req.model,
+                messages: req.messages,
+                stream: true,
+                options: { num_predict: req.maxTokens },
+            }),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            parentPort?.postMessage({
+                type: "error",
+                error: `Ollama error ${res.status}: ${text.slice(0, 200)}`,
+            });
+            return;
+        }
+        if (!res.body) {
+            parentPort?.postMessage({ type: "error", error: "Ollama returned empty body" });
+            return;
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        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) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const chunk = JSON.parse(trimmed);
+                    const piece = chunk.message?.content ?? "";
+                    if (piece) {
+                        if (firstAt === null)
+                            firstAt = performance.now();
+                        content += piece;
+                    }
+                    const evalCount = Number(chunk.eval_count ?? 0);
+                    if (evalCount > 0) {
+                        tokens = evalCount;
+                    }
+                    else if (piece) {
+                        tokens = Math.max(tokens, Math.ceil(content.length / 4));
+                    }
+                    if (piece || evalCount > 0 || chunk.done) {
+                        parentPort?.postMessage({
+                            type: "progress",
+                            tokens: Math.max(tokens, piece ? 1 : 0),
+                            maxTokens: req.maxTokens,
+                        });
+                    }
+                }
+                catch {
+                    /* skip malformed chunk */
+                }
+            }
+        }
+        const end = performance.now();
+        const ttftMs = Math.floor((firstAt ?? end) - start);
+        const outputTokens = Math.max(tokens, 1);
+        const tpotMs = outputTokens > 1 && firstAt
+            ? Math.floor((end - firstAt) / (outputTokens - 1))
+            : 0;
+        parentPort?.postMessage({
+            type: "done",
+            result: {
+                content: content.trim() || "(empty)",
+                tokens: outputTokens,
+                ttftMs,
+                tpotMs,
+            },
+        });
+    }
+    catch (e) {
+        parentPort?.postMessage({
+            type: "error",
+            error: e instanceof Error ? e.message : String(e),
+        });
+    }
+});

package/dist/inference.d.ts

@@ -0,0 +1,27 @@
+import { type InferenceBackend } from "./config.js";
+export interface InferenceProgress {
+    tokens: number;
+    maxTokens: number;
+}
+export interface InferenceResult {
+    content: string;
+    tokens: number;
+    ttftMs: number;
+    tpotMs: number;
+}
+export interface InferenceOptions {
+    maxTokens?: number;
+    onProgress?: (progress: InferenceProgress) => void;
+}
+export interface ChatMessage {
+    role: string;
+    content: string;
+}
+export type ActiveBackend = "ollama" | "vllm";
+export declare function getActiveBackend(): ActiveBackend;
+export declare function getActiveModel(): string;
+export declare function checkOllama(): Promise<boolean>;
+export declare function checkVllm(): Promise<boolean>;
+export declare function resolveInferenceBackend(preferred?: InferenceBackend, modelPreference?: string): Promise<ActiveBackend>;
+export declare function runInference(messages: ChatMessage[], maxTokensOrOptions?: number | InferenceOptions, maybeOptions?: InferenceOptions): Promise<InferenceResult>;
+export declare function runBenchmark(): Promise<number>;