@hakobu/hakobu 1.0.0

package/lib-es5/bundler.js

@@ -0,0 +1,496 @@
+"use strict";
+/**
+ * Hakobu Bundle Mode
+ *
+ * Optional pre-processing step that bundles a project before packaging.
+ * This is useful for:
+ *   - TypeScript projects (compiled to JS)
+ *   - Workspace monorepos (resolved to a single bundle)
+ *   - Projects with complex dependency graphs (tree-shaken)
+ *
+ * Bundle mode is NOT the default. Native mode (direct packaging of JS files)
+ * remains the primary path. Bundle mode is an opt-in adapter that produces
+ * a self-contained JS project that the existing packaging pipeline can consume.
+ *
+ * Architecture:
+ *   1. BundleAdapter receives project root + entry + options
+ *   2. Adapter produces a bundled project in a temp directory
+ *   3. Packager runs on the temp directory as if it were a normal JS project
+ *   4. Temp directory is cleaned up after packaging
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAdapter = exports.RolldownAdapter = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const log_1 = require("./log");
+// ─────────────────────────────────────────────────────────────────────
+// Rolldown adapter
+// ─────────────────────────────────────────────────────────────────────
+class RolldownAdapter {
+    name = 'rolldown';
+    async bundle(input) {
+        // Dynamic import — rolldown is ESM-only and optional
+        let rolldown;
+        try {
+            rolldown = await loadRolldown();
+        }
+        catch {
+            throw new Error('Rolldown is required for bundle mode but could not be loaded.\n' +
+                'Install it with: pnpm add rolldown');
+        }
+        const { projectRoot, entry, external = [], appName } = input;
+        const entryPath = path_1.default.isAbsolute(entry)
+            ? entry
+            : path_1.default.resolve(projectRoot, entry);
+        if (!fs_1.default.existsSync(entryPath)) {
+            throw new Error(`Bundle entry not found: ${entryPath}`);
+        }
+        // Create temp output directory
+        const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'hakobu-bundle-'));
+        const outFile = 'index.js';
+        const warnings = [];
+        try {
+            log_1.log.info(`  bundler: rolldown`);
+            log_1.log.info(`  entry: ${path_1.default.relative(projectRoot, entryPath)}`);
+            // Default externals: node builtins + runtime-specific protocols + user-specified
+            const allExternal = [
+                /^node:/,
+                /^bun:/,
+                /^electron$/,
+                /^chromium-bidi/,
+                ...external.map(e => {
+                    if (e.includes('*')) {
+                        return new RegExp('^' + e.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\\\*/g, '.*') + '$');
+                    }
+                    return e;
+                }),
+            ];
+            const build = await rolldown.rolldown({
+                input: entryPath,
+                platform: 'node',
+                resolve: {
+                    conditionNames: ['node', 'import', 'require', 'default'],
+                    mainFields: ['module', 'main'],
+                },
+                external: allExternal,
+                onwarn: (warning) => {
+                    warnings.push({
+                        message: warning.message || String(warning),
+                        file: warning.loc?.file,
+                    });
+                },
+            });
+            const writeResult = await writeBundleOutput(build, tmpDir, outFile);
+            // Post-bundle: apply compatibility patches for bundler-hostile packages
+            const applied = [];
+            for (const file of writeResult.jsFiles) {
+                applied.push(...applyBundlePatches(file));
+            }
+            // Create a minimal package.json for the bundled output
+            const bundledPkg = {
+                name: appName,
+                version: '0.0.0',
+                type: 'module',
+                main: outFile,
+            };
+            fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'package.json'), JSON.stringify(bundledPkg, null, 2));
+            const outSize = writeResult.jsFiles.reduce((sum, file) => sum + fs_1.default.statSync(file).size, 0);
+            log_1.log.info(`  output: ${(outSize / 1024).toFixed(0)}KB bundled ` +
+                `(${writeResult.strategy}, ${writeResult.chunkCount} chunk${writeResult.chunkCount === 1 ? '' : 's'})`);
+            if (writeResult.fallbackReason) {
+                log_1.log.info(`  fallback: ${writeResult.fallbackReason}`);
+            }
+            if (writeResult.injectedChunks && writeResult.injectedChunks.length > 0) {
+                log_1.log.info(`  injected __dirname/__filename into ${writeResult.injectedChunks.length} chunk(s)`);
+            }
+            // Post-bundle diagnostics: classify warnings and scan for unhandled patterns
+            const diagnostics = analyzeBundleDiagnostics(warnings, writeResult, applied, external);
+            for (const d of diagnostics) {
+                if (d.severity === 'info') {
+                    log_1.log.info(`  ${d.message}`);
+                }
+                else {
+                    log_1.log.warn(`  ${d.message}`);
+                }
+            }
+            // Collect map file paths relative to tmpDir for asset inclusion
+            const relativeMapFiles = writeResult.mapFiles.map(f => path_1.default.relative(tmpDir, f));
+            return {
+                projectRoot: tmpDir,
+                entry: outFile,
+                warnings,
+                strategy: writeResult.strategy,
+                chunkCount: writeResult.chunkCount,
+                fallbackReason: writeResult.fallbackReason,
+                injectedChunks: writeResult.injectedChunks,
+                mapFiles: relativeMapFiles,
+                cleanup: () => {
+                    try {
+                        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+                    }
+                    catch { /* best effort */ }
+                },
+            };
+        }
+        catch (err) {
+            // Clean up on failure
+            try {
+                fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch { }
+            throw new Error(`Rolldown bundle failed: ${err.message}`);
+        }
+    }
+}
+exports.RolldownAdapter = RolldownAdapter;
+const CHUNK_BANNER = [
+    `import{fileURLToPath as _hk_f}from'node:url';`,
+    `import{dirname as _hk_d}from'node:path';`,
+].join('');
+const PATH_GLOBALS_POLYFILL = `var __filename=_hk_f(import.meta.url),__dirname=_hk_d(__filename);`;
+async function writeBundleOutput(build, tmpDir, outFile) {
+    // Always try code-splitting first
+    const result = await writeBundle(build, tmpDir, outFile, true);
+    // Inject __dirname/__filename polyfill into only the chunks that need it.
+    // Each chunk is scanned for bare __dirname/__filename references; if found,
+    // the polyfill is prepended. Chunks without these globals are left untouched.
+    const injectedChunks = injectPathGlobalsPerChunk(result.jsFiles);
+    const isSplit = result.jsFiles.length > 1;
+    return {
+        strategy: isSplit ? 'code-split' : 'single-chunk',
+        chunkCount: result.jsFiles.length,
+        jsFiles: result.jsFiles,
+        mapFiles: result.mapFiles,
+        ...(injectedChunks.length > 0 ? {
+            injectedChunks: injectedChunks.map(f => path_1.default.basename(f)),
+        } : {}),
+    };
+}
+async function writeBundle(build, tmpDir, outFile, codeSplitting) {
+    await build.write({
+        dir: tmpDir,
+        format: 'esm',
+        entryFileNames: outFile,
+        chunkFileNames: 'chunks/[name]-[hash].js',
+        sourcemap: true,
+        codeSplitting,
+        banner: CHUNK_BANNER,
+    });
+    return listBundleFiles(tmpDir);
+}
+function listBundleFiles(rootDir) {
+    const jsFiles = [];
+    const mapFiles = [];
+    function walk(dir) {
+        for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(fullPath);
+            }
+            else if (entry.isFile()) {
+                if (/\.(?:m?js|cjs)$/.test(entry.name)) {
+                    jsFiles.push(fullPath);
+                }
+                else if (entry.name.endsWith('.map')) {
+                    mapFiles.push(fullPath);
+                }
+            }
+        }
+    }
+    walk(rootDir);
+    jsFiles.sort();
+    mapFiles.sort();
+    return { jsFiles, mapFiles };
+}
+function resetBundleDir(tmpDir) {
+    fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+    fs_1.default.mkdirSync(tmpDir, { recursive: true });
+}
+/**
+ * Inject __dirname/__filename polyfill into specific chunks that use
+ * those globals. Returns the list of files that were injected.
+ *
+ * This replaces the old single-chunk fallback: instead of abandoning
+ * code-splitting when any chunk uses __dirname, we inject the polyfill
+ * into only the chunks that need it.
+ */
+function injectPathGlobalsPerChunk(jsFiles) {
+    const injected = [];
+    for (const file of jsFiles) {
+        const globals = findUnsafeNodePathGlobals(file);
+        if (globals.length > 0) {
+            injectPolyfillIntoFile(file);
+            injected.push(file);
+        }
+    }
+    return injected;
+}
+/**
+ * Prepend the __dirname/__filename polyfill to a JS file.
+ * Inserts after the CHUNK_BANNER (import statements) if present.
+ */
+function injectPolyfillIntoFile(filePath) {
+    const code = fs_1.default.readFileSync(filePath, 'utf8');
+    // The banner is at the top of the file. Insert the polyfill right after it.
+    // The banner ends with the last import statement's semicolon.
+    const bannerEnd = code.indexOf(`from'node:path';`);
+    if (bannerEnd >= 0) {
+        const insertPos = bannerEnd + `from'node:path';`.length;
+        const patched = code.slice(0, insertPos) + PATH_GLOBALS_POLYFILL + code.slice(insertPos);
+        fs_1.default.writeFileSync(filePath, patched);
+    }
+    else {
+        // No banner found — prepend the full polyfill with imports
+        fs_1.default.writeFileSync(filePath, CHUNK_BANNER + PATH_GLOBALS_POLYFILL + code);
+    }
+}
+function detectSingleChunkFallback(jsFiles) {
+    for (const file of jsFiles) {
+        const globals = findUnsafeNodePathGlobals(file);
+        if (globals.length > 0) {
+            return `${path_1.default.relative(path_1.default.dirname(file), file)} requires ${globals.join('/')} globals`;
+        }
+    }
+    return null;
+}
+function findUnsafeNodePathGlobals(filePath) {
+    const code = fs_1.default.readFileSync(filePath, 'utf8');
+    const ast = (0, parser_1.parse)(code, {
+        sourceType: 'module',
+        plugins: ['importMeta', 'topLevelAwait'],
+    });
+    const found = new Set();
+    (0, traverse_1.default)(ast, {
+        Identifier(p) {
+            const name = p.node.name;
+            if (name !== '__dirname' && name !== '__filename')
+                return;
+            if (!p.isReferencedIdentifier())
+                return;
+            if (p.scope.hasBinding(name))
+                return;
+            found.add(name);
+        },
+    });
+    return Array.from(found);
+}
+/**
+ * Analyze bundle warnings and post-bundle state to produce actionable
+ * diagnostics for the user.
+ *
+ * Classifies Rolldown warnings into categories and suggests concrete
+ * actions (externalization, patch rules, etc.) where appropriate.
+ */
+function analyzeBundleDiagnostics(warnings, writeResult, appliedPatches, userExternals) {
+    const diagnostics = [];
+    // ── Classify warnings ──
+    const unresolvedImports = [];
+    const dynamicImports = [];
+    const otherWarnings = [];
+    for (const w of warnings) {
+        const msg = w.message;
+        if (/unresolved|not found|Could not resolve/i.test(msg)) {
+            // Extract package name from common warning formats
+            const pkgMatch = msg.match(/['"]([^'"]+)['"]/);
+            if (pkgMatch)
+                unresolvedImports.push(pkgMatch[1]);
+        }
+        else if (/dynamic/i.test(msg) && /import/i.test(msg)) {
+            dynamicImports.push(w.file ? path_1.default.basename(w.file) : 'unknown');
+        }
+        else {
+            otherWarnings.push(msg);
+        }
+    }
+    // Deduplicate
+    const uniqueUnresolved = [...new Set(unresolvedImports)];
+    const uniqueDynamic = [...new Set(dynamicImports)];
+    // ── Unresolved imports ──
+    if (uniqueUnresolved.length > 0) {
+        // Separate bun:* and other runtime-specific from real missing packages
+        const runtimeSpecific = uniqueUnresolved.filter(p => p.startsWith('bun:') || p.startsWith('deno:'));
+        const realMissing = uniqueUnresolved.filter(p => !p.startsWith('bun:') && !p.startsWith('deno:') && !p.startsWith('node:'));
+        if (runtimeSpecific.length > 0) {
+            diagnostics.push({
+                severity: 'info',
+                message: `[bundle] Runtime-specific imports skipped: ${runtimeSpecific.join(', ')} (stubbed at runtime)`,
+            });
+        }
+        if (realMissing.length > 0) {
+            diagnostics.push({
+                severity: 'warn',
+                message: `[bundle] Unresolved packages: ${realMissing.join(', ')}. ` +
+                    `If these are optional, use --external ${realMissing.map(p => `"${p}"`).join(' --external ')}`,
+            });
+        }
+    }
+    // ── Dynamic imports ──
+    if (uniqueDynamic.length > 0) {
+        diagnostics.push({
+            severity: 'warn',
+            message: `[bundle] Dynamic import() with variable arguments in ${uniqueDynamic.length} location(s). ` +
+                `Hakobu cannot trace these statically — the imported modules must be available at runtime.`,
+        });
+    }
+    // ── Applied patches summary ──
+    if (appliedPatches.length > 0) {
+        const scopes = [...new Set(appliedPatches.map(p => p.split(':')[0].trim()))];
+        diagnostics.push({
+            severity: 'info',
+            message: `[bundle] Compatibility patches applied for: ${scopes.join(', ')} (handled automatically)`,
+        });
+    }
+    // ── Per-chunk injection summary ──
+    if (writeResult.injectedChunks && writeResult.injectedChunks.length > 0) {
+        diagnostics.push({
+            severity: 'info',
+            message: `[bundle] __dirname/__filename polyfill injected into: ${writeResult.injectedChunks.join(', ')} (CJS-origin code)`,
+        });
+    }
+    // ── Other unclassified warnings ──
+    for (const msg of otherWarnings) {
+        diagnostics.push({
+            severity: 'warn',
+            message: `[bundle] ${msg}`,
+        });
+    }
+    // ── Summary line ──
+    const issueCount = diagnostics.filter(d => d.severity === 'warn').length;
+    if (issueCount === 0 && diagnostics.length > 0) {
+        diagnostics.push({
+            severity: 'info',
+            message: `[bundle] All detected patterns handled — no user action needed`,
+        });
+    }
+    return diagnostics;
+}
+/**
+ * Registry of known bundler-hostile patterns and their fixes.
+ *
+ * These packages use runtime introspection patterns (require.resolve to
+ * their own package.json, dirname-based path discovery, etc.) that produce
+ * build-time absolute paths after bundling. The paths don't exist at runtime
+ * in a packaged executable, so we replace them with safe stubs.
+ *
+ * Order matters: dirname(resolve(...)) rules must come before resolve(...)
+ * rules, because the latter is a substring of the former.
+ *
+ * To add a new package: append rules to the array below. Each rule is
+ * independent and self-documenting.
+ */
+const BUNDLE_PATCH_RULES = [
+    // ── playwright-core ──
+    // Playwright resolves its own package.json at runtime to find its
+    // installation directory. After bundling, these become absolute build-time
+    // paths that don't exist in the packaged snapshot.
+    {
+        name: 'dirname(resolve(playwright/package.json))',
+        scope: 'playwright-core',
+        pattern: /(?:dirname|_hk_d)\(\s*(?:__require\.resolve|require\.resolve)\(\s*"[^"]*playwright[^"]*package\.json"\s*\)\s*\)/g,
+        replacement: 'process.cwd()',
+    },
+    {
+        name: 'resolve(playwright/package.json)',
+        scope: 'playwright-core',
+        pattern: /(?:__require\.resolve|require\.resolve)\(\s*"[^"]*playwright[^"]*package\.json"\s*\)/g,
+        replacement: '"playwright-core-stub"',
+    },
+    {
+        name: 'require(playwright/package.json)',
+        scope: 'playwright-core',
+        pattern: /(?:__require|require)\(\s*"[^"]*playwright[^"]*package\.json"\s*\)/g,
+        replacement: '({name:"playwright-core",version:"0.0.0"})',
+    },
+    // ── Generic: relative package.json traversals ──
+    // Many packages use dirname(require.resolve('../../package.json')) to find
+    // their own root. After bundling, relative paths resolve to the bundler's
+    // working directory at build time, not the runtime location.
+    {
+        name: 'dirname(resolve(../package.json))',
+        scope: 'relative-package-json',
+        pattern: /[\w$.]+\.dirname\(\s*(?:__require\.resolve|require\.resolve)\(\s*"(?:\.\.\/)+package\.json"\s*\)\s*\)/g,
+        replacement: 'process.cwd()',
+    },
+    {
+        name: 'resolve(../package.json)',
+        scope: 'relative-package-json',
+        pattern: /(?:__require\.resolve|require\.resolve)\(\s*"(?:\.\.\/)+package\.json"\s*\)/g,
+        replacement: '"package-json-stub"',
+    },
+    {
+        name: 'require(../package.json)',
+        scope: 'relative-package-json',
+        pattern: /(?:__require|require)\(\s*"(?:\.\.\/)+package\.json"\s*\)/g,
+        replacement: '({name:"unknown",version:"0.0.0"})',
+    },
+];
+/**
+ * Apply all bundle compatibility patches to a file.
+ * Returns the list of rules that matched (for diagnostics).
+ */
+function applyBundlePatches(filePath) {
+    const original = fs_1.default.readFileSync(filePath, 'utf8');
+    let code = original;
+    const applied = [];
+    for (const rule of BUNDLE_PATCH_RULES) {
+        const before = code;
+        code = code.replace(rule.pattern, rule.replacement);
+        if (code !== before) {
+            applied.push(`${rule.scope}: ${rule.name}`);
+        }
+    }
+    if (code !== original) {
+        fs_1.default.writeFileSync(filePath, code);
+        for (const desc of applied) {
+            log_1.log.info(`  patched: ${desc}`);
+        }
+    }
+    return applied;
+}
+// ─────────────────────────────────────────────────────────────────────
+// Rolldown loader (handles ESM-only package from CJS context)
+// ─────────────────────────────────────────────────────────────────────
+let _rolldownCache = null;
+async function loadRolldown() {
+    if (_rolldownCache)
+        return _rolldownCache;
+    const { pathToFileURL } = require('url');
+    // rolldown is ESM-only, so we need dynamic import with a file:// URL
+    // (bare paths fail on Windows where import() expects URL format)
+    const dynamicImport = new Function('specifier', 'return import(specifier)');
+    // Try to find rolldown in the local node_modules first
+    const localPath = path_1.default.resolve(__dirname, '../node_modules/rolldown/dist/index.mjs');
+    if (fs_1.default.existsSync(localPath)) {
+        _rolldownCache = await dynamicImport(pathToFileURL(localPath).href);
+        return _rolldownCache;
+    }
+    // Fallback: try bare specifier (might work if hoisted)
+    try {
+        _rolldownCache = await dynamicImport('rolldown');
+        return _rolldownCache;
+    }
+    catch {
+        throw new Error('rolldown not found');
+    }
+}
+// ─────────────────────────────────────────────────────────────────────
+// Adapter registry
+// ─────────────────────────────────────────────────────────────────────
+const adapters = {
+    rolldown: () => new RolldownAdapter(),
+};
+function getAdapter(name) {
+    const factory = adapters[name];
+    if (!factory) {
+        throw new Error(`Unknown bundler: ${name}. Available: ${Object.keys(adapters).join(', ')}`);
+    }
+    return factory();
+}
+exports.getAdapter = getAdapter;
+//# sourceMappingURL=bundler.js.map

package/lib-es5/chmod.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plusx = void 0;
+const promises_1 = require("fs/promises");
+async function plusx(file) {
+    const s = await (0, promises_1.stat)(file);
+    const newMode = s.mode | 64 | 8 | 1;
+    if (s.mode === newMode) {
+        return;
+    }
+    const base8 = newMode.toString(8).slice(-3);
+    await (0, promises_1.chmod)(file, base8);
+}
+exports.plusx = plusx;
+//# sourceMappingURL=chmod.js.map

package/lib-es5/colors.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pc = void 0;
+const picocolors_1 = __importDefault(require("picocolors"));
+const tty_1 = require("tty");
+// makes color detection more accurate using node's own API for it
+// https://github.com/alexeyraspopov/picocolors/issues/85
+exports.pc = picocolors_1.default.createColors(tty_1.WriteStream.prototype.hasColors());
+//# sourceMappingURL=colors.js.map