blokctl 0.2.0

package/dist/services/runtime-setup.js

@@ -0,0 +1,250 @@
+import child_process from "node:child_process";
+import path from "node:path";
+import util from "node:util";
+import fsExtra from "fs-extra";
+const exec = util.promisify(child_process.exec);
+export async function setupRuntime(runtime, githubRepoLocal, projectDir, spinner) {
+    const sdkSourcePath = path.join(githubRepoLocal, "sdks", runtime.sdkDir);
+    const blokctlRuntimeDir = path.join(projectDir, ".blok", "runtimes", runtime.kind);
+    const projectRuntimeDir = path.join(projectDir, "runtimes", runtime.kind);
+    if (!fsExtra.existsSync(sdkSourcePath)) {
+        throw new Error(`SDK source for ${runtime.label} not found at ${sdkSourcePath}. Make sure the Blok repository is up to date.`);
+    }
+    spinner.message(`Setting up ${runtime.label} runtime...`);
+    fsExtra.ensureDirSync(path.dirname(blokctlRuntimeDir));
+    fsExtra.copySync(sdkSourcePath, blokctlRuntimeDir);
+    fsExtra.ensureDirSync(projectRuntimeDir);
+    const nodesDir = path.join(projectRuntimeDir, "nodes");
+    fsExtra.ensureDirSync(nodesDir);
+    let startCmdOverride;
+    switch (runtime.kind) {
+        case "python3":
+            await setupPython3(blokctlRuntimeDir, projectRuntimeDir, spinner);
+            break;
+        case "go":
+            await setupGo(blokctlRuntimeDir, spinner);
+            break;
+        case "rust":
+            await setupRust(blokctlRuntimeDir, spinner);
+            break;
+        case "java":
+            startCmdOverride = await setupJava(blokctlRuntimeDir, spinner);
+            break;
+        case "csharp":
+            await setupCSharp(blokctlRuntimeDir, spinner);
+            break;
+        case "php":
+            await setupPhp(blokctlRuntimeDir, spinner);
+            break;
+        case "ruby":
+            startCmdOverride = await setupRuby(blokctlRuntimeDir, spinner, runtime.defaultPort);
+            break;
+    }
+    spinner.message(`${runtime.label} runtime setup complete.`);
+    return {
+        port: runtime.defaultPort,
+        startCmd: startCmdOverride || runtime.startCmd,
+        cwd: path.relative(projectDir, blokctlRuntimeDir),
+        kind: runtime.kind,
+        label: runtime.label,
+    };
+}
+async function setupPython3(sdkDir, projectRuntimeDir, spinner) {
+    spinner.message("Creating Python3 virtual environment...");
+    await createPythonVenv(sdkDir);
+    spinner.message("Python3 virtual environment created.");
+    spinner.message("Installing Python3 packages...");
+    const venvPip = path.join(sdkDir, "python3_runtime", "bin", "pip3");
+    const requirementsFile = path.join(sdkDir, "requirements.txt");
+    if (fsExtra.existsSync(requirementsFile)) {
+        await exec(`"${venvPip}" install -r "${requirementsFile}"`, { cwd: sdkDir });
+    }
+    spinner.message("Python3 packages installed.");
+    const nodesLink = path.join(projectRuntimeDir, "nodes");
+    const sdkNodesDir = path.join(sdkDir, "nodes");
+    if (fsExtra.existsSync(sdkNodesDir) && !fsExtra.existsSync(nodesLink)) {
+        fsExtra.symlinkSync(sdkNodesDir, nodesLink, "junction");
+    }
+    const coreLink = path.join(projectRuntimeDir, "core");
+    const sdkCoreDir = path.join(sdkDir, "core");
+    if (fsExtra.existsSync(sdkCoreDir) && !fsExtra.existsSync(coreLink)) {
+        fsExtra.symlinkSync(sdkCoreDir, coreLink, "junction");
+    }
+}
+async function createPythonVenv(sdkDir) {
+    await exec("python3 -m venv python3_runtime", { cwd: sdkDir, timeout: 60000 });
+}
+async function setupGo(sdkDir, spinner) {
+    spinner.message("Downloading Go dependencies...");
+    await exec("go mod download", { cwd: sdkDir, timeout: 120000 });
+    spinner.message("Go dependencies installed.");
+}
+async function setupRust(sdkDir, spinner) {
+    spinner.message("Building Rust project (this may take a few minutes on first build)...");
+    await exec("cargo build --release", { cwd: sdkDir, timeout: 600000 });
+    spinner.message("Rust project built.");
+}
+async function setupJava(sdkDir, spinner) {
+    spinner.message("Building Java project with Maven...");
+    await exec("mvn package -q -DskipTests", { cwd: sdkDir, timeout: 300000 });
+    spinner.message("Java project built.");
+    const javaCandidates = ["java", "/opt/homebrew/opt/openjdk/bin/java"];
+    for (const javaBin of javaCandidates) {
+        try {
+            await exec(`${javaBin} --version`, { timeout: 5000 });
+            if (javaBin !== "java") {
+                return `${javaBin} -jar target/blok-java-1.0.0.jar`;
+            }
+            return undefined;
+        }
+        catch {
+        }
+    }
+    return undefined;
+}
+async function setupCSharp(sdkDir, spinner) {
+    spinner.message("Restoring .NET packages...");
+    await exec("dotnet restore", { cwd: sdkDir, timeout: 120000 });
+    spinner.message(".NET packages restored.");
+}
+async function setupPhp(sdkDir, spinner) {
+    spinner.message("Installing PHP dependencies...");
+    await exec("composer install --no-dev --optimize-autoloader", { cwd: sdkDir, timeout: 120000 });
+    spinner.message("PHP dependencies installed.");
+}
+async function setupRuby(sdkDir, spinner, port) {
+    const bundleCandidates = ["bundle", "/opt/homebrew/opt/ruby/bin/bundle"];
+    let resolvedBundle = "bundle";
+    for (const bin of bundleCandidates) {
+        try {
+            const { stdout } = await exec(`${bin} --version`, { timeout: 5000 });
+            const match = stdout.match(/(\d+)\./);
+            const major = match ? Number.parseInt(match[1], 10) : 0;
+            if (major >= 2) {
+                resolvedBundle = bin;
+                break;
+            }
+        }
+        catch {
+        }
+    }
+    spinner.message("Installing Ruby dependencies...");
+    await exec(`"${resolvedBundle}" install`, { cwd: sdkDir, timeout: 120000 });
+    spinner.message("Ruby dependencies installed.");
+    return `${resolvedBundle} exec rackup --host 0.0.0.0 -p ${port} config.ru`;
+}
+export function writeProjectConfig(projectDir, runtimeConfigs, triggerConfigs) {
+    const config = {};
+    if (runtimeConfigs.length > 0) {
+        config.runtimes = {};
+        for (const rc of runtimeConfigs) {
+            config.runtimes[rc.kind] = rc;
+        }
+    }
+    if (triggerConfigs && triggerConfigs.length > 0) {
+        config.triggers = {};
+        for (const tc of triggerConfigs) {
+            config.triggers[tc.kind] = tc;
+        }
+    }
+    const configPath = path.join(projectDir, ".blok", "config.json");
+    fsExtra.ensureDirSync(path.dirname(configPath));
+    fsExtra.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+export function readProjectConfig(projectDir) {
+    const configPath = path.join(projectDir, ".blok", "config.json");
+    if (!fsExtra.existsSync(configPath)) {
+        return null;
+    }
+    return JSON.parse(fsExtra.readFileSync(configPath, "utf8"));
+}
+export function generateRuntimeEnvVars(runtimeConfigs) {
+    if (runtimeConfigs.length === 0)
+        return "";
+    const lines = ["\n# Runtimes (auto-configured by blokctl)"];
+    for (const rc of runtimeConfigs) {
+        const envKey = rc.kind === "csharp" ? "CSHARP" : rc.kind.toUpperCase();
+        lines.push(`RUNTIME_${envKey}_HOST=localhost`);
+        lines.push(`RUNTIME_${envKey}_PORT=${rc.port}`);
+    }
+    return lines.join("\n");
+}
+export function generateSupervisordConfig(runtimeConfigs) {
+    let config = "";
+    for (const rc of runtimeConfigs) {
+        config += `
+[program:${rc.kind}_runtime]
+command=${rc.startCmd}
+directory=/app/${rc.cwd}
+environment=PORT="${rc.port}",HOST="0.0.0.0"
+autostart=true
+autorestart=true
+stderr_logfile=/var/log/${rc.kind}.err.log
+stdout_logfile=/var/log/${rc.kind}.out.log
+`;
+    }
+    return config;
+}
+const TRIGGER_PORTS = {
+    http: 4000,
+    sse: 4001,
+    websocket: 4002,
+    grpc: 4003,
+    cron: 4004,
+    queue: 4005,
+    pubsub: 4006,
+    webhook: 4007,
+    worker: 4008,
+};
+const TRIGGER_LABELS = {
+    http: "HTTP Trigger",
+    sse: "SSE Trigger",
+    websocket: "WebSocket Trigger",
+    grpc: "gRPC Trigger",
+    cron: "Cron Trigger",
+    queue: "Queue Trigger",
+    pubsub: "PubSub Trigger",
+    webhook: "Webhook Trigger",
+    worker: "Worker Trigger",
+};
+export function getTriggerPort(triggerKind) {
+    return TRIGGER_PORTS[triggerKind] ?? 4000;
+}
+export function getTriggerLabel(triggerKind) {
+    return TRIGGER_LABELS[triggerKind] ?? `${triggerKind.toUpperCase()} Trigger`;
+}
+export function createTriggerConfig(triggerKind) {
+    const port = getTriggerPort(triggerKind);
+    return {
+        kind: triggerKind,
+        label: getTriggerLabel(triggerKind),
+        port,
+        entryPoint: `src/triggers/${triggerKind}/index.ts`,
+        startCmd: `bun run src/triggers/${triggerKind}/index.ts`,
+    };
+}
+export function generateTriggerEnvVars(triggerConfigs) {
+    if (triggerConfigs.length === 0)
+        return "";
+    const lines = ["\n# Triggers (auto-configured by blokctl)"];
+    for (const tc of triggerConfigs) {
+        lines.push(`TRIGGER_${tc.kind.toUpperCase()}_PORT=${tc.port}`);
+    }
+    return lines.join("\n");
+}
+export function generateTriggerSupervisordConfig(triggerConfigs) {
+    let config = "";
+    for (const tc of triggerConfigs) {
+        config += `
+[program:${tc.kind}_trigger]
+command=${tc.startCmd}
+directory=/app
+environment=PORT="${tc.port}",HOST="0.0.0.0"
+autostart=true
+autorestart=true
+stderr_logfile=/var/log/${tc.kind}_trigger.err.log
+stdout_logfile=/var/log/${tc.kind}_trigger.out.log
+`;
+    }
+    return config;
+}

package/dist/services/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function getPackageVersion(): Promise<string>;
+export declare function getPreferredEditor(): string;

package/dist/services/utils.js

@@ -0,0 +1,29 @@
+import os from "node:os";
+import path, { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import fs from "fs-extra";
+export async function getPackageVersion() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const pkgJsonPath = path.join(__dirname, "..", "..", "package.json");
+    const content = (await fs.readJSON(pkgJsonPath));
+    return content?.version;
+}
+export function getPreferredEditor() {
+    const configPath = `${os.homedir()}/.blok/config.json`;
+    try {
+        if (fs.existsSync(configPath)) {
+            const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+            if (config.defaultEditor) {
+                return config.defaultEditor;
+            }
+        }
+    }
+    catch (error) {
+    }
+    return process.env.TERM_PROGRAM === "vscode"
+        ? "Visual Studio Code"
+        : process.env.TERM_PROGRAM === "cursor"
+            ? "Cursor"
+            : "Visual Studio Code";
+}

package/dist/services/workflow-loader.d.ts

@@ -0,0 +1,30 @@
+export interface WorkflowDef {
+    name: string;
+    version: string;
+    description?: string;
+    trigger: Record<string, unknown>;
+    steps: Array<{
+        name: string;
+        node: string;
+        type?: string;
+        runtime?: string;
+        conditions?: Array<{
+            type: "if" | "else";
+            expression?: string;
+            steps?: Array<{
+                name: string;
+                node: string;
+                type?: string;
+                runtime?: string;
+            }>;
+        }>;
+    }>;
+    nodes: Record<string, unknown>;
+}
+export interface LoadedWorkflow {
+    name: string;
+    filePath: string;
+    def: WorkflowDef;
+}
+export declare function loadWorkflows(directory: string): Promise<LoadedWorkflow[]>;
+export declare function loadWorkflow(directory: string, name: string): Promise<LoadedWorkflow | null>;

package/dist/services/workflow-loader.js

@@ -0,0 +1,46 @@
+import fs from "node:fs";
+import path from "node:path";
+export async function loadWorkflows(directory) {
+    const jsonDir = path.join(directory, "workflows", "json");
+    if (!fs.existsSync(jsonDir)) {
+        const altDir = path.join(directory, "workflows");
+        if (fs.existsSync(altDir)) {
+            return scanDirectory(altDir);
+        }
+        return [];
+    }
+    return scanDirectory(jsonDir);
+}
+export async function loadWorkflow(directory, name) {
+    const all = await loadWorkflows(directory);
+    return all.find((w) => w.name === name) ?? null;
+}
+function scanDirectory(dir) {
+    const workflows = [];
+    if (!fs.existsSync(dir))
+        return workflows;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith(".json")) {
+            const filePath = path.join(dir, entry.name);
+            try {
+                const content = fs.readFileSync(filePath, "utf-8");
+                const parsed = JSON.parse(content);
+                if (parsed.name && parsed.trigger && parsed.steps && parsed.nodes) {
+                    workflows.push({
+                        name: parsed.name,
+                        filePath,
+                        def: parsed,
+                    });
+                }
+            }
+            catch {
+            }
+        }
+        else if (entry.isDirectory()) {
+            const subWorkflows = scanDirectory(path.join(dir, entry.name));
+            workflows.push(...subWorkflows);
+        }
+    }
+    return workflows;
+}