blokctl 0.2.0

package/dist/services/package-manager.js

@@ -0,0 +1,111 @@
+import { exec as _exec } from "node:child_process";
+import { promisify } from "node:util";
+const executor = promisify(_exec);
+const isWindows = process.platform === "win32";
+export var VersionUpdateType;
+(function (VersionUpdateType) {
+    VersionUpdateType["PATCH"] = "patch";
+    VersionUpdateType["MINOR"] = "minor";
+    VersionUpdateType["MAJOR"] = "major";
+})(VersionUpdateType || (VersionUpdateType = {}));
+const COMMANDS = {
+    bun: {
+        INSTALL: "bun install",
+        BUILD: "bun run build",
+        PUBLISH: () => {
+            return "bun publish --access public";
+        },
+        INSTALL_NODE: (opts) => {
+            return `bun add ${opts.node}`;
+        },
+        UPDATE_VERSION: (opts) => {
+            return `bun version ${opts.type}`;
+        },
+    },
+    pnpm: {
+        INSTALL: "pnpm install",
+        BUILD: "pnpm run build",
+        PUBLISH: () => {
+            return "pnpm publish --access public";
+        },
+        INSTALL_NODE: (opts) => {
+            return `pnpm install ${opts.node}`;
+        },
+        UPDATE_VERSION: (opts) => {
+            return `pnpm version ${opts.type}`;
+        },
+    },
+    yarn: {
+        INSTALL: "yarn install",
+        BUILD: "yarn run build",
+        PUBLISH: () => {
+            return "yarn publish --access public";
+        },
+        INSTALL_NODE: (opts) => {
+            return `yarn add ${opts.node}`;
+        },
+        UPDATE_VERSION: (opts) => {
+            return `yarn version --${opts.type}`;
+        },
+    },
+    npm: {
+        INSTALL: "npm install",
+        BUILD: "npm run build",
+        PUBLISH: (opts) => {
+            return `npm publish --registry=${opts.registry} --userconfig ${opts.npmrcDir} --json`;
+        },
+        INSTALL_NODE: (opts) => {
+            return `npm install ${opts.node}`;
+        },
+        UPDATE_VERSION: (opts) => {
+            return `npm version ${opts.type}`;
+        },
+    },
+};
+const PACKAGE_MANAGERS = Object.keys(COMMANDS);
+class PackageManager {
+    static instance;
+    detectedManager = null;
+    constructor() { }
+    static getInstance() {
+        if (!PackageManager.instance) {
+            PackageManager.instance = new PackageManager();
+        }
+        return PackageManager.instance;
+    }
+    async isAvailable(cmd) {
+        const checkCmd = isWindows ? `where ${cmd}` : `which ${cmd}`;
+        try {
+            await executor(checkCmd);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getAvailableManagers() {
+        const availableManagers = [];
+        for (const manager of PACKAGE_MANAGERS) {
+            if (await this.isAvailable(manager)) {
+                availableManagers.push(manager);
+            }
+        }
+        return availableManagers;
+    }
+    async getManager(preferedManager) {
+        if (preferedManager)
+            return COMMANDS[preferedManager];
+        if (this.detectedManager)
+            return COMMANDS[this.detectedManager];
+        for (const manager of PACKAGE_MANAGERS) {
+            if (await this.isAvailable(manager)) {
+                this.detectedManager = manager;
+                return COMMANDS[manager];
+            }
+        }
+        throw new Error("No supported package manager found.");
+    }
+}
+export default PackageManager;
+const manager = PackageManager.getInstance();
+export { manager };

package/dist/services/posthog.d.ts

@@ -0,0 +1,31 @@
+export declare class PosthogAnalytics {
+    private sessionId;
+    private client?;
+    private distinctId;
+    private version;
+    constructor({ version, apiKey, host, cliConfigPath, }: {
+        version: string;
+        apiKey?: string;
+        host?: string;
+        cliConfigPath: string;
+    });
+    private writeCliConfig;
+    private initializePostHog;
+    private isTelemetryEnabled;
+    private getDistinctId;
+    private getSystemProperties;
+    private captureSessionStart;
+    trackCommand(options: {
+        command: string;
+        args?: Record<string, unknown>;
+        durationMs?: number;
+        status?: "success" | "error";
+        error?: string;
+    }): void;
+    trackCommandExecution<T>({ command, args, execution, }: {
+        command: string;
+        args: Record<string, unknown>;
+        execution: () => Promise<T>;
+    }): Promise<T>;
+    shutdown(): Promise<void>;
+}

package/dist/services/posthog.js

@@ -0,0 +1,159 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import { PostHog } from "posthog-node";
+export class PosthogAnalytics {
+    sessionId;
+    client;
+    distinctId;
+    version;
+    constructor({ version, apiKey = "phc_2xrtQviE7fuks4uth84sqTIq7gOErCX7FOATRjHjzBa", host = "https://us.i.posthog.com", cliConfigPath, }) {
+        this.version = version;
+        if (existsSync(cliConfigPath)) {
+            try {
+                const { distinctId, sessionId } = JSON.parse(readFileSync(cliConfigPath, "utf-8"));
+                this.distinctId = distinctId;
+                this.sessionId = sessionId;
+            }
+            catch (e) {
+                this.sessionId = randomUUID();
+                this.distinctId = this.getDistinctId();
+            }
+            this.writeCliConfig({
+                distinctId: this.distinctId,
+                sessionId: this.sessionId,
+            }, cliConfigPath);
+        }
+        else {
+            this.sessionId = randomUUID();
+            this.distinctId = this.getDistinctId();
+            this.writeCliConfig({
+                distinctId: this.distinctId,
+                sessionId: this.sessionId,
+            }, cliConfigPath);
+        }
+        if (this.isTelemetryEnabled()) {
+            this.initializePostHog(apiKey, host);
+        }
+    }
+    writeCliConfig({ distinctId, sessionId }, cliConfigPath) {
+        try {
+            writeFileSync(cliConfigPath, JSON.stringify({ distinctId, sessionId }));
+        }
+        catch (e) {
+        }
+    }
+    initializePostHog(apiKey, host) {
+        this.client = new PostHog(apiKey, {
+            host,
+            flushAt: 1,
+            flushInterval: 0,
+        });
+        this.captureSessionStart();
+        process.on("exit", () => {
+            this.client?.flush();
+        });
+    }
+    isTelemetryEnabled() {
+        if (process.env.NO_NANOCTL_TELEMETRY) {
+            return false;
+        }
+        return true;
+    }
+    getDistinctId() {
+        const machineId = os.hostname();
+        return `blokctl-${machineId}`;
+    }
+    getSystemProperties() {
+        return {
+            os: process.platform,
+            os_version: os.release(),
+            node_version: process.version,
+            platform: process.arch,
+            session_id: this.sessionId,
+            cli_version: this.version || "unknown",
+            machine_id: os.hostname(),
+        };
+    }
+    captureSessionStart() {
+        if (!this.client) {
+            return;
+        }
+        this.client.capture({
+            distinctId: this.distinctId,
+            event: "cli_session_start",
+            properties: {
+                ...this.getSystemProperties(),
+            },
+        });
+    }
+    trackCommand(options) {
+        try {
+            if (!this.client) {
+                console.log("CLIENT NOT FOUND");
+                return;
+            }
+            const commandData = {
+                command: options.command,
+                status: options.status || "success",
+            };
+            if (options.args) {
+                commandData.args = options.args;
+            }
+            if (options.durationMs) {
+                commandData.durationMs = options.durationMs;
+            }
+            if (options.error) {
+                commandData.error = options.error;
+            }
+            this.client.capture({
+                distinctId: this.distinctId,
+                event: "cli_command",
+                properties: {
+                    ...this.getSystemProperties(),
+                    ...commandData,
+                },
+            });
+        }
+        catch (e) {
+            console.log("ERROR", e);
+        }
+    }
+    async trackCommandExecution({ command, args, execution, }) {
+        const startTime = process.hrtime();
+        try {
+            const result = await execution();
+            const [seconds, nanoseconds] = process.hrtime(startTime);
+            const durationMs = seconds * 1000 + nanoseconds / 1000000;
+            this.trackCommand({
+                command,
+                args,
+                durationMs,
+                status: "success",
+            });
+            return result;
+        }
+        catch (error) {
+            const [seconds, nanoseconds] = process.hrtime(startTime);
+            const durationMs = seconds * 1000 + nanoseconds / 1000000;
+            this.trackCommand({
+                command,
+                args,
+                durationMs,
+                status: "error",
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async shutdown() {
+        if (!this.client) {
+            return;
+        }
+        try {
+            await this.client.shutdown();
+        }
+        catch (e) {
+        }
+    }
+}

package/dist/services/registry-manager.d.ts

@@ -0,0 +1,9 @@
+export default class RegistryManager {
+    private registry;
+    constructor();
+    setRegistry(url: string): void;
+    getRegistry(): string;
+    getRegistryToken(accessToken: string): Promise<any>;
+}
+declare const registryManager: RegistryManager;
+export { registryManager };

package/dist/services/registry-manager.js

@@ -0,0 +1,26 @@
+import { BLOK_URL } from "./constants.js";
+export default class RegistryManager {
+    registry;
+    constructor() {
+        this.registry = "https://registry.npmjs.org/";
+    }
+    setRegistry(url) {
+        this.registry = url;
+    }
+    getRegistry() {
+        return this.registry;
+    }
+    async getRegistryToken(accessToken) {
+        const response = await fetch(`${BLOK_URL}/repository-token`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        const data = await response.json();
+        return data;
+    }
+}
+const registryManager = new RegistryManager();
+export { registryManager };

package/dist/services/runtime-detector.d.ts

@@ -0,0 +1,23 @@
+export interface RuntimeInfo {
+    kind: string;
+    label: string;
+    available: boolean;
+    version?: string;
+    installHint: string;
+    defaultPort: number;
+    commands: string[];
+    toolchain: string;
+    installDeps: string;
+    startCmd: string;
+    sdkDir: string;
+    secondaryTool?: {
+        name: string;
+        command: string;
+        available?: boolean;
+        version?: string;
+        installHint: string;
+    };
+}
+export declare function detectRuntimes(): Promise<RuntimeInfo[]>;
+export declare function getRuntimeDefinition(kind: string): Omit<RuntimeInfo, "available" | "version"> | undefined;
+export declare function getAllRuntimeDefinitions(): Omit<RuntimeInfo, "available" | "version">[];

package/dist/services/runtime-detector.js

@@ -0,0 +1,181 @@
+import child_process from "node:child_process";
+import util from "node:util";
+const exec = util.promisify(child_process.exec);
+const RUNTIME_DEFINITIONS = [
+    {
+        kind: "python3",
+        label: "Python 3",
+        installHint: "Install Python: https://python.org/downloads/",
+        defaultPort: 9007,
+        commands: ["python3 --version"],
+        toolchain: "python3",
+        installDeps: "pip3 install -r requirements.txt",
+        startCmd: "python3 bin/serve.py",
+        sdkDir: "python3",
+    },
+    {
+        kind: "go",
+        label: "Go",
+        installHint: "Install Go: https://go.dev/dl/",
+        defaultPort: 9001,
+        commands: ["go version"],
+        toolchain: "go",
+        installDeps: "go mod download",
+        startCmd: "go run ./cmd/server",
+        sdkDir: "go",
+    },
+    {
+        kind: "rust",
+        label: "Rust",
+        installHint: "Install Rust: https://rustup.rs/",
+        defaultPort: 9002,
+        commands: ["rustc --version"],
+        toolchain: "rustc + cargo",
+        installDeps: "cargo build --release",
+        startCmd: "cargo run",
+        sdkDir: "rust",
+    },
+    {
+        kind: "java",
+        label: "Java",
+        installHint: "Install JDK 17+: https://adoptium.net/",
+        defaultPort: 9003,
+        commands: [
+            "java --version",
+            "/opt/homebrew/opt/openjdk/bin/java --version",
+            "/usr/libexec/java_home -v 17+ 2>/dev/null && java --version",
+        ],
+        toolchain: "java + mvn",
+        installDeps: "mvn package -q -DskipTests",
+        startCmd: "java -jar target/blok-java-1.0.0.jar",
+        sdkDir: "java",
+        secondaryTool: {
+            name: "Maven",
+            command: "mvn --version",
+            installHint: "Install Maven: https://maven.apache.org/install.html",
+        },
+    },
+    {
+        kind: "csharp",
+        label: "C# / .NET",
+        installHint: "Install .NET SDK: https://dotnet.microsoft.com/download",
+        defaultPort: 9004,
+        commands: ["dotnet --version"],
+        toolchain: "dotnet",
+        installDeps: "dotnet restore",
+        startCmd: "dotnet run --project src/Blok.Core",
+        sdkDir: "csharp",
+    },
+    {
+        kind: "php",
+        label: "PHP",
+        installHint: "Install PHP 8.2+: https://php.net/downloads",
+        defaultPort: 9005,
+        commands: ["php --version"],
+        toolchain: "php + composer",
+        installDeps: "composer install",
+        startCmd: "php bin/serve.php",
+        sdkDir: "php",
+        secondaryTool: {
+            name: "Composer",
+            command: "composer --version",
+            installHint: "Install Composer: https://getcomposer.org/download/",
+        },
+    },
+    {
+        kind: "ruby",
+        label: "Ruby",
+        installHint: "Install Ruby 3.2+: https://ruby-lang.org/en/downloads/",
+        defaultPort: 9006,
+        commands: ["ruby --version", "/opt/homebrew/opt/ruby/bin/ruby --version"],
+        toolchain: "ruby + bundler",
+        installDeps: "bundle install",
+        startCmd: "bundle exec rackup --host 0.0.0.0 config.ru",
+        sdkDir: "ruby",
+        secondaryTool: {
+            name: "Bundler",
+            command: "bundle --version",
+            installHint: "Install Bundler: gem install bundler",
+        },
+    },
+];
+async function tryExec(command) {
+    try {
+        const { stdout } = await exec(command, { timeout: 5000 });
+        return stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
+function parseVersion(output, kind) {
+    switch (kind) {
+        case "go": {
+            const match = output.match(/go(\d+\.\d+(?:\.\d+)?)/);
+            return match ? match[1] : undefined;
+        }
+        case "rust": {
+            const match = output.match(/rustc\s+(\d+\.\d+\.\d+)/);
+            return match ? match[1] : undefined;
+        }
+        case "java": {
+            const match = output.match(/(?:openjdk|java)\s+(\d+[\d.]*)/);
+            return match ? match[1] : undefined;
+        }
+        case "csharp": {
+            const match = output.match(/(\d+\.\d+\.\d+)/);
+            return match ? match[1] : undefined;
+        }
+        case "php": {
+            const match = output.match(/PHP\s+(\d+\.\d+\.\d+)/);
+            return match ? match[1] : undefined;
+        }
+        case "ruby": {
+            const match = output.match(/ruby\s+(\d+\.\d+\.\d+)/);
+            return match ? match[1] : undefined;
+        }
+        case "python3": {
+            const match = output.match(/Python\s+(\d+\.\d+\.\d+)/);
+            return match ? match[1] : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+export async function detectRuntimes() {
+    const results = [];
+    for (const def of RUNTIME_DEFINITIONS) {
+        const info = {
+            ...def,
+            available: false,
+            version: undefined,
+        };
+        for (const cmd of def.commands) {
+            const output = await tryExec(cmd);
+            if (output) {
+                info.available = true;
+                info.version = parseVersion(output, def.kind);
+                break;
+            }
+        }
+        if (def.secondaryTool) {
+            const secondaryOutput = await tryExec(def.secondaryTool.command);
+            info.secondaryTool = {
+                ...def.secondaryTool,
+                available: secondaryOutput !== null,
+                version: secondaryOutput ?? undefined,
+            };
+            if (info.available && !info.secondaryTool.available) {
+                info.available = false;
+            }
+        }
+        results.push(info);
+    }
+    return results;
+}
+export function getRuntimeDefinition(kind) {
+    return RUNTIME_DEFINITIONS.find((r) => r.kind === kind);
+}
+export function getAllRuntimeDefinitions() {
+    return [...RUNTIME_DEFINITIONS];
+}

package/dist/services/runtime-setup.d.ts

@@ -0,0 +1,36 @@
+import type { RuntimeInfo } from "./runtime-detector.js";
+type SpinnerHandler = {
+    start: (msg?: string) => void;
+    stop: (msg?: string, code?: number) => void;
+    message: (msg?: string) => void;
+};
+export interface RuntimeConfig {
+    port: number;
+    startCmd: string;
+    cwd: string;
+    kind: string;
+    label: string;
+}
+export interface TriggerConfig {
+    kind: string;
+    label: string;
+    port: number;
+    entryPoint: string;
+    startCmd: string;
+}
+export interface ProjectConfig {
+    triggers?: Record<string, TriggerConfig>;
+    runtimes?: Record<string, RuntimeConfig>;
+}
+export type ProjectRuntimeConfig = ProjectConfig;
+export declare function setupRuntime(runtime: RuntimeInfo, githubRepoLocal: string, projectDir: string, spinner: SpinnerHandler): Promise<RuntimeConfig>;
+export declare function writeProjectConfig(projectDir: string, runtimeConfigs: RuntimeConfig[], triggerConfigs?: TriggerConfig[]): void;
+export declare function readProjectConfig(projectDir: string): ProjectConfig | null;
+export declare function generateRuntimeEnvVars(runtimeConfigs: RuntimeConfig[]): string;
+export declare function generateSupervisordConfig(runtimeConfigs: RuntimeConfig[]): string;
+export declare function getTriggerPort(triggerKind: string): number;
+export declare function getTriggerLabel(triggerKind: string): string;
+export declare function createTriggerConfig(triggerKind: string): TriggerConfig;
+export declare function generateTriggerEnvVars(triggerConfigs: TriggerConfig[]): string;
+export declare function generateTriggerSupervisordConfig(triggerConfigs: TriggerConfig[]): string;
+export {};