mirror of
https://github.com/affaan-m/ECC.git
synced 2026-08-17 21:15:40 +02:00
296 lines
17 KiB
JavaScript
296 lines
17 KiB
JavaScript
'use strict';
|
|
|
|
const crypto = require('crypto');
|
|
const fs = require('fs');
|
|
const https = require('https');
|
|
const os = require('os');
|
|
const path = require('path');
|
|
const zlib = require('zlib');
|
|
|
|
const REGISTRY_ORIGIN = 'https://registry.nasiko.dev';
|
|
const REPOSITORY = 'nasiko/nasiko';
|
|
const SOURCE_URL = 'https://github.com/Nasiko-Labs/nasiko';
|
|
const LICENSE = 'Apache-2.0';
|
|
const METADATA_FILENAME = '.ecc-nasiko-install.json';
|
|
const MAX_MANIFEST_BYTES = 1024 * 1024;
|
|
const MAX_ARCHIVE_BYTES = 100 * 1024 * 1024;
|
|
const MAX_BINARY_BYTES = 64 * 1024 * 1024;
|
|
const MAX_METADATA_BYTES = 64 * 1024;
|
|
const SHA256_PATTERN = /^sha256:[a-f0-9]{64}$/;
|
|
|
|
const QUALIFIED_RELEASES = Object.freeze({
|
|
'v0.1.0': Object.freeze({
|
|
'linux/amd64': Object.freeze({ manifestDigest: 'sha256:0df748a40f3d714b6b6a3376a1d13a224c05bdb8d1628f31ace5a7bee8ceb9de', binaryDigest: 'sha256:94a2bcab2d3832257e0111480bb7c3dcac81d63a7ae9bac53206a92c0957ee0f' }),
|
|
'linux/arm64': Object.freeze({ manifestDigest: 'sha256:655021a129c7df4621a80d16ea4eab38018530bfe9a20da646641d9f4ac5c249', binaryDigest: 'sha256:85f9fa5cfbed6c276fce6df2d71e9d0c66d7d8e8d46a40297464833d38db7a7e' }),
|
|
'darwin/amd64': Object.freeze({ manifestDigest: 'sha256:b4188482621efd7da5a2ab630f653665ab5f80b9aceae448b6bb5fc93e003f06', binaryDigest: 'sha256:ed6232e0bb96a2dcfd86d3c25f86021091600d52f09250403a54528bfe8100a3' }),
|
|
'darwin/arm64': Object.freeze({ manifestDigest: 'sha256:ce7e54fa19f989a5d125c4409b3587ca9503bb5a07bc5ff223c60e0fbad437f0', binaryDigest: 'sha256:3c60f862b04eea1b9a633593b39f1a443d9ca2123cf3edfd150d313e95f3894b' }),
|
|
'windows/amd64': Object.freeze({ manifestDigest: 'sha256:0760fe1fc98e8fedb66796aaf891a1de9268af1338c5e88b949656fda5d9f045', binaryDigest: 'sha256:0f57672d24fc3c70e4cbbf22864e65b35b9978ddaae3793803841536e682929b' }),
|
|
}),
|
|
});
|
|
|
|
function normalizePlatform(platform = process.platform, architecture = process.arch) {
|
|
const osName = platform === 'win32' ? 'windows' : platform;
|
|
if (!['linux', 'darwin', 'windows'].includes(osName)) throw new Error(`Unsupported platform: ${platform}`);
|
|
const arch = architecture === 'x64' ? 'amd64' : architecture;
|
|
if (!['amd64', 'arm64'].includes(arch)) throw new Error(`Unsupported architecture: ${architecture}`);
|
|
if (osName === 'windows' && arch !== 'amd64') throw new Error(`Unsupported architecture for Windows: ${architecture}`);
|
|
return { os: osName, arch, binaryName: osName === 'windows' ? 'nasiko.exe' : 'nasiko' };
|
|
}
|
|
|
|
function getQualifiedRelease(version, platform = process.platform, architecture = process.arch) {
|
|
if (!/^v\d+\.\d+\.\d+$/.test(String(version || ''))) {
|
|
throw new Error('Nasiko installation requires a pinned version such as v0.1.0; latest is not allowed.');
|
|
}
|
|
const normalized = normalizePlatform(platform, architecture);
|
|
const qualification = QUALIFIED_RELEASES[version]?.[`${normalized.os}/${normalized.arch}`];
|
|
if (!qualification) throw new Error(`Nasiko ${version} is not qualified for ${normalized.os}/${normalized.arch}.`);
|
|
return { version, ...normalized, ...qualification, license: LICENSE, sourceUrl: SOURCE_URL };
|
|
}
|
|
|
|
function digestBytes(bytes) {
|
|
return `sha256:${crypto.createHash('sha256').update(bytes).digest('hex')}`;
|
|
}
|
|
|
|
function assertDigest(bytes, expectedDigest, label) {
|
|
if (!SHA256_PATTERN.test(expectedDigest)) throw new Error(`${label} has an invalid expected digest.`);
|
|
const actual = digestBytes(bytes);
|
|
if (actual !== expectedDigest) throw new Error(`${label} digest mismatch: expected ${expectedDigest}, got ${actual}.`);
|
|
}
|
|
|
|
function validateManifest(bytes) {
|
|
let manifest;
|
|
try { manifest = JSON.parse(bytes.toString('utf8')); } catch (_error) { throw new Error('Nasiko manifest is not valid JSON.'); }
|
|
if (manifest.schemaVersion !== 2 || !Array.isArray(manifest.layers) || manifest.layers.length !== 1) {
|
|
throw new Error('Nasiko manifest must contain exactly one OCI layer.');
|
|
}
|
|
const layer = manifest.layers[0];
|
|
if (layer.mediaType !== 'application/gzip' || !SHA256_PATTERN.test(layer.digest)) {
|
|
throw new Error('Nasiko manifest layer is not a qualified gzip artifact.');
|
|
}
|
|
if (!Number.isSafeInteger(layer.size) || layer.size <= 0 || layer.size > MAX_ARCHIVE_BYTES) {
|
|
throw new Error('Nasiko manifest layer size is outside the allowed range.');
|
|
}
|
|
return { digest: layer.digest, size: layer.size };
|
|
}
|
|
|
|
function readTarString(block, offset, length) {
|
|
return block.subarray(offset, offset + length).toString('utf8').replace(/\0.*$/, '');
|
|
}
|
|
|
|
function extractQualifiedTarGzip(archiveBytes, expectedName) {
|
|
let tar;
|
|
try { tar = zlib.gunzipSync(archiveBytes, { maxOutputLength: MAX_BINARY_BYTES + 2048 }); }
|
|
catch (_error) { throw new Error('Nasiko archive is invalid or exceeds the decompressed size limit.'); }
|
|
let offset = 0;
|
|
let binary = null;
|
|
while (offset + 512 <= tar.length) {
|
|
const header = tar.subarray(offset, offset + 512);
|
|
if (header.every(byte => byte === 0)) break;
|
|
const name = readTarString(header, 0, 100);
|
|
const prefix = readTarString(header, 345, 155);
|
|
const type = String.fromCharCode(header[156] || 48);
|
|
const rawSize = readTarString(header, 124, 12).trim();
|
|
const size = Number.parseInt(rawSize || '0', 8);
|
|
const start = offset + 512;
|
|
const end = start + size;
|
|
if (!Number.isSafeInteger(size) || size < 0 || end > tar.length) throw new Error('Nasiko archive is truncated.');
|
|
const payload = tar.subarray(start, end);
|
|
const isBinary = !prefix && name === expectedName && (type === '0' || type === '\0');
|
|
const isAppleDouble = !prefix && name === `._${expectedName}` && type === '0' && size <= 1024 * 1024;
|
|
const isPaxMetadata = !prefix && name === `PaxHeader/${expectedName}` && type === 'x' && size <= 64 * 1024
|
|
&& !/(?:^|\n)(?:path|linkpath)=/i.test(payload.toString('utf8'));
|
|
if (isBinary && !binary && size > 0 && size <= MAX_BINARY_BYTES) binary = Buffer.from(payload);
|
|
else if (!isAppleDouble && !isPaxMetadata) throw new Error('Unsafe Nasiko archive: expected exactly one bounded regular binary file.');
|
|
offset = start + Math.ceil(size / 512) * 512;
|
|
}
|
|
if (!binary) throw new Error('Unsafe Nasiko archive: expected exactly one bounded regular binary file.');
|
|
return binary;
|
|
}
|
|
|
|
function fetchBytes(url, options = {}) {
|
|
const parsed = new URL(url);
|
|
if (parsed.origin !== REGISTRY_ORIGIN || parsed.protocol !== 'https:') return Promise.reject(new Error('Nasiko download origin is not allowed.'));
|
|
const maxBytes = options.maxBytes || MAX_ARCHIVE_BYTES;
|
|
return new Promise((resolve, reject) => {
|
|
const request = https.get(parsed, { headers: options.accept ? { Accept: options.accept } : {} }, response => {
|
|
if (response.statusCode >= 300 && response.statusCode < 400) { response.resume(); reject(new Error('Nasiko registry redirects are not allowed.')); return; }
|
|
if (response.statusCode !== 200) { response.resume(); reject(new Error(`Nasiko registry returned HTTP ${response.statusCode}.`)); return; }
|
|
const chunks = [];
|
|
let total = 0;
|
|
response.on('data', chunk => {
|
|
total += chunk.length;
|
|
if (total > maxBytes) request.destroy(new Error('Nasiko registry response exceeded the size limit.'));
|
|
else chunks.push(chunk);
|
|
});
|
|
response.on('end', () => resolve(Buffer.concat(chunks)));
|
|
response.on('error', reject);
|
|
});
|
|
request.setTimeout(options.timeoutMs || 15000, () => request.destroy(new Error('Nasiko registry request timed out.')));
|
|
request.on('error', reject);
|
|
});
|
|
}
|
|
|
|
function defaultInstallDirectory(normalized, environment = process.env, homeDirectory = os.homedir()) {
|
|
if (normalized.os === 'windows') {
|
|
if (!environment.LOCALAPPDATA) throw new Error('LOCALAPPDATA is required on Windows.');
|
|
return path.join(environment.LOCALAPPDATA, 'nasiko', 'bin');
|
|
}
|
|
return path.join(homeDirectory, '.local', 'bin');
|
|
}
|
|
|
|
function validateInstallDirectory(directory) {
|
|
if (typeof directory !== 'string' || directory.includes('\0') || !path.isAbsolute(directory)) throw new Error('Nasiko install directory must be an absolute path.');
|
|
if (/^(?:\\\\|\\\\\?\\|\\\\\.\\)/.test(directory)) throw new Error('Nasiko install directory must be on a local filesystem.');
|
|
const resolved = path.resolve(directory);
|
|
if (resolved === path.parse(resolved).root) throw new Error('Nasiko cannot install directly into a filesystem root.');
|
|
let ancestor = resolved;
|
|
while (!fs.existsSync(ancestor)) ancestor = path.dirname(ancestor);
|
|
const canonical = fs.realpathSync(ancestor);
|
|
return path.join(canonical, path.relative(ancestor, resolved));
|
|
}
|
|
|
|
function assertPrivateInstallDirectory(directory) {
|
|
const stats = fs.lstatSync(directory);
|
|
if (!stats.isDirectory() || stats.isSymbolicLink()) throw new Error('Nasiko install directory must be a real directory, not a symlink.');
|
|
if (process.platform !== 'win32') {
|
|
if (typeof process.getuid === 'function' && stats.uid !== process.getuid()) throw new Error('Nasiko install directory must be owned by the current user.');
|
|
if ((stats.mode & 0o022) !== 0) throw new Error('Nasiko install directory must not be group- or world-writable.');
|
|
}
|
|
}
|
|
|
|
function metadataPathFor(executable) { return path.join(path.dirname(executable), METADATA_FILENAME); }
|
|
|
|
function readMetadata(executable) {
|
|
try {
|
|
const metadataPath = metadataPathFor(executable);
|
|
const stats = fs.lstatSync(metadataPath);
|
|
if (!stats.isFile() || stats.isSymbolicLink() || stats.size <= 0 || stats.size > MAX_METADATA_BYTES) return null;
|
|
return JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
|
|
}
|
|
catch (_error) { return null; }
|
|
}
|
|
|
|
function inspectInstalledNasiko(executable, resolveRelease = getQualifiedRelease) {
|
|
if (!executable || !fs.existsSync(executable)) return { installed: false, qualified: false, version: null, executable: executable || null };
|
|
const stats = fs.lstatSync(executable);
|
|
if (!stats.isFile() || stats.isSymbolicLink()) throw new Error('Nasiko executable must be a regular file, not a symlink.');
|
|
if (stats.size <= 0 || stats.size > MAX_BINARY_BYTES) return { installed: true, qualified: false, version: null, executable, binaryDigest: null, metadataPath: metadataPathFor(executable) };
|
|
const binaryDigest = digestBytes(fs.readFileSync(executable));
|
|
const metadata = readMetadata(executable);
|
|
let release = null;
|
|
try { if (metadata) release = resolveRelease(metadata.version, metadata.platform, metadata.architecture); } catch (_error) { release = null; }
|
|
const qualified = Boolean(release
|
|
&& metadata.installedPath === executable
|
|
&& metadata.manifestDigest === release.manifestDigest
|
|
&& metadata.binaryDigest === release.binaryDigest
|
|
&& binaryDigest === release.binaryDigest
|
|
&& metadata.license === release.license
|
|
&& metadata.sourceUrl === release.sourceUrl);
|
|
return { installed: true, qualified, version: qualified ? metadata.version : null, executable, binaryDigest, metadataPath: metadataPathFor(executable) };
|
|
}
|
|
|
|
function writeMetadataExclusive(metadataPath, metadata) {
|
|
fs.writeFileSync(metadataPath, `${JSON.stringify(metadata, null, 2)}\n`, { mode: 0o600, flag: 'wx' });
|
|
}
|
|
|
|
function acquireLifecycleLock(installDirectory) {
|
|
const lockPath = path.join(installDirectory, '.ecc-nasiko-lifecycle.lock');
|
|
let descriptor;
|
|
try { descriptor = fs.openSync(lockPath, 'wx', 0o600); }
|
|
catch (error) {
|
|
if (error.code === 'EEXIST') throw new Error('Another Nasiko lifecycle operation is already in progress.');
|
|
throw error;
|
|
}
|
|
return () => {
|
|
fs.closeSync(descriptor);
|
|
fs.rmSync(lockPath, { force: true });
|
|
};
|
|
}
|
|
|
|
async function installNasiko(options = {}, dependencies = {}) {
|
|
const version = options.version || 'v0.1.0';
|
|
const base = getQualifiedRelease(version, dependencies.platform || process.platform, dependencies.arch || process.arch);
|
|
const release = dependencies.releaseOverride ? { ...base, ...dependencies.releaseOverride } : base;
|
|
const installDirectory = validateInstallDirectory(options.installDir || defaultInstallDirectory(release, dependencies.environment || process.env, dependencies.homeDirectory || os.homedir()));
|
|
const destination = path.join(installDirectory, release.binaryName);
|
|
const plan = { dryRun: Boolean(options.dryRun), version, platform: release.os, architecture: release.arch, manifestDigest: release.manifestDigest, binaryDigest: release.binaryDigest, registryOrigin: REGISTRY_ORIGIN, destination, license: release.license, sourceUrl: release.sourceUrl };
|
|
if (options.dryRun) return plan;
|
|
if (!options.yes) throw new Error('Nasiko installation requires explicit --yes consent.');
|
|
fs.mkdirSync(installDirectory, { recursive: true, mode: 0o755 });
|
|
assertPrivateInstallDirectory(installDirectory);
|
|
const releaseLock = acquireLifecycleLock(installDirectory);
|
|
const metadataPath = metadataPathFor(destination);
|
|
let destinationOwned = false;
|
|
let metadataOwned = false;
|
|
try {
|
|
if (fs.existsSync(destination) || fs.existsSync(metadataPath)) {
|
|
const existing = inspectInstalledNasiko(destination);
|
|
if (existing.qualified && existing.version === version) return { ...plan, dryRun: false, installed: true, reused: true };
|
|
throw new Error('An unqualified or incompatible Nasiko executable or receipt already exists at the destination.');
|
|
}
|
|
const retrieve = dependencies.fetchBytes || fetchBytes;
|
|
const manifestBytes = await retrieve(`${REGISTRY_ORIGIN}/v2/${REPOSITORY}/manifests/${release.manifestDigest}`, { accept: 'application/vnd.oci.image.manifest.v1+json', maxBytes: MAX_MANIFEST_BYTES });
|
|
assertDigest(manifestBytes, release.manifestDigest, 'Nasiko manifest');
|
|
const layer = validateManifest(manifestBytes);
|
|
const archiveBytes = await retrieve(`${REGISTRY_ORIGIN}/v2/${REPOSITORY}/blobs/${layer.digest}`, { maxBytes: MAX_ARCHIVE_BYTES });
|
|
if (archiveBytes.length !== layer.size) throw new Error('Nasiko archive size mismatch.');
|
|
assertDigest(archiveBytes, layer.digest, 'Nasiko archive');
|
|
const binary = (dependencies.extractBinary || extractQualifiedTarGzip)(archiveBytes, release.binaryName);
|
|
assertDigest(binary, release.binaryDigest, 'Nasiko binary');
|
|
if (dependencies.beforePublish) dependencies.beforePublish(destination);
|
|
const descriptor = fs.openSync(destination, 'wx', 0o700);
|
|
destinationOwned = true;
|
|
try { fs.writeFileSync(descriptor, binary); fs.fsyncSync(descriptor); } finally { fs.closeSync(descriptor); }
|
|
assertDigest(fs.readFileSync(destination), release.binaryDigest, 'Published Nasiko binary');
|
|
const metadata = { version, platform: release.os, architecture: release.arch, manifestDigest: release.manifestDigest, artifactDigest: layer.digest, binaryDigest: release.binaryDigest, installedPath: destination, license: release.license, sourceUrl: release.sourceUrl };
|
|
(dependencies.writeMetadata || writeMetadataExclusive)(metadataPath, metadata);
|
|
metadataOwned = true;
|
|
return { ...plan, dryRun: false, installed: true, reused: false, artifactDigest: layer.digest };
|
|
} catch (error) {
|
|
if (metadataOwned) fs.rmSync(metadataPath, { force: true });
|
|
if (destinationOwned) fs.rmSync(destination, { force: true });
|
|
throw error;
|
|
} finally { releaseLock(); }
|
|
}
|
|
|
|
function uninstallNasiko(options = {}, dependencies = {}) {
|
|
const version = options.version || 'v0.1.0';
|
|
const release = getQualifiedRelease(version, dependencies.platform || process.platform, dependencies.arch || process.arch);
|
|
const installDirectory = validateInstallDirectory(options.installDir || defaultInstallDirectory(release, dependencies.environment || process.env, dependencies.homeDirectory || os.homedir()));
|
|
const destination = path.join(installDirectory, release.binaryName);
|
|
const plan = { dryRun: Boolean(options.dryRun), version, destination };
|
|
if (options.dryRun) return plan;
|
|
if (!options.yes) throw new Error('Nasiko uninstall requires explicit --yes consent.');
|
|
if (!fs.existsSync(installDirectory)) return { ...plan, dryRun: false, removed: false };
|
|
assertPrivateInstallDirectory(installDirectory);
|
|
const releaseLock = acquireLifecycleLock(installDirectory);
|
|
const metadataPath = metadataPathFor(destination);
|
|
const suffix = `${process.pid}-${crypto.randomBytes(6).toString('hex')}`;
|
|
const binaryTombstone = `${destination}.remove-${suffix}`;
|
|
const metadataTombstone = `${metadataPath}.remove-${suffix}`;
|
|
let binaryStaged = false;
|
|
let metadataStaged = false;
|
|
const rename = dependencies.rename || fs.renameSync;
|
|
try {
|
|
const status = (dependencies.inspectInstalled || inspectInstalledNasiko)(destination);
|
|
if (!status.installed) return { ...plan, dryRun: false, removed: false };
|
|
if (!status.qualified || status.version !== version) throw new Error('Refusing to remove an unqualified or modified Nasiko executable.');
|
|
rename(destination, binaryTombstone);
|
|
binaryStaged = true;
|
|
rename(metadataPath, metadataTombstone);
|
|
metadataStaged = true;
|
|
const cleanupPending = [];
|
|
try { fs.rmSync(metadataTombstone); } catch (_error) { cleanupPending.push(metadataTombstone); }
|
|
metadataStaged = false;
|
|
try { fs.rmSync(binaryTombstone); } catch (_error) { cleanupPending.push(binaryTombstone); }
|
|
binaryStaged = false;
|
|
return { ...plan, dryRun: false, removed: true, cleanupPending };
|
|
} catch (error) {
|
|
if (metadataStaged && !fs.existsSync(metadataPath)) rename(metadataTombstone, metadataPath);
|
|
if (binaryStaged && !fs.existsSync(destination)) rename(binaryTombstone, destination);
|
|
throw error;
|
|
} finally { releaseLock(); }
|
|
}
|
|
|
|
module.exports = { QUALIFIED_RELEASES, REGISTRY_ORIGIN, digestBytes, extractQualifiedTarGzip, fetchBytes, getQualifiedRelease, inspectInstalledNasiko, installNasiko, normalizePlatform, uninstallNasiko, validateInstallDirectory };
|