hadara 0.1.0-rc.0

package/dist/services/harness-service.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHarnessValidateReport = createHarnessValidateReport;
+const validate_1 = require("../harness/validate");
+function createHarnessValidateReport(projectRoot, taskId, options = {}) {
+    return (0, validate_1.validateTaskCapsule)(projectRoot, taskId, options);
+}

package/dist/services/install-plan.js

@@ -0,0 +1,233 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInstallPlanReport = createInstallPlanReport;
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const schema_1 = require("../core/schema");
+const REQUIRED_NODE_MAJOR = 22;
+function createInstallPlanReport(options = {}) {
+    const issues = [];
+    const mode = parseMode(options.mode, issues);
+    const platform = parsePlatform(options.platform, issues);
+    const sourceKind = parseSourceKind(options.sourceKind, options.source, issues);
+    const nodeMajor = Number.parseInt(process.versions.node.split('.')[0] ?? '', 10);
+    const detectedNode = Number.isFinite(nodeMajor) ? `${nodeMajor}.x` : null;
+    const windowsShimRejected = platform === 'wsl' && /node\.exe$/i.test(process.execPath);
+    if (nodeMajor !== REQUIRED_NODE_MAJOR) {
+        issues.push({
+            severity: 'error',
+            code: 'NODE_22_REQUIRED',
+            message: `HADARA install planning requires Node ${REQUIRED_NODE_MAJOR}.`
+        });
+    }
+    if (windowsShimRejected) {
+        issues.push({
+            severity: 'error',
+            code: 'WSL_WINDOWS_NODE_SHIM_REJECTED',
+            message: 'WSL install planning requires Linux Node.js, not a Windows node.exe shim.'
+        });
+    }
+    if (mode === 'execute') {
+        issues.push({
+            severity: 'error',
+            code: 'INSTALL_EXECUTION_DISABLED',
+            message: 'Installer execution is not implemented in this dry-run capsule.'
+        });
+    }
+    const target = createTarget(platform, options, issues);
+    const report = {
+        schemaVersion: 'hadara.install.plan.v1',
+        command: 'install.plan',
+        ok: false,
+        mode,
+        platform,
+        source: createSource(sourceKind, options.source),
+        target,
+        execution: {
+            executeEnabled: false,
+            disabledIssueCode: 'INSTALL_EXECUTION_DISABLED'
+        },
+        node: {
+            requiredMajor: REQUIRED_NODE_MAJOR,
+            detected: detectedNode,
+            windowsShimRejected
+        },
+        actions: createActions(platform),
+        issues
+    };
+    report.ok = report.issues.every((issue) => issue.severity !== 'error');
+    (0, schema_1.assertSchema)('hadara.install.plan.v1', report);
+    return report;
+}
+function parseMode(value, issues) {
+    if (value === undefined || value === 'dry-run')
+        return 'dry-run';
+    if (value === 'execute')
+        return 'execute';
+    issues.push({
+        severity: 'error',
+        code: 'INSTALL_MODE_UNSUPPORTED',
+        message: `Unsupported install mode: ${value}`
+    });
+    return 'dry-run';
+}
+function parsePlatform(value, issues) {
+    if (value === undefined)
+        return defaultPlatform();
+    if (value === 'linux' || value === 'posix' || value === 'windows' || value === 'wsl' || value === 'usb')
+        return value;
+    issues.push({
+        severity: 'error',
+        code: 'INSTALL_PLATFORM_UNSUPPORTED',
+        message: `Unsupported install platform: ${value}`
+    });
+    return defaultPlatform();
+}
+function parseSourceKind(value, source, issues) {
+    if (value === undefined)
+        return inferSourceKind(source);
+    if (value === 'tarball' || value === 'directory' || value === 'portable-bundle')
+        return value;
+    issues.push({
+        severity: 'error',
+        code: 'INSTALL_SOURCE_KIND_UNSUPPORTED',
+        message: `Unsupported install source kind: ${value}`
+    });
+    return inferSourceKind(source);
+}
+function defaultPlatform() {
+    return process.platform === 'win32' ? 'windows' : 'linux';
+}
+function inferSourceKind(source) {
+    if (!source)
+        return 'directory';
+    if (/\.tgz$/i.test(source))
+        return 'tarball';
+    return 'directory';
+}
+function createSource(kind, source) {
+    const relativePath = safeRelativePath(source);
+    return {
+        kind,
+        displayPath: relativePath ? `./${relativePath}` : '<redacted-source>',
+        pathRedacted: true,
+        ...(relativePath ? { relativePath } : {})
+    };
+}
+function createTarget(platform, options, issues) {
+    const root = platform === 'usb' ? options.usbRoot ?? options.target : options.target ?? options.prefix;
+    if (platform === 'usb' && !root) {
+        issues.push({
+            severity: 'error',
+            code: 'USB_ROOT_REQUIRED',
+            message: 'USB install planning requires an explicit USB root path, such as --usb-root L:\\HADARA or --usb-root /mnt/l/HADARA.'
+        });
+    }
+    const defaults = defaultTarget(platform, root);
+    const prefix = root ?? defaults.prefix;
+    const launcher = options.launcher ?? defaults.launcher;
+    return {
+        prefix: publicPathRef(prefix, defaults.prefixKind, platform),
+        launcher: publicPathRef(launcher, defaults.launcherKind, platform)
+    };
+}
+function defaultTarget(platform, root) {
+    switch (platform) {
+        case 'windows':
+            return {
+                prefix: '%LOCALAPPDATA%\\HADARA',
+                launcher: '%LOCALAPPDATA%\\HADARA\\bin\\hadara.cmd',
+                prefixKind: 'default',
+                launcherKind: 'default'
+            };
+        case 'usb':
+            if (root) {
+                return {
+                    prefix: root,
+                    launcher: joinPortableLauncher(root),
+                    prefixKind: 'portable',
+                    launcherKind: 'portable'
+                };
+            }
+            return {
+                prefix: '<usb-root-required>',
+                launcher: '<usb-root-required>/portable/bin/hadara',
+                prefixKind: 'portable',
+                launcherKind: 'portable'
+            };
+        case 'linux':
+        case 'posix':
+        case 'wsl':
+        default:
+            return {
+                prefix: '~/.local/share/hadara',
+                launcher: '~/.local/bin/hadara',
+                prefixKind: 'default',
+                launcherKind: 'default'
+            };
+    }
+}
+function joinPortableLauncher(root) {
+    const separator = root.includes('\\') ? '\\' : '/';
+    return `${root.replace(/[\\/]+$/, '')}${separator}portable${separator}bin${separator}hadara`;
+}
+function publicPathRef(value, kind, platform) {
+    const relativePath = safeRelativePath(value);
+    return {
+        displayPath: relativePath ? `./${relativePath}` : redactDisplayPath(value, platform),
+        pathRedacted: true,
+        kind,
+        ...(relativePath ? { relativePath } : {})
+    };
+}
+function safeRelativePath(value) {
+    if (!value || node_path_1.default.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith('~') || value.startsWith('<') || value.includes('%'))
+        return undefined;
+    const normalized = value.split(/[\\/]+/).filter(Boolean).join('/');
+    if (!normalized || normalized === '.' || normalized.startsWith('..'))
+        return undefined;
+    return normalized;
+}
+function redactDisplayPath(value, platform) {
+    if (value.startsWith('<'))
+        return value;
+    if (value.startsWith('~') || value.includes('%'))
+        return value;
+    if (/^[A-Za-z]:[\\/]/.test(value))
+        return '<redacted-windows-path>';
+    if (node_path_1.default.isAbsolute(value))
+        return `<redacted-${redactedPlatformLabel(platform)}-path>`;
+    return '<redacted-path>';
+}
+function redactedPlatformLabel(platform) {
+    if (platform === 'windows')
+        return 'windows';
+    if (platform === 'wsl')
+        return 'wsl';
+    if (platform === 'usb')
+        return node_os_1.default.platform() === 'win32' ? 'windows' : 'portable';
+    return 'linux';
+}
+function createActions(platform) {
+    const launcherKind = platform === 'windows' ? 'create-windows-launcher' : 'create-launcher';
+    return [
+        {
+            kind: 'create-directory',
+            description: 'Create install prefix if it does not exist.',
+            wouldWrite: true
+        },
+        {
+            kind: 'copy-bundle',
+            description: 'Copy the HADARA package or portable bundle into the install prefix.',
+            wouldWrite: true
+        },
+        {
+            kind: launcherKind,
+            description: 'Create a hadara launcher that points at the installed bundle.',
+            wouldWrite: true
+        }
+    ];
+}