blokctl 0.6.18 → 0.6.20

package/dist/services/runtime-mutations.js

@@ -0,0 +1,67 @@
+import { generateRuntimeEnvVars, generateSupervisordConfig, } from "./runtime-setup.js";
+const RUNTIME_ENV_HEADER = "# Runtimes (auto-configured by blokctl)";
+export function runtimeEnvKey(kind) {
+    return kind === "csharp" ? "CSHARP" : kind.toUpperCase();
+}
+export function withRuntime(config, rc) {
+    return { ...config, runtimes: { ...(config.runtimes ?? {}), [rc.kind]: rc } };
+}
+export function withoutRuntime(config, kind) {
+    if (!config.runtimes || !(kind in config.runtimes))
+        return config;
+    const runtimes = Object.fromEntries(Object.entries(config.runtimes).filter(([k]) => k !== kind));
+    return { ...config, runtimes: Object.keys(runtimes).length === 0 ? undefined : runtimes };
+}
+export function rewriteRuntimeEnvBlock(envContent, runtimes) {
+    const isManaged = (line) => {
+        const t = line.trimStart();
+        return (line.trim() === RUNTIME_ENV_HEADER ||
+            /^RUNTIME_[A-Z0-9]+_(HOST|PORT|GRPC_PORT)=/.test(t) ||
+            /^BLOK_TRANSPORT=/.test(t));
+    };
+    const kept = envContent
+        .split("\n")
+        .filter((line) => !isManaged(line))
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .replace(/\n+$/, "");
+    const block = generateRuntimeEnvVars(runtimes);
+    if (!block)
+        return kept.length > 0 ? `${kept}\n` : "";
+    return `${kept}\n${block}\n`;
+}
+export function rewriteSupervisordRuntimes(supervisordContent, runtimes) {
+    const out = [];
+    let skipping = false;
+    for (const line of supervisordContent.split("\n")) {
+        const t = line.trimStart();
+        if (/^\[program:[\w-]+_runtime\]/.test(t)) {
+            skipping = true;
+            continue;
+        }
+        if (/^\[/.test(t))
+            skipping = false;
+        if (!skipping)
+            out.push(line);
+    }
+    const kept = out.join("\n").replace(/\n+$/, "");
+    const block = generateSupervisordConfig(runtimes);
+    return block ? `${kept}\n${block}\n` : `${kept}\n`;
+}
+const RUNTIME_GITIGNORE_GLOBS = [
+    ".blok/runtimes/**/bin/",
+    ".blok/runtimes/**/obj/",
+    ".blok/runtimes/**/target/",
+    ".blok/runtimes/**/__pycache__/",
+    ".blok/runtimes/**/python3_runtime/",
+    ".blok/runtimes/**/vendor/",
+];
+export function ensureRuntimeGitignore(gitignoreContent) {
+    if (/^\.blok\/\s*$/m.test(gitignoreContent))
+        return gitignoreContent;
+    const missing = RUNTIME_GITIGNORE_GLOBS.filter((glob) => !gitignoreContent.includes(glob));
+    if (missing.length === 0)
+        return gitignoreContent;
+    const base = gitignoreContent.replace(/\n+$/, "");
+    return `${base}\n\n# Blok runtime build artifacts (managed by blokctl)\n${missing.join("\n")}\n`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "blokctl",
-	"version": "0.6.18",
+	"version": "0.6.20",
 	"author": "Deskree Technologies Inc.",
 	"license": "Apache-2.0",
 	"description": "cli for blok",
@@ -30,7 +30,7 @@
 	"keywords": ["blokctl", "cli", "blok", "blok"],
 	"dependencies": {
 		"@ai-sdk/openai": "^1.3.22",
-		"@blokjs/runner": "^0.6.18",
+		"@blokjs/runner": "^0.6.20",
 		"@clack/prompts": "^1.0.0",
 		"ai": "^4.3.16",
 		"better-sqlite3": "^12.6.2",

package/dist/commands/marketplace/runtime.d.ts

@@ -1,54 +0,0 @@
-import type { CatalogStats, RuntimeKind, RuntimePackageManifest } from "@blokjs/runner";
-import { Command } from "../../services/commander.js";
-export interface MarketplaceConfig {
-    registryUrl: string;
-    cacheDir: string;
-    cacheTtlMs: number;
-}
-export interface MarketplaceListOptions {
-    runtime?: RuntimeKind;
-    query?: string;
-    tags?: string[];
-    verified?: boolean;
-    sortBy?: "name" | "downloads" | "rating" | "updated";
-    limit?: number;
-    format?: "table" | "json";
-}
-export interface MarketplaceInstallOptions {
-    name: string;
-    version?: string;
-    runtime?: RuntimeKind;
-    force?: boolean;
-}
-export interface MarketplacePublishOptions {
-    manifestPath: string;
-    dockerImage: string;
-    runtime: RuntimeKind;
-    tags?: string[];
-    description?: string;
-}
-export declare class RuntimeMarketplaceCommand {
-    private config;
-    constructor(config?: Partial<MarketplaceConfig>);
-    search(options: MarketplaceListOptions): Promise<RuntimePackageManifest[]>;
-    install(options: MarketplaceInstallOptions): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    publish(options: MarketplacePublishOptions): Promise<{
-        success: boolean;
-        packageId: string;
-        version: string;
-    }>;
-    info(name: string, version?: string): Promise<RuntimePackageManifest | null>;
-    stats(): Promise<CatalogStats>;
-    list(runtime: RuntimeKind): Promise<RuntimePackageManifest[]>;
-    formatTable(packages: RuntimePackageManifest[]): string;
-    formatJson(packages: RuntimePackageManifest[]): string;
-    private getCacheKey;
-    private readCache;
-    private writeCache;
-    private fetchFromApi;
-}
-declare const _default: Command;
-export default _default;

package/dist/commands/marketplace/runtime.js

@@ -1,350 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import * as p from "@clack/prompts";
-import { Command, trackCommandExecution } from "../../services/commander.js";
-import { tokenManager } from "../../services/local-token-manager.js";
-const DEFAULT_REGISTRY_URL = "https://marketplace.blok.dev/api/v1";
-const DEFAULT_CACHE_DIR = path.join(os.homedir(), ".blok", "marketplace-cache");
-const DEFAULT_CACHE_TTL_MS = 3_600_000;
-export class RuntimeMarketplaceCommand {
-    config;
-    constructor(config) {
-        this.config = {
-            registryUrl: config?.registryUrl ?? process.env.BLOK_MARKETPLACE_URL ?? DEFAULT_REGISTRY_URL,
-            cacheDir: config?.cacheDir ?? DEFAULT_CACHE_DIR,
-            cacheTtlMs: config?.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS,
-        };
-        if (!fs.existsSync(this.config.cacheDir)) {
-            fs.mkdirSync(this.config.cacheDir, { recursive: true });
-        }
-    }
-    async search(options) {
-        const cacheKey = this.getCacheKey(options);
-        const cached = this.readCache(cacheKey);
-        if (cached) {
-            return cached;
-        }
-        const searchOptions = {
-            query: options.query,
-            runtime: options.runtime,
-            tags: options.tags,
-            verified: options.verified,
-            sortBy: options.sortBy,
-            limit: options.limit,
-        };
-        const params = {};
-        if (searchOptions.query)
-            params.query = searchOptions.query;
-        if (searchOptions.runtime)
-            params.runtime = searchOptions.runtime;
-        if (searchOptions.tags && searchOptions.tags.length > 0)
-            params.tags = searchOptions.tags.join(",");
-        if (searchOptions.verified !== undefined)
-            params.verified = String(searchOptions.verified);
-        if (searchOptions.sortBy)
-            params.sortBy = searchOptions.sortBy;
-        if (searchOptions.limit)
-            params.limit = String(searchOptions.limit);
-        const result = await this.fetchFromApi("/packages/search", params);
-        const packages = result.packages;
-        this.writeCache(cacheKey, packages);
-        return packages;
-    }
-    async install(options) {
-        try {
-            let version = options.version;
-            if (!version) {
-                const versionInfo = await this.fetchFromApi(`/packages/${encodeURIComponent(options.name)}/versions/latest`);
-                version = versionInfo.latest;
-            }
-            const manifest = await this.fetchFromApi(`/packages/${encodeURIComponent(options.name)}/versions/${encodeURIComponent(version)}`);
-            if (options.runtime && manifest.runtime !== options.runtime) {
-                return {
-                    success: false,
-                    message: `Package "${options.name}" is for runtime "${manifest.runtime}", not "${options.runtime}".`,
-                };
-            }
-            if (manifest.dockerImage) {
-                const { exec } = await import("node:child_process");
-                const { promisify } = await import("node:util");
-                const execAsync = promisify(exec);
-                const pullCommand = options.force
-                    ? `docker pull --force ${manifest.dockerImage}`
-                    : `docker pull ${manifest.dockerImage}`;
-                try {
-                    await execAsync(pullCommand);
-                }
-                catch (dockerError) {
-                    return {
-                        success: false,
-                        message: `Failed to pull Docker image "${manifest.dockerImage}": ${dockerError.message}`,
-                    };
-                }
-            }
-            const catalogDir = path.join(os.homedir(), ".blok", "catalog");
-            if (!fs.existsSync(catalogDir)) {
-                fs.mkdirSync(catalogDir, { recursive: true });
-            }
-            const catalogFile = path.join(catalogDir, "installed.json");
-            let catalog = {};
-            if (fs.existsSync(catalogFile)) {
-                catalog = JSON.parse(fs.readFileSync(catalogFile, "utf-8"));
-            }
-            const catalogKey = `${manifest.name}@${manifest.version}`;
-            if (catalog[catalogKey] && !options.force) {
-                return {
-                    success: false,
-                    message: `Package "${catalogKey}" is already installed. Use --force to reinstall.`,
-                };
-            }
-            catalog[catalogKey] = manifest;
-            fs.writeFileSync(catalogFile, JSON.stringify(catalog, null, 2), "utf-8");
-            return {
-                success: true,
-                message: `Successfully installed ${manifest.name}@${manifest.version} (${manifest.runtime} runtime).`,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                message: `Failed to install "${options.name}": ${error.message}`,
-            };
-        }
-    }
-    async publish(options) {
-        try {
-            const manifestPath = path.resolve(options.manifestPath);
-            if (!fs.existsSync(manifestPath)) {
-                return {
-                    success: false,
-                    packageId: "",
-                    version: "",
-                };
-            }
-            const rawManifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
-            const manifest = {
-                name: rawManifest.name,
-                version: rawManifest.version,
-                runtime: options.runtime,
-                description: options.description ?? rawManifest.description ?? "",
-                author: rawManifest.author ?? "",
-                license: rawManifest.license ?? "MIT",
-                repository: rawManifest.repository,
-                tags: options.tags ?? rawManifest.tags ?? [],
-                protocols: rawManifest.protocols ?? ["http"],
-                dockerImage: options.dockerImage,
-                minBlokVersion: rawManifest.minBlokVersion,
-                nodeCount: rawManifest.nodes?.length ?? 0,
-                nodes: rawManifest.nodes ?? [],
-                createdAt: Date.now(),
-                updatedAt: Date.now(),
-                downloads: 0,
-                rating: 0,
-                verified: false,
-            };
-            if (!manifest.name) {
-                return { success: false, packageId: "", version: "" };
-            }
-            if (!manifest.version) {
-                return { success: false, packageId: "", version: "" };
-            }
-            const token = tokenManager.getToken();
-            if (!token) {
-                return { success: false, packageId: "", version: "" };
-            }
-            const response = await fetch(`${this.config.registryUrl}/packages`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: `Bearer ${token}`,
-                },
-                body: JSON.stringify(manifest),
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`API error (${response.status}): ${errorText}`);
-            }
-            const result = await response.json();
-            return {
-                success: true,
-                packageId: result.packageId ?? manifest.name,
-                version: manifest.version,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                packageId: "",
-                version: "",
-            };
-        }
-    }
-    async info(name, version) {
-        try {
-            const versionPath = version
-                ? `/packages/${encodeURIComponent(name)}/versions/${encodeURIComponent(version)}`
-                : `/packages/${encodeURIComponent(name)}`;
-            return await this.fetchFromApi(versionPath);
-        }
-        catch {
-            return null;
-        }
-    }
-    async stats() {
-        return this.fetchFromApi("/stats");
-    }
-    async list(runtime) {
-        const params = { runtime };
-        const result = await this.fetchFromApi("/packages", params);
-        return result.packages;
-    }
-    formatTable(packages) {
-        if (packages.length === 0) {
-            return "No packages found.";
-        }
-        const headers = ["Name", "Version", "Runtime", "Downloads", "Rating", "Verified", "Description"];
-        const rows = packages.map((pkg) => [
-            pkg.name,
-            pkg.version,
-            pkg.runtime,
-            String(pkg.downloads),
-            pkg.rating.toFixed(1),
-            pkg.verified ? "Yes" : "No",
-            pkg.description.length > 40 ? `${pkg.description.substring(0, 37)}...` : pkg.description,
-        ]);
-        const colWidths = headers.map((header, index) => {
-            const maxDataWidth = rows.reduce((max, row) => Math.max(max, row[index].length), 0);
-            return Math.max(header.length, maxDataWidth);
-        });
-        const separator = `+-${colWidths.map((w) => "-".repeat(w)).join("-+-")}-+`;
-        const headerRow = `| ${headers.map((h, i) => h.padEnd(colWidths[i])).join(" | ")} |`;
-        const dataRows = rows.map((row) => `| ${row.map((cell, i) => cell.padEnd(colWidths[i])).join(" | ")} |`);
-        return [separator, headerRow, separator, ...dataRows, separator].join("\n");
-    }
-    formatJson(packages) {
-        return JSON.stringify(packages, null, 2);
-    }
-    getCacheKey(options) {
-        const parts = [];
-        if (options.runtime)
-            parts.push(`runtime:${options.runtime}`);
-        if (options.query)
-            parts.push(`query:${options.query}`);
-        if (options.tags && options.tags.length > 0)
-            parts.push(`tags:${options.tags.sort().join(",")}`);
-        if (options.verified !== undefined)
-            parts.push(`verified:${options.verified}`);
-        if (options.sortBy)
-            parts.push(`sortBy:${options.sortBy}`);
-        if (options.limit)
-            parts.push(`limit:${options.limit}`);
-        const key = parts.length > 0 ? parts.join("|") : "all";
-        return hashToSafeFilename(key);
-    }
-    readCache(key) {
-        try {
-            const cacheFile = path.join(this.config.cacheDir, `${key}.json`);
-            if (!fs.existsSync(cacheFile)) {
-                return null;
-            }
-            const raw = fs.readFileSync(cacheFile, "utf-8");
-            const entry = JSON.parse(raw);
-            if (Date.now() - entry.timestamp > this.config.cacheTtlMs) {
-                fs.unlinkSync(cacheFile);
-                return null;
-            }
-            return entry.data;
-        }
-        catch {
-            return null;
-        }
-    }
-    writeCache(key, data) {
-        try {
-            const cacheFile = path.join(this.config.cacheDir, `${key}.json`);
-            const entry = {
-                timestamp: Date.now(),
-                data,
-            };
-            fs.writeFileSync(cacheFile, JSON.stringify(entry), "utf-8");
-        }
-        catch {
-        }
-    }
-    async fetchFromApi(apiPath, params) {
-        const url = new URL(`${this.config.registryUrl}${apiPath}`);
-        if (params) {
-            for (const [key, value] of Object.entries(params)) {
-                url.searchParams.set(key, value);
-            }
-        }
-        const token = tokenManager.getToken();
-        const headers = {
-            "Content-Type": "application/json",
-        };
-        if (token) {
-            headers.Authorization = `Bearer ${token}`;
-        }
-        const response = await fetch(url.toString(), {
-            method: "GET",
-            headers,
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`Marketplace API error (${response.status}): ${errorText}`);
-        }
-        return (await response.json());
-    }
-}
-function hashToSafeFilename(input) {
-    let hash = 0;
-    for (let i = 0; i < input.length; i++) {
-        const char = input.charCodeAt(i);
-        hash = (hash << 5) - hash + char;
-        hash |= 0;
-    }
-    return Math.abs(hash).toString(36);
-}
-export default new Command()
-    .command("runtime")
-    .description("Manage runtime packages from the Blok marketplace")
-    .option("-r, --runtime <value>", "Filter by runtime kind (nodejs, python3, go, rust, etc.)")
-    .option("-q, --query <value>", "Search query string")
-    .option("-t, --tags <value>", "Comma-separated tags to filter by")
-    .option("--verified", "Show only verified packages")
-    .option("-s, --sort-by <value>", "Sort by: name, downloads, rating, updated", "downloads")
-    .option("-l, --limit <value>", "Limit number of results", "20")
-    .option("-f, --format <value>", "Output format: table or json", "table")
-    .action(async (options) => {
-    await trackCommandExecution({
-        command: "marketplace runtime",
-        args: options,
-        execution: async () => {
-            const logger = p.spinner();
-            try {
-                logger.start("Searching marketplace for runtime packages...");
-                const marketplace = new RuntimeMarketplaceCommand();
-                const listOptions = {
-                    runtime: options.runtime,
-                    query: options.query,
-                    tags: options.tags ? options.tags.split(",") : undefined,
-                    verified: options.verified,
-                    sortBy: options.sortBy ?? "downloads",
-                    limit: options.limit ? Number.parseInt(options.limit, 10) : 20,
-                    format: options.format ?? "table",
-                };
-                const packages = await marketplace.search(listOptions);
-                if (packages.length === 0) {
-                    logger.stop("No packages found matching your criteria.");
-                    return;
-                }
-                const output = listOptions.format === "json" ? marketplace.formatJson(packages) : marketplace.formatTable(packages);
-                logger.stop(`Found ${packages.length} package(s):\n\n${output}`);
-            }
-            catch (error) {
-                logger.error(error.message);
-            }
-        },
-    });
-});