@dainprotocol/cli 1.2.36 → 1.3.1

package/dist/commands/dev.js

@@ -1,79 +1,26 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = dev;
-var child_process_1 = require("child_process");
-var utils_1 = require("../utils");
-var ora_1 = __importDefault(require("ora"));
-var chokidar_1 = __importDefault(require("chokidar"));
-var path_1 = __importDefault(require("path"));
-var miniflare_1 = require("miniflare");
-var build_1 = __importDefault(require("./build"));
-var fs_extra_1 = __importDefault(require("fs-extra"));
-var net_1 = require("net");
-var childProcess = null;
-var watcher = null;
-var mf = null;
-var tunnelUrl = null;
-var isFirstStart = true;
-var proxyServer = null;
-var isCleaningUp = false;
-var debounceTimer = null;
-var KILL_TIMEOUT_MS = 5000;
+import { spawn } from 'child_process';
+import { getDainConfig, setupProxy, logError, logInfo, logSuccess, getStaticFilesPath, displayTunnelUrl, } from '../utils.js';
+import ora from 'ora';
+import chokidar from 'chokidar';
+import path from 'path';
+import { Log, LogLevel, Miniflare } from 'miniflare';
+import build from './build.js';
+import fs from 'fs-extra';
+import { createServer } from 'net';
+let childProcess = null;
+let watcher = null;
+let mf = null;
+let tunnelUrl = null;
+let isFirstStart = true;
+let proxyServer = null;
+let isCleaningUp = false;
+let debounceTimer = null;
+const KILL_TIMEOUT_MS = 5000;
 function isPortAvailable(port) {
-    return new Promise(function (resolve) {
-        var server = (0, net_1.createServer)()
-            .listen(port, function () { server.close(); resolve(true); })
-            .on('error', function () { return resolve(false); });
+    return new Promise((resolve) => {
+        const server = createServer()
+            .listen(port, () => { server.close(); resolve(true); })
+            .on('error', () => resolve(false));
     });
 }
 /**
@@ -81,13 +28,13 @@ function isPortAvailable(port) {
  * Sends SIGTERM first, escalates to SIGKILL after timeout.
  */
 function killProcess(proc) {
-    return new Promise(function (resolve) {
+    return new Promise((resolve) => {
         if (!proc.pid || proc.killed) {
             resolve();
             return;
         }
-        var resolved = false;
-        var done = function () {
+        let resolved = false;
+        const done = () => {
             if (resolved)
                 return;
             resolved = true;
@@ -98,255 +45,196 @@ function killProcess(proc) {
         proc.once('exit', done);
         proc.kill('SIGTERM');
         // Escalate to SIGKILL if process doesn't exit within timeout
-        var forceKillTimer = setTimeout(function () {
+        const forceKillTimer = setTimeout(() => {
             if (!resolved) {
                 try {
                     proc.kill('SIGKILL');
                 }
-                catch (_a) { }
+                catch { }
                 // Resolve after SIGKILL — don't wait forever
                 setTimeout(done, 500);
             }
         }, KILL_TIMEOUT_MS);
     });
 }
-function cleanup() {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (isCleaningUp)
-                        return [2 /*return*/];
-                    isCleaningUp = true;
-                    if (debounceTimer) {
-                        clearTimeout(debounceTimer);
-                        debounceTimer = null;
-                    }
-                    if (!childProcess) return [3 /*break*/, 2];
-                    return [4 /*yield*/, killProcess(childProcess)];
-                case 1:
-                    _a.sent();
-                    childProcess = null;
-                    _a.label = 2;
-                case 2:
-                    if (watcher) {
-                        watcher.close();
-                        watcher = null;
-                    }
-                    if (mf) {
-                        mf.dispose();
-                        mf = null;
-                    }
-                    (0, utils_1.logInfo)('Development server and file watcher stopped.');
-                    return [2 /*return*/];
-            }
-        });
-    });
+async function cleanup() {
+    if (isCleaningUp)
+        return;
+    isCleaningUp = true;
+    if (debounceTimer) {
+        clearTimeout(debounceTimer);
+        debounceTimer = null;
+    }
+    if (childProcess) {
+        await killProcess(childProcess);
+        childProcess = null;
+    }
+    if (watcher) {
+        watcher.close();
+        watcher = null;
+    }
+    if (mf) {
+        mf.dispose();
+        mf = null;
+    }
+    logInfo('Development server and file watcher stopped.');
 }
-function gracefulShutdown() {
-    return __awaiter(this, arguments, void 0, function (exitCode) {
-        var _a;
-        if (exitCode === void 0) { exitCode = 0; }
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, cleanup()];
-                case 1:
-                    _b.sent();
-                    if (!proxyServer) return [3 /*break*/, 5];
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, 4, , 5]);
-                    return [4 /*yield*/, proxyServer.stop()];
-                case 3:
-                    _b.sent();
-                    (0, utils_1.logInfo)('Proxy server closed.');
-                    return [3 /*break*/, 5];
-                case 4:
-                    _a = _b.sent();
-                    return [3 /*break*/, 5];
-                case 5:
-                    process.exit(exitCode);
-                    return [2 /*return*/];
-            }
-        });
-    });
+async function gracefulShutdown(exitCode = 0) {
+    await cleanup();
+    if (proxyServer) {
+        try {
+            await proxyServer.stop();
+            logInfo('Proxy server closed.');
+        }
+        catch { }
+    }
+    process.exit(exitCode);
 }
-function startProcess(mainFile_1, envVars_1) {
-    return __awaiter(this, arguments, void 0, function (mainFile, envVars, isRestart) {
-        var spinner, hasStarted, tsNodePath, markStarted;
-        var _a, _b;
-        if (isRestart === void 0) { isRestart = false; }
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    if (!childProcess) return [3 /*break*/, 2];
-                    return [4 /*yield*/, killProcess(childProcess)];
-                case 1:
-                    _c.sent();
-                    childProcess = null;
-                    _c.label = 2;
-                case 2:
-                    spinner = (0, ora_1.default)(isRestart ? 'Restarting development server...' : 'Starting development server...').start();
-                    hasStarted = false;
-                    tsNodePath = path_1.default.join(process.cwd(), 'node_modules', '.bin', 'ts-node');
-                    if (!fs_extra_1.default.existsSync(tsNodePath)) {
-                        spinner.fail('ts-node not found. Run: npm install ts-node typescript');
-                        return [2 /*return*/];
-                    }
-                    if (!fs_extra_1.default.existsSync(mainFile)) {
-                        spinner.fail("Main file not found: ".concat(mainFile));
-                        return [2 /*return*/];
-                    }
-                    childProcess = (0, child_process_1.spawn)(tsNodePath, [mainFile], {
-                        env: __assign(__assign({}, process.env), envVars),
-                        stdio: ['inherit', 'pipe', 'pipe'],
-                        shell: false,
-                    });
-                    markStarted = function (success) {
-                        if (hasStarted)
-                            return;
-                        hasStarted = true;
-                        if (success) {
-                            spinner.succeed(isRestart ? 'Development server restarted.' : 'Development server started.');
-                            if (tunnelUrl && isFirstStart) {
-                                (0, utils_1.displayTunnelUrl)(tunnelUrl);
-                                isFirstStart = false;
-                            }
-                        }
-                        else {
-                            spinner.fail('Development server error.');
-                        }
-                    };
-                    (_a = childProcess.stdout) === null || _a === void 0 ? void 0 : _a.on('data', function (data) { markStarted(true); process.stdout.write(data.toString()); });
-                    (_b = childProcess.stderr) === null || _b === void 0 ? void 0 : _b.on('data', function (data) {
-                        var output = data.toString();
-                        markStarted(output.includes('Error:') || output.includes('error:') ? false : true);
-                        process.stderr.write(output);
-                    });
-                    childProcess.on('close', function (code) {
-                        if (code !== 0 && code !== null && !hasStarted)
-                            spinner.fail("Development server exited with code ".concat(code));
-                        childProcess = null;
-                    });
-                    childProcess.on('error', function (error) { spinner.fail("Failed to start: ".concat(error.message)); childProcess = null; });
-                    return [2 /*return*/];
-            }
+async function startProcess(mainFile, envVars, isRestart = false) {
+    // Kill previous process and WAIT for it to fully exit before spawning a new one
+    if (childProcess) {
+        await killProcess(childProcess);
+        childProcess = null;
+    }
+    const spinner = ora(isRestart ? 'Restarting development server...' : 'Starting development server...').start();
+    let hasStarted = false;
+    if (!fs.existsSync(mainFile)) {
+        spinner.fail(`Main file not found: ${mainFile}`);
+        return;
+    }
+    const runtime = envVars.DAIN_RUNTIME || "node";
+    if (runtime === "bun") {
+        childProcess = spawn("bun", [mainFile], {
+            env: { ...process.env, ...envVars },
+            stdio: ["inherit", "pipe", "pipe"],
+            shell: false,
         });
-    });
-}
-function dev(options) {
-    return __awaiter(this, void 0, void 0, function () {
-        var config, port, portNumber, runtime, mainFile, resolvedMain, envVars, proxySetup, watchPaths, isRestarting_1, dainDir, outFile, MFconfig_1, error_1;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    config = (0, utils_1.getDainConfig)(options.config);
-                    port = process.env.PORT || options.port || '2022';
-                    portNumber = parseInt(port, 10);
-                    if (isNaN(portNumber) || portNumber < 1 || portNumber > 65535) {
-                        (0, utils_1.logError)("Invalid port: ".concat(port, ". Must be 1-65535. Using default port 2022"));
-                        port = '2022';
-                    }
-                    runtime = options.runtime || config.runtime || 'node';
-                    mainFile = config['main-file'];
-                    resolvedMain = path_1.default.resolve(process.cwd(), mainFile);
-                    if (!resolvedMain.startsWith(process.cwd())) {
-                        (0, utils_1.logError)('Invalid main-file path: must be within project directory');
-                        process.exit(1);
-                    }
-                    envVars = {
-                        PORT: port,
-                        DAIN_API_KEY: config['api-key'],
-                        DAIN_PROJECT_ID: config['project-id'],
-                        DAIN_ENVIRONMENT: config['environment'],
-                        DAIN_OUT_DIR: config['out-dir'],
-                    };
-                    process.once('SIGINT', function () { return gracefulShutdown(0); });
-                    process.once('SIGTERM', function () { return gracefulShutdown(0); });
-                    process.once('uncaughtException', function (error) { (0, utils_1.logError)('Uncaught Exception:', error); gracefulShutdown(1); });
-                    process.once('unhandledRejection', function (reason) { (0, utils_1.logError)('Unhandled Rejection:', reason); gracefulShutdown(1); });
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 10, , 11]);
-                    return [4 /*yield*/, isPortAvailable(portNumber)];
-                case 2:
-                    if (!(_a.sent())) {
-                        (0, utils_1.logError)("Port ".concat(portNumber, " is already in use. Use --port to specify a different port."));
-                        process.exit(1);
-                    }
-                    process.env.PORT = port;
-                    if (!!options.noproxy) return [3 /*break*/, 4];
-                    if (!config['api-key'])
-                        throw new Error("'api-key' is required when using development proxy");
-                    return [4 /*yield*/, (0, utils_1.setupProxy)(port, config['api-key'], config)];
-                case 3:
-                    proxySetup = _a.sent();
-                    proxyServer = proxySetup.client;
-                    tunnelUrl = proxySetup.tunnelUrl;
-                    _a.label = 4;
-                case 4:
-                    if (!(runtime === 'node')) return [3 /*break*/, 6];
-                    return [4 /*yield*/, startProcess(mainFile, envVars)];
-                case 5:
-                    _a.sent();
-                    watchPaths = [
-                        path_1.default.dirname(mainFile),
-                        config['static-dir'] ? path_1.default.join(process.cwd(), config['static-dir']) : (0, utils_1.getStaticFilesPath)(),
-                    ].filter(function (p) { return fs_extra_1.default.existsSync(p); });
-                    isRestarting_1 = false;
-                    watcher = chokidar_1.default.watch(watchPaths, { ignored: /(^|[\/\\])\./, persistent: true, ignoreInitial: true });
-                    watcher.on('change', function (changedPath) {
-                        if (debounceTimer)
-                            clearTimeout(debounceTimer);
-                        debounceTimer = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        if (isRestarting_1)
-                                            return [2 /*return*/];
-                                        isRestarting_1 = true;
-                                        (0, utils_1.logInfo)("File ".concat(changedPath, " changed. Restarting..."));
-                                        return [4 /*yield*/, startProcess(mainFile, envVars, true)];
-                                    case 1:
-                                        _a.sent();
-                                        isRestarting_1 = false;
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); }, 300);
-                    });
-                    (0, utils_1.logInfo)('Watching for file changes...');
-                    return [3 /*break*/, 9];
-                case 6:
-                    if (!(runtime === 'workers')) return [3 /*break*/, 8];
-                    dainDir = path_1.default.join(process.cwd(), '.dain');
-                    outFile = path_1.default.join(dainDir, path_1.default.basename(config['main-file'], '.ts') + '.mjs');
-                    return [4 /*yield*/, (0, build_1.default)({ config: options.config, runtime: 'workers', watch: true })];
-                case 7:
-                    _a.sent();
-                    MFconfig_1 = { scriptPath: outFile, modules: true, port: parseInt(port, 10), log: new miniflare_1.Log(miniflare_1.LogLevel.DEBUG), liveReload: true };
-                    mf = new miniflare_1.Miniflare(MFconfig_1);
-                    (0, utils_1.logSuccess)("Miniflare server started on port ".concat(port));
-                    fs_extra_1.default.watch(dainDir, { recursive: true }, function (_eventType, filename) {
-                        if (debounceTimer)
-                            clearTimeout(debounceTimer);
-                        debounceTimer = setTimeout(function () { if (mf) {
-                            mf.setOptions(MFconfig_1);
-                            (0, utils_1.logInfo)("Build updated (".concat(filename, ")"));
-                        } }, 300);
-                    });
-                    (0, utils_1.logInfo)('Watching for file changes in source and build directories...');
-                    return [3 /*break*/, 9];
-                case 8: throw new Error("Unsupported runtime: ".concat(runtime));
-                case 9: return [3 /*break*/, 11];
-                case 10:
-                    error_1 = _a.sent();
-                    (0, utils_1.logError)("Error in dev process for ".concat(runtime, " runtime:"), error_1);
-                    gracefulShutdown(1);
-                    return [3 /*break*/, 11];
-                case 11: return [2 /*return*/];
-            }
+    }
+    else {
+        const tsNodePath = path.join(process.cwd(), "node_modules", ".bin", "ts-node");
+        if (!fs.existsSync(tsNodePath)) {
+            spinner.fail("ts-node not found. Run: npm install ts-node typescript");
+            return;
+        }
+        childProcess = spawn(tsNodePath, [mainFile], {
+            env: { ...process.env, ...envVars },
+            stdio: ["inherit", "pipe", "pipe"],
+            shell: false,
         });
+    }
+    const markStarted = (success) => {
+        if (hasStarted)
+            return;
+        hasStarted = true;
+        if (success) {
+            spinner.succeed(isRestart ? 'Development server restarted.' : 'Development server started.');
+            if (tunnelUrl && isFirstStart) {
+                displayTunnelUrl(tunnelUrl);
+                isFirstStart = false;
+            }
+        }
+        else {
+            spinner.fail('Development server error.');
+        }
+    };
+    childProcess.stdout?.on('data', (data) => { markStarted(true); process.stdout.write(data.toString()); });
+    childProcess.stderr?.on('data', (data) => {
+        const output = data.toString();
+        markStarted(output.includes('Error:') || output.includes('error:') ? false : true);
+        process.stderr.write(output);
+    });
+    childProcess.on('close', (code) => {
+        if (code !== 0 && code !== null && !hasStarted)
+            spinner.fail(`Development server exited with code ${code}`);
+        childProcess = null;
     });
+    childProcess.on('error', (error) => { spinner.fail(`Failed to start: ${error.message}`); childProcess = null; });
+}
+export default async function dev(options) {
+    const config = getDainConfig(options.config);
+    let port = process.env.PORT || options.port || '2022';
+    const portNumber = parseInt(port, 10);
+    if (isNaN(portNumber) || portNumber < 1 || portNumber > 65535) {
+        logError(`Invalid port: ${port}. Must be 1-65535. Using default port 2022`);
+        port = '2022';
+    }
+    const runtime = options.runtime || config.runtime || 'node';
+    const mainFile = config['main-file'];
+    const resolvedMain = path.resolve(process.cwd(), mainFile);
+    if (!resolvedMain.startsWith(process.cwd())) {
+        logError('Invalid main-file path: must be within project directory');
+        process.exit(1);
+    }
+    const envVars = {
+        PORT: port,
+        DAIN_API_KEY: config['api-key'],
+        DAIN_PROJECT_ID: config['project-id'],
+        DAIN_ENVIRONMENT: config['environment'],
+        DAIN_OUT_DIR: config['out-dir'],
+        DAIN_RUNTIME: runtime,
+    };
+    process.once('SIGINT', () => gracefulShutdown(0));
+    process.once('SIGTERM', () => gracefulShutdown(0));
+    process.once('uncaughtException', (error) => { logError('Uncaught Exception:', error); gracefulShutdown(1); });
+    process.once('unhandledRejection', (reason) => { logError('Unhandled Rejection:', reason); gracefulShutdown(1); });
+    try {
+        if (!(await isPortAvailable(portNumber))) {
+            logError(`Port ${portNumber} is already in use. Use --port to specify a different port.`);
+            process.exit(1);
+        }
+        process.env.PORT = port;
+        if (!options.noproxy) {
+            if (!config['api-key'])
+                throw new Error("'api-key' is required when using development proxy");
+            const proxySetup = await setupProxy(port, config['api-key'], config);
+            proxyServer = proxySetup.client;
+            tunnelUrl = proxySetup.tunnelUrl;
+        }
+        if (runtime === 'node' || runtime === 'bun') {
+            await startProcess(mainFile, envVars);
+            const watchPaths = [
+                path.dirname(mainFile),
+                config['static-dir'] ? path.join(process.cwd(), config['static-dir']) : getStaticFilesPath(),
+            ].filter((p) => fs.existsSync(p));
+            let isRestarting = false;
+            watcher = chokidar.watch(watchPaths, { ignored: /(^|[\/\\])\./, persistent: true, ignoreInitial: true });
+            watcher.on('change', (changedPath) => {
+                if (debounceTimer)
+                    clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(async () => {
+                    if (isRestarting)
+                        return;
+                    isRestarting = true;
+                    logInfo(`File ${changedPath} changed. Restarting...`);
+                    await startProcess(mainFile, envVars, true);
+                    isRestarting = false;
+                }, 300);
+            });
+            logInfo('Watching for file changes...');
+        }
+        else if (runtime === 'workers') {
+            const dainDir = path.join(process.cwd(), '.dain');
+            const outFile = path.join(dainDir, path.basename(config['main-file'], '.ts') + '.mjs');
+            await build({ config: options.config, runtime: 'workers', watch: true });
+            const MFconfig = { scriptPath: outFile, modules: true, port: parseInt(port, 10), log: new Log(LogLevel.DEBUG), liveReload: true };
+            mf = new Miniflare(MFconfig);
+            logSuccess(`Miniflare server started on port ${port}`);
+            fs.watch(dainDir, { recursive: true }, (_eventType, filename) => {
+                if (debounceTimer)
+                    clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(() => { if (mf) {
+                    mf.setOptions(MFconfig);
+                    logInfo(`Build updated (${filename})`);
+                } }, 300);
+            });
+            logInfo('Watching for file changes in source and build directories...');
+        }
+        else {
+            throw new Error(`Unsupported runtime: ${runtime}`);
+        }
+    }
+    catch (error) {
+        logError(`Error in dev process for ${runtime} runtime:`, error);
+        gracefulShutdown(1);
+    }
 }

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export default function init(projectName: string): void;

package/dist/commands/init.js

@@ -1,46 +1,43 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = init;
-var fs_extra_1 = __importDefault(require("fs-extra"));
-var path_1 = __importDefault(require("path"));
-var utils_1 = require("../utils");
-var ora_1 = __importDefault(require("ora"));
-function init(projectName) {
-    var spinner = (0, ora_1.default)('Initializing Dain project...').start();
-    var projectDir = path_1.default.join(process.cwd(), projectName);
-    var templateDir = path_1.default.join(__dirname, '..', '..', 'templates', 'default');
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { logError, logSuccess, logInfo } from '../utils.js';
+import ora from 'ora';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export default function init(projectName) {
+    const spinner = ora('Initializing Dain project...').start();
+    const projectDir = path.join(process.cwd(), projectName);
+    const templateDir = path.join(__dirname, '..', '..', 'templates', 'default');
     try {
-        var nodeVersion = Number(process.version.slice(1).split('.')[0]);
+        const nodeVersion = Number(process.version.slice(1).split('.')[0]);
         if (nodeVersion < 20) {
             spinner.fail('Node.js version 20.7 or higher is required');
-            (0, utils_1.logError)('Please upgrade Node.js to version 20.7 or higher');
-            (0, utils_1.logInfo)('You can download it from: https://nodejs.org/');
+            logError('Please upgrade Node.js to version 20.7 or higher');
+            logInfo('You can download it from: https://nodejs.org/');
             process.exit(1);
         }
-        if (fs_extra_1.default.existsSync(projectDir)) {
-            spinner.fail("Directory ".concat(projectName, " already exists"));
+        if (fs.existsSync(projectDir)) {
+            spinner.fail(`Directory ${projectName} already exists`);
             process.exit(1);
         }
-        fs_extra_1.default.ensureDirSync(projectDir);
-        fs_extra_1.default.copySync(templateDir, projectDir);
-        var packageJsonPath = path_1.default.join(projectDir, 'package.json');
-        var packageJson = fs_extra_1.default.readJsonSync(packageJsonPath);
+        fs.ensureDirSync(projectDir);
+        fs.copySync(templateDir, projectDir);
+        const packageJsonPath = path.join(projectDir, 'package.json');
+        const packageJson = fs.readJsonSync(packageJsonPath);
         packageJson.name = projectName;
-        fs_extra_1.default.writeJsonSync(packageJsonPath, packageJson, { spaces: 2 });
-        spinner.succeed("Initialized Dain project: ".concat(projectName));
-        (0, utils_1.logSuccess)("Project created at ".concat(projectDir));
-        (0, utils_1.logInfo)('Run the following commands to get started:');
-        (0, utils_1.logInfo)("  cd ".concat(projectName));
-        (0, utils_1.logInfo)('  npm install');
-        (0, utils_1.logInfo)('  npm run dev');
+        fs.writeJsonSync(packageJsonPath, packageJson, { spaces: 2 });
+        spinner.succeed(`Initialized Dain project: ${projectName}`);
+        logSuccess(`Project created at ${projectDir}`);
+        logInfo('Run the following commands to get started:');
+        logInfo(`  cd ${projectName}`);
+        logInfo('  npm install');
+        logInfo('  npm run dev');
         process.exit(0);
     }
     catch (error) {
         spinner.fail('Project initialization failed');
-        (0, utils_1.logError)('Error initializing project', error);
+        logError('Error initializing project', error);
         process.exit(1);
     }
 }

package/dist/commands/logs.d.ts

@@ -0,0 +1,4 @@
+export default function logs(options: {
+    config?: string;
+    watch?: boolean;
+}): Promise<void>;