@sifurai/cli 0.1.0 → 0.1.2

package/dist/secrets.js

@@ -1,28 +1,82 @@
+import { randomBytes } from 'node:crypto';
 const PLACEHOLDER = /\{\{([A-Z][A-Z0-9_]*)\}\}/g;
-export function secretNames(cases) {
-    const names = new Set();
+/** Not a secret: each run's own token, for data a case creates and can create again next run. */
+export const RUN = 'RUN';
+const ECHOED = /USER|EMAIL|LOGIN/;
+const HIDDEN = /PASSWORD|TOKEN|SECRET/;
+/** Where a step's secrets go: what it types, the page it opens, and the text it checks for. */
+function secretFields(step) {
+    switch (step.action) {
+        case 'fill':
+            return ['value'];
+        case 'goto':
+            return ['url'];
+        case 'expectText':
+        case 'expectUrl':
+            return ['text'];
+        default:
+            return [];
+    }
+}
+/** Each secret the scripts use, with the first step that needs it. */
+export function secretUses(cases) {
+    const uses = new Map();
     for (const testCase of cases) {
-        for (const step of testCase.uiScript ?? []) {
-            if (step.action !== 'fill')
-                continue;
-            for (const match of String(step.value ?? '').matchAll(PLACEHOLDER))
-                names.add(match[1]);
+        for (const [index, step] of (testCase.uiScript ?? []).entries()) {
+            for (const field of secretFields(step)) {
+                for (const match of String(step[field] ?? '').matchAll(PLACEHOLDER)) {
+                    const name = match[1];
+                    if (name !== RUN && !uses.has(name))
+                        uses.set(name, { name, caseId: testCase.id, step: index + 1, caption: step.caption });
+                }
+            }
         }
     }
-    return [...names].sort();
+    return [...uses.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+export function secretNames(cases) {
+    return secretUses(cases).map((use) => use.name);
 }
-/** From `SIFUR_SECRET_<NAME>`, or typed without echo. Kept in memory only: never written or sent to Sifur. */
-export async function collectSecrets(names, io, env = process.env) {
+/** From `SIFUR_SECRET_<NAME>`, or typed. Kept in memory only: never written or sent to Sifur. */
+export async function collectSecrets(uses, io, env = process.env) {
     const secrets = {};
-    for (const name of names) {
+    for (const { name, caseId, step, caption } of uses) {
         const fromEnv = env[`SIFUR_SECRET_${name}`];
-        secrets[name] = fromEnv !== undefined ? fromEnv : await io.askHidden(`${name} (or set SIFUR_SECRET_${name}): `);
+        if (fromEnv !== undefined) {
+            secrets[name] = fromEnv;
+            continue;
+        }
+        io.out(`${caseId} uses {{${name}}} in step ${step}${caption ? ` (${caption})` : ''}.`);
+        const prompt = `${name} (or set SIFUR_SECRET_${name}; Enter to skip the cases that need it): `;
+        const value = ECHOED.test(name) && !HIDDEN.test(name) ? await io.ask(prompt) : await io.askHidden(prompt);
+        // Left out: the cases that need it are skipped, never run with a blank login.
+        if (value !== '')
+            secrets[name] = value;
     }
     return secrets;
 }
 export function withSecrets(value, secrets) {
     return value.replace(PLACEHOLDER, (match, name) => secrets[name] ?? match);
 }
+export function newRunToken() {
+    const alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    return [...randomBytes(8)].map((byte) => alphabet[byte % alphabet.length]).join('');
+}
+/** The step as it's played: this run's token in every field, secrets where they belong. */
+export function resolveStep(step, secrets, runToken) {
+    const resolved = { ...step };
+    for (const field of ['url', 'selector', 'value', 'text']) {
+        const value = resolved[field];
+        if (typeof value === 'string')
+            resolved[field] = value.replaceAll(`{{${RUN}}}`, runToken);
+    }
+    for (const field of secretFields(step)) {
+        const value = resolved[field];
+        if (value !== undefined)
+            resolved[field] = withSecrets(String(value), secrets);
+    }
+    return resolved;
+}
 export function redact(text, secrets) {
     let redacted = text;
     for (const value of Object.values(secrets))

package/dist/store.js

@@ -1,9 +1,12 @@
-import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import { mkdir, readdir, readFile, rm, rmdir, writeFile } from 'node:fs/promises';
 import { isAbsolute, join, relative, resolve } from 'node:path';
 import { CliError } from './api.js';
-export const STORE = '.sifur';
+/** Where 0.1.0 kept a ticket's files, in the directory it ran from. Never read or written now. */
+export const LEGACY_STORE = '.sifur';
+/** Folder of a patch `sifur apply` put in a checkout, kept until `--revert` needs it. */
+export const APPLIED = 'applied';
 export function ticketDir(root, key) {
-    return join(root, STORE, key.replace(/[^A-Za-z0-9_-]/g, '_'));
+    return join(root, key.replace(/[^A-Za-z0-9_-]/g, '_'));
 }
 export async function saveCases(root, saved) {
     const dir = ticketDir(root, saved.acceptance.ticket.key);
@@ -44,15 +47,15 @@ export async function findTicketDir(root, ref) {
         return direct;
     let entries;
     try {
-        entries = await readdir(join(root, STORE));
+        entries = await readdir(root);
     }
     catch {
         return null;
     }
     for (const entry of entries) {
-        const saved = await readJson(join(root, STORE, entry, 'cases.json'));
+        const saved = await readJson(join(root, entry, 'cases.json'));
         if (saved?.acceptance.ticket.uuid === ref.toLowerCase())
-            return join(root, STORE, entry);
+            return join(root, entry);
     }
     return null;
 }
@@ -68,3 +71,19 @@ export async function loadResults(dir) {
         throw new CliError(`No results in ${dir}. Run with --run first.`);
     return mapScreenshots(saved, (screenshot) => resolve(dir, screenshot));
 }
+async function removeIfEmpty(dir) {
+    await rmdir(dir).catch(() => { });
+}
+/** Removes a ticket's folder, and the store's own folder when nothing else is left in it. */
+export async function pruneTicketDir(store, dir) {
+    await removeIfEmpty(dir);
+    await removeIfEmpty(store);
+}
+/** Everything kept for a ticket once its results are in, except a patch that's still applied. */
+export async function removeTicketFiles(store, dir) {
+    const entries = await readdir(dir).catch(() => []);
+    for (const entry of entries)
+        if (entry !== APPLIED)
+            await rm(join(dir, entry), { recursive: true, force: true });
+    await pruneTicketDir(store, dir);
+}

package/dist/workspace.js

@@ -0,0 +1,142 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, rmdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { basename, dirname, isAbsolute, posix, relative, resolve, win32 } from 'node:path';
+import { CliError } from './api.js';
+export function gitTopLevel(cwd) {
+    try {
+        const top = execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        return top ? resolve(top) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function sameRepository(folder, repository) {
+    const name = repository.split('/').pop() ?? repository;
+    return folder.toLowerCase() === name.toLowerCase();
+}
+/**
+ * The checkout the CLI was run from, for the first repository in `needing` that's clearly its: the
+ * repositories named are only that one, or the folder has its name.
+ */
+export function defaultWorkdirFor(named, needing, workdirs, topLevel) {
+    if (!topLevel)
+        return { workdirs, chosen: null };
+    const repository = needing.find((r) => !workdirs[r] && (named.size === 1 || sameRepository(basename(topLevel), r)));
+    if (!repository)
+        return { workdirs, chosen: null };
+    return { workdirs: { ...workdirs, [repository]: topLevel }, chosen: { repository, dir: topLevel } };
+}
+/** For a repository whose automated cases have no --workdir. */
+export function defaultWorkdirs(cases, workdirs, topLevel) {
+    const named = new Set(cases.map((c) => c.repository).filter((r) => Boolean(r)));
+    const needing = cases.filter((c) => c.check !== 'ui' && c.automatedTestRef && c.repository).map((c) => c.repository);
+    return defaultWorkdirFor(named, needing, workdirs, topLevel);
+}
+export function shellQuote(value, platform = process.platform) {
+    if (/^[A-Za-z0-9_\-./:@%+,=~]+$/.test(value))
+        return value;
+    if (platform === 'win32')
+        return `"${value.replaceAll('"', '""')}"`;
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+const LEADING_CD = /^\s*cd\s+(["']?)\/workspace(?:\/[^\s"';&|]*)?\1\s*&&\s*/;
+const SANDBOX_PATH = /(^|[^\w./-])(["']?)\/workspace\/[^\s/"';&|]+/g;
+/** Sifur's sandbox checks a repository out at /workspace/<name>; here it's the engineer's own checkout. */
+export function localizeCommand(command, workdir, platform = process.platform) {
+    return command.replace(LEADING_CD, '').replace(SANDBOX_PATH, (_match, before, quote) => {
+        if (quote === '"')
+            return `${before}"${workdir.replace(/["$`\\]/g, '\\$&')}`;
+        if (quote === "'")
+            return `${before}'${workdir.replaceAll("'", `'\\''`)}`;
+        return `${before}${shellQuote(workdir, platform)}`;
+    });
+}
+/** Refuses, before anything is written, a path that would land outside its repository. */
+export function checkFilePaths(files) {
+    for (const file of files) {
+        const outside = !file.path ||
+            posix.isAbsolute(file.path) ||
+            win32.isAbsolute(file.path) ||
+            file.path.split(/[\\/]/).includes('..');
+        if (outside)
+            throw new CliError(`Sifur sent a test file to put at "${file.path}", outside the ${file.repository} repository. Refusing to write it.`);
+    }
+}
+/**
+ * Writes the test files Sifur keeps out of the repository into the checkout for the run. `remove` puts
+ * the checkout back as it was: created files and the folders made for them go, replaced files come back.
+ */
+export function placeTestFiles(workdir, files) {
+    checkFilePaths(files);
+    const root = resolve(workdir);
+    const undo = [];
+    let removed = false;
+    const remove = () => {
+        if (removed)
+            return;
+        removed = true;
+        for (const step of undo.reverse()) {
+            try {
+                step();
+            }
+            catch {
+                // A folder that isn't empty any more, or a file already gone, is left as it is.
+            }
+        }
+    };
+    try {
+        for (const file of files) {
+            const target = resolve(root, file.path);
+            const inside = relative(root, target);
+            if (!inside || inside.startsWith('..') || isAbsolute(inside)) {
+                throw new CliError(`Sifur sent a test file to put at "${file.path}", outside ${root}. Refusing to write it.`);
+            }
+            const missing = [];
+            for (let dir = dirname(target); dir !== root && !existsSync(dir); dir = dirname(dir))
+                missing.unshift(dir);
+            for (const dir of missing) {
+                mkdirSync(dir);
+                undo.push(() => rmdirSync(dir));
+            }
+            const content = Buffer.from(file.content, 'utf8');
+            if (existsSync(target)) {
+                if (!statSync(target).isFile())
+                    throw new CliError(`Can't put a test file at ${target}: something else is there.`);
+                const before = readFileSync(target);
+                if (before.equals(content))
+                    continue;
+                writeFileSync(target, content);
+                undo.push(() => writeFileSync(target, before));
+            }
+            else {
+                writeFileSync(target, content);
+                undo.push(() => rmSync(target, { force: true }));
+            }
+        }
+    }
+    catch (error) {
+        remove();
+        throw error;
+    }
+    return { workdir: root, count: files.length, remove };
+}
+/** Removes the placed files however the run ends: normally, on Ctrl-C or SIGTERM, or through process.exit. */
+export function removeOnExit(placed) {
+    const removeAll = () => {
+        for (const files of placed())
+            files.remove();
+    };
+    const onSignal = (signal) => {
+        removeAll();
+        process.exit(signal === 'SIGINT' ? 130 : 143);
+    };
+    process.on('exit', removeAll);
+    process.on('SIGINT', onSignal);
+    process.on('SIGTERM', onSignal);
+    return () => {
+        process.off('exit', removeAll);
+        process.off('SIGINT', onSignal);
+        process.off('SIGTERM', onSignal);
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sifurai/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Run a Sifur ticket's acceptance cases against your own test server and upload the results.",
   "license": "UNLICENSED",
   "homepage": "https://sifur.ai",