rubrkit 0.1.0

package/src/manifest.js

@@ -0,0 +1,118 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export const MANIFEST_RELATIVE_PATH = '.rubrkit/manifest.json';
+
+/**
+ * @param {string} content
+ */
+export function hashContent(content) {
+    return `sha256:${crypto.createHash('sha256').update(content).digest('hex')}`;
+}
+
+/**
+ * @param {string} root
+ * @param {Pick<typeof fs, 'readFile'>} [fsImpl]
+ */
+export async function loadManifest(root, fsImpl = fs) {
+    const manifestPath = path.join(root, MANIFEST_RELATIVE_PATH);
+
+    try {
+        const parsed = JSON.parse(await fsImpl.readFile(manifestPath, 'utf8'));
+        return normalizeManifest(parsed);
+    } catch (error) {
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+            return createEmptyManifest();
+        }
+
+        throw error;
+    }
+}
+
+/**
+ * @param {string} root
+ * @param {ReturnType<typeof createEmptyManifest>} manifest
+ * @param {Pick<typeof fs, 'mkdir' | 'writeFile'>} [fsImpl]
+ */
+export async function writeManifest(root, manifest, fsImpl = fs) {
+    const manifestPath = path.join(root, MANIFEST_RELATIVE_PATH);
+    const nextManifest = {
+        ...manifest,
+        updatedAt: new Date().toISOString(),
+        entries: [...manifest.entries].sort((left, right) => left.destinationPath.localeCompare(right.destinationPath)),
+    };
+
+    await fsImpl.mkdir(path.dirname(manifestPath), { recursive: true });
+    await fsImpl.writeFile(manifestPath, `${JSON.stringify(nextManifest, null, 2)}\n`, 'utf8');
+}
+
+export function createEmptyManifest() {
+    return {
+        schemaVersion: 1,
+        generatedBy: 'rubrkit-cli',
+        updatedAt: null,
+        entries: [],
+    };
+}
+
+/**
+ * @param {unknown} value
+ */
+function normalizeManifest(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return createEmptyManifest();
+    }
+
+    const record = /** @type {Record<string, unknown>} */ (value);
+    const entries = Array.isArray(record.entries)
+        ? record.entries.filter((entry) => entry && typeof entry === 'object').map((entry) => ({ ...entry }))
+        : [];
+
+    return {
+        schemaVersion: 1,
+        generatedBy: 'rubrkit-cli',
+        updatedAt: typeof record.updatedAt === 'string' ? record.updatedAt : null,
+        entries,
+    };
+}
+
+/**
+ * @param {ReturnType<typeof createEmptyManifest>} manifest
+ * @param {{ artifactBundleId: string, artifactId: string, destinationPath: string }} lookup
+ */
+export function findManifestEntry(manifest, lookup) {
+    return manifest.entries.find(
+        (entry) =>
+            entry.artifactBundleId === lookup.artifactBundleId &&
+            entry.artifactId === lookup.artifactId &&
+            entry.destinationPath === lookup.destinationPath,
+    );
+}
+
+/**
+ * @param {ReturnType<typeof createEmptyManifest>} manifest
+ * @param {Record<string, unknown>} nextEntry
+ */
+export function upsertManifestEntry(manifest, nextEntry) {
+    const index = manifest.entries.findIndex(
+        (entry) =>
+            entry.artifactBundleId === nextEntry.artifactBundleId &&
+            entry.artifactId === nextEntry.artifactId &&
+            entry.destinationPath === nextEntry.destinationPath,
+    );
+
+    if (index === -1) {
+        manifest.entries.push(nextEntry);
+    } else {
+        manifest.entries[index] = nextEntry;
+    }
+}
+
+/**
+ * @param {ReturnType<typeof createEmptyManifest>} manifest
+ * @param {Set<string>} destinationPaths
+ */
+export function removeManifestEntriesByDestination(manifest, destinationPaths) {
+    manifest.entries = manifest.entries.filter((entry) => !destinationPaths.has(String(entry.destinationPath)));
+}

package/src/pathSafety.js

@@ -0,0 +1,62 @@
+import path from 'node:path';
+
+import { RubrkitCliError } from './errors.js';
+
+/**
+ * @param {string} input
+ */
+export function normalizeArtifactPath(input) {
+    const value = String(input ?? '').replace(/\\/g, '/').trim();
+
+    if (!value || value.startsWith('/') || /^[a-zA-Z]:/.test(value)) {
+        throw new RubrkitCliError(`Unsafe artifact path "${input}".`, { code: 'unsafe_artifact_path' });
+    }
+
+    const parts = value.split('/').filter((part) => part && part !== '.');
+
+    if (parts.length === 0 || parts.some((part) => part === '..')) {
+        throw new RubrkitCliError(`Unsafe artifact path "${input}".`, { code: 'unsafe_artifact_path' });
+    }
+
+    return parts.join('/');
+}
+
+/**
+ * @param {string} root
+ * @param {string} relativePath
+ */
+export function resolveInsideRoot(root, relativePath) {
+    const normalizedRoot = path.resolve(root);
+    const normalizedRelativePath = normalizeArtifactPath(relativePath);
+    const target = path.resolve(normalizedRoot, ...normalizedRelativePath.split('/'));
+    const relative = path.relative(normalizedRoot, target);
+
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new RubrkitCliError(`Refusing to write outside the destination root: ${relativePath}`, {
+            code: 'path_outside_destination',
+        });
+    }
+
+    return target;
+}
+
+/**
+ * @param {string} root
+ * @param {string} target
+ */
+export function relativeToRoot(root, target) {
+    return path.relative(path.resolve(root), path.resolve(target)).replace(/\\/g, '/');
+}
+
+/**
+ * @param {string | null | undefined} value
+ */
+export function slugifyPathSegment(value) {
+    const slug = String(value ?? 'artifact-bundle')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+
+    return slug || 'artifact-bundle';
+}

package/src/prompts.js

@@ -0,0 +1,149 @@
+import readline from 'node:readline/promises';
+
+import { RubrkitCliError } from './errors.js';
+
+/**
+ * @param {{
+ *   bundles: Array<Record<string, any>>,
+ *   loadFiles(bundle: Record<string, any>): Promise<Array<Record<string, any>>>,
+ *   stdin: NodeJS.ReadableStream,
+ *   stdout: NodeJS.WritableStream,
+ * }} params
+ */
+export async function promptForPullSelections({ bundles, loadFiles, stdin, stdout }) {
+    if (bundles.length === 0) {
+        throw new RubrkitCliError('No active artifact bundles are available to pull.', { code: 'no_artifact_bundles' });
+    }
+
+    const inputMeta = /** @type {{ isTTY?: boolean }} */ (stdin);
+    const scriptedAnswers = inputMeta.isTTY ? null : await readScriptedAnswers(stdin);
+    const rl = scriptedAnswers ? null : readline.createInterface({ input: stdin, output: stdout });
+
+    try {
+        stdout.write('Artifact bundles:\n');
+        bundles.forEach((bundle, index) => {
+            stdout.write(`  ${index + 1}. ${bundle.name ?? bundle.id} (${bundle.id})\n`);
+        });
+
+        const bundleAnswer = await ask({ rl, scriptedAnswers, stdout }, 'Choose bundles by number, comma list, or "all": ');
+        const bundleIndexes = parseSelection(bundleAnswer, bundles.length);
+        const selectedBundles = bundleIndexes.map((index) => bundles[index]);
+        const selections = [];
+
+        for (const bundle of selectedBundles) {
+            const files = await loadFiles(bundle);
+
+            if (files.length === 0) {
+                continue;
+            }
+
+            stdout.write(`\nFiles in ${bundle.name ?? bundle.id}:\n`);
+            files.forEach((file, index) => {
+                const primary = file.isPrimary ? ' primary' : '';
+                stdout.write(`  ${index + 1}. ${file.path}${primary}\n`);
+            });
+
+            const fileAnswer = await ask({ rl, scriptedAnswers, stdout }, 'Choose files by number, comma list, or "all": ');
+            const fileIndexes = parseSelection(fileAnswer, files.length);
+
+            for (const index of fileIndexes) {
+                selections.push({ artifactBundle: bundle, file: files[index] });
+            }
+        }
+
+        return selections;
+    } finally {
+        rl?.close();
+    }
+}
+
+/**
+ * @param {{ rl: readline.Interface | null, scriptedAnswers: string[] | null, stdout: NodeJS.WritableStream }} input
+ * @param {string} question
+ */
+async function ask({ rl, scriptedAnswers, stdout }, question) {
+    if (scriptedAnswers) {
+        stdout.write(question);
+        const answer = scriptedAnswers.shift();
+
+        if (answer === undefined) {
+            throw new RubrkitCliError('Interactive selection was cancelled. Use --all or selectors with --yes for CI.', {
+                code: 'interactive_selection_cancelled',
+                exitCode: 2,
+            });
+        }
+
+        stdout.write(`${answer}\n`);
+        return answer;
+    }
+
+    try {
+        return await rl.question(question);
+    } catch {
+        throw new RubrkitCliError('Interactive selection was cancelled. Use --all or selectors with --yes for CI.', {
+            code: 'interactive_selection_cancelled',
+            exitCode: 2,
+        });
+    }
+}
+
+/**
+ * @param {NodeJS.ReadableStream} stdin
+ */
+async function readScriptedAnswers(stdin) {
+    let text = '';
+
+    for await (const chunk of stdin) {
+        text += chunk.toString();
+    }
+
+    return text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+
+/**
+ * @param {string} answer
+ * @param {number} length
+ */
+export function parseSelection(answer, length) {
+    const normalized = answer.trim().toLowerCase();
+
+    if (normalized === 'all' || normalized === '*') {
+        return Array.from({ length }, (_, index) => index);
+    }
+
+    const indexes = normalized
+        .split(',')
+        .map((part) => Number(part.trim()))
+        .filter((value) => Number.isInteger(value));
+
+    if (indexes.length === 0) {
+        throw new RubrkitCliError('Selection must be "all" or one or more item numbers.', {
+            code: 'invalid_selection',
+            exitCode: 2,
+        });
+    }
+
+    const unique = [];
+    const seen = new Set();
+
+    for (const value of indexes) {
+        if (value < 1 || value > length) {
+            throw new RubrkitCliError(`Selection ${value} is out of range.`, {
+                code: 'selection_out_of_range',
+                exitCode: 2,
+            });
+        }
+
+        const index = value - 1;
+
+        if (!seen.has(index)) {
+            unique.push(index);
+            seen.add(index);
+        }
+    }
+
+    return unique;
+}