@sifurai/cli 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,134 @@
-# Temporary Holding Version
+# Sifur CLI
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Run a Sifur ticket's acceptance cases against your own test server, from your own machine, and
+send the results back to Sifur.
+
+Use it when your app only runs on your team's servers, behind a firewall or VPN that Sifur can't
+reach. Sifur never deploys to your server, never holds VPN or server credentials, and never connects
+into your network: you deploy the ticket's branch, this tool runs the cases on your machine, and only
+the results and screenshots go to Sifur.
+
+## Requirements
+
+- Node.js 20 or newer
+- Google Chrome or Microsoft Edge (the tool drives the browser you already have; it downloads none)
+- A machine that can reach your test server (usually: on your company VPN)
+
+## Install
+
+Nothing to install up front:
+
+```sh
+npx @sifurai/cli login
+```
+
+Or install it globally to get a `sifur` command:
+
+```sh
+npm install -g @sifurai/cli
+sifur login
+```
+
+## Sign in
+
+```sh
+sifur login
+```
+
+This prints a code and opens Sifur in your browser. Check that the code matches, approve it, and
+the CLI is signed in. The sign-in is listed with your other sessions in Sifur, where you can revoke it.
+It follows your organization's single sign-on and MFA rules, like the console.
+
+The token is saved with owner-only permissions (0600) in:
+
+- macOS and Linux: `~/.config/sifur/credentials.json` (or `$XDG_CONFIG_HOME/sifur`)
+- Windows: `%APPDATA%\sifur\credentials.json`
+
+To sign out (and revoke the session):
+
+```sh
+sifur logout
+```
+
+## Run a ticket's acceptance cases
+
+When a ticket is in **Acceptance testing**, its Overview shows the branch and the commit of each
+repository to deploy. Deploy them to your test server, then run:
+
+```sh
+sifur accept AZA-12 --url https://test.example.internal
+```
+
+`AZA-12` is the ticket's key; its uuid works too. The CLI:
+
+1. Finds the ticket in your organizations and downloads its cases.
+2. Runs each UI case in a headless browser against `--url` (paths in the cases are relative to
+   it), taking a screenshot after every step. Add `--headed` to watch.
+3. For a step that needs a person's eye, shows you the screenshot's path and asks whether it looks
+   right.
+4. Runs automated cases in your checkout when you pass `--workdir <repository>=<dir>` (repeat it
+   for each repository); otherwise asks you for the result.
+5. For a case with no script, shows its steps and expected result and asks you for the result:
+   passed, failed or blocked, with a note.
+6. Uploads the screenshots and results, prints a summary, and links to the ticket.
+
+```sh
+sifur accept AZA-12 --url https://test.example.internal \
+    --workdir api=~/src/azalea-api --workdir web=~/src/azalea-web
+```
+
+Every case passed: the ticket moves on to approval. Any failed or blocked: it goes back to be fixed.
+
+Screenshots and results are kept in `./.sifur/AZA-12/` (add `.sifur/` to your `.gitignore`). If the
+upload fails, send them again with `sifur accept AZA-12 --upload`.
+
+## VPN: split tunnel or full tunnel
+
+With a **split-tunnel** VPN (only company traffic goes through it), one command does everything:
+your machine reaches the test server and Sifur at the same time.
+
+With a **full-tunnel** VPN that blocks the internet while it's up, work in three steps:
+
+```sh
+# VPN down
+sifur accept AZA-12 --download
+
+# VPN up: runs the cases, talks only to your test server
+sifur accept AZA-12 --run --url https://test.example.internal
+
+# VPN down
+sifur accept AZA-12 --upload
+```
+
+`--download` saves the cases in `./.sifur/AZA-12/`, `--run` runs them from there and saves the
+results next to them, and `--upload` sends them. Run all three from the same directory.
+
+## Secrets
+
+A case can use a placeholder such as `{{ADMIN_PASSWORD}}` for a value it types, like a test
+account's password. The CLI takes it from the environment variable `SIFUR_SECRET_ADMIN_PASSWORD`
+or, when that isn't set, asks you for it without echoing. Secrets stay on your machine: they are
+never written to `.sifur/`, never sent to Sifur, and are replaced with `[secret]` in any error
+message.
+
+```sh
+SIFUR_SECRET_ADMIN_PASSWORD='…' sifur accept AZA-12 --url https://test.example.internal
+```
+
+## Options
+
+| Option | |
+|---|---|
+| `--url <url>` | Your test server, where the ticket's branch is deployed |
+| `--headed` | Show the browser while the cases run |
+| `--workdir <repository>=<dir>` | Run that repository's automated cases in `<dir>`; repeatable |
+| `--download` / `--run` / `--upload` | The three steps for a full-tunnel VPN |
+| `--api <url>` | Sifur's API, for `login` (default `https://api.sifur.ai`, or `SIFUR_API_URL`) |
+
+## Exit codes
+
+| Code | Meaning |
+|---|---|
+| 0 | Every case passed (or `--download` finished) |
+| 1 | At least one case failed or was blocked |
+| 2 | An error: not signed in, the ticket isn't in acceptance testing, Sifur unreachable, no Chrome or Edge, … |

package/dist/accept.js

@@ -0,0 +1,304 @@
+import { existsSync, statSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { basename, extname, join, resolve } from 'node:path';
+import { ApiError, CliError } from './api.js';
+import { runAutomated } from './automated.js';
+import { launchBrowser } from './browser.js';
+import { askStatus, confirm } from './io.js';
+import { resolveTicket } from './resolve.js';
+import { buildResultsPayload, combine, outcome } from './results.js';
+import { runUiCase } from './runner.js';
+import { collectSecrets, redact, secretNames } from './secrets.js';
+import { findTicketDir, loadCases, loadResults, saveCases, saveResults } from './store.js';
+export const MAX_SCREENSHOT_BYTES = 5 * 1024 * 1024;
+export async function download(api, ref) {
+    const { ticketUuid, organization } = await resolveTicket(api, ref);
+    try {
+        const acceptance = await api.request(`tickets/${ticketUuid}/acceptance`, { organization: organization.uuid });
+        return { api: api.base, organizationUuid: organization.uuid, acceptance };
+    }
+    catch (error) {
+        if (error instanceof ApiError && error.status === 409) {
+            throw new CliError(`${ref} isn't waiting for acceptance testing: ${error.message}`);
+        }
+        throw error;
+    }
+}
+export function describeDeploy(acceptance, io) {
+    const { ticket, heads } = acceptance;
+    io.out(`${ticket.key}: ${ticket.title}`);
+    if (ticket.branch)
+        io.out(`Branch: ${ticket.branch}`);
+    const repositories = Object.entries(heads ?? {});
+    if (repositories.length > 0) {
+        io.out('The test server should be running:');
+        for (const [repository, sha] of repositories)
+            io.out(`  ${repository}  ${sha}`);
+    }
+    io.out(`${acceptance.cases.length} case${acceptance.cases.length === 1 ? '' : 's'}`);
+    io.out();
+}
+function printCase(io, testCase) {
+    for (const [index, step] of (testCase.steps ?? []).entries())
+        io.out(`    ${index + 1}. ${step}`);
+    if (testCase.expected)
+        io.out(`    Expected: ${testCase.expected}`);
+}
+async function askNote(io, prompt) {
+    return (await io.ask(prompt)).trim();
+}
+async function askEngineer(io, testCase, why) {
+    io.out(`  ${why}. Check it by hand:`);
+    printCase(io, testCase);
+    if (testCase.automatedTestRef)
+        io.out(`    Test: ${testCase.automatedTestRef}`);
+    const status = await askStatus(io, '  Result');
+    const note = await askNote(io, status === 'passed' ? '  Note (optional): ' : '  What happened? ');
+    return { status, note };
+}
+function judgeWith(io) {
+    return async (step, screenshot, testCase) => {
+        io.out(`  Judge: ${step.caption ?? 'Does the page look right?'}`);
+        if (testCase.expected)
+            io.out(`    Expected: ${testCase.expected}`);
+        io.out(screenshot ? `    Screenshot: ${screenshot}` : '    (No screenshot could be taken.)');
+        if (await confirm(io, '  Does it look right?'))
+            return { ok: true };
+        const note = await askNote(io, "  What's wrong? ");
+        return { ok: false, note: note || undefined };
+    };
+}
+function workdirFor(testCase, workdirs) {
+    if (testCase.repository && workdirs[testCase.repository])
+        return workdirs[testCase.repository];
+    const all = Object.values(workdirs);
+    return !testCase.repository && all.length === 1 ? all[0] : null;
+}
+function summarize(status, steps, notes) {
+    if (notes.length > 0)
+        return notes.join('\n');
+    if (status === 'passed' && steps.length > 0)
+        return `All ${steps.length} step${steps.length === 1 ? '' : 's'} passed.`;
+    return status === 'passed' ? 'Passed.' : `The case ${status}.`;
+}
+/** Runs every case on this machine against the engineer's test server. Nothing here talks to Sifur. */
+export async function runCases(acceptance, options, deps) {
+    const { io } = deps;
+    const workdirs = options.workdirs ?? {};
+    for (const [repository, dir] of Object.entries(workdirs)) {
+        if (!existsSync(dir) || !statSync(dir).isDirectory())
+            throw new CliError(`--workdir ${repository}=${dir}: no such directory.`);
+    }
+    const scripted = acceptance.cases.filter((c) => c.check !== 'automated' && (c.uiScript?.length ?? 0) > 0);
+    const secrets = await collectSecrets(secretNames(scripted), io, deps.env);
+    let browser = null;
+    const results = [];
+    try {
+        for (const testCase of acceptance.cases) {
+            io.out(`${testCase.id}  ${testCase.title}`);
+            const statuses = [];
+            const notes = [];
+            let steps = [];
+            let output;
+            if (testCase.check === 'ui' || testCase.check === 'both') {
+                if (scripted.includes(testCase)) {
+                    browser ??= await (deps.launch ?? launchBrowser)({ headed: options.headed });
+                    const ui = await runUiCase(browser, testCase, {
+                        baseUrl: options.baseUrl,
+                        outDir: options.outDir,
+                        secrets,
+                        judge: judgeWith(io),
+                        timeoutMs: deps.timeoutMs,
+                    });
+                    for (const step of ui.steps)
+                        io.out(`  ${step.ok ? 'ok  ' : 'FAIL'} ${step.n}. ${step.caption}${step.error ? `: ${step.error}` : ''}`);
+                    statuses.push(ui.status);
+                    notes.push(...ui.notes);
+                    steps = ui.steps;
+                }
+                else {
+                    const answer = await askEngineer(io, testCase, 'No UI script');
+                    statuses.push(answer.status);
+                    if (answer.note)
+                        notes.push(answer.note);
+                }
+            }
+            if (testCase.check === 'automated' || testCase.check === 'both') {
+                const cwd = workdirFor(testCase, workdirs);
+                let run;
+                if (testCase.automatedTestRef && cwd) {
+                    io.out(`  $ ${testCase.automatedTestRef}   (in ${cwd})`);
+                    run = await runAutomated(testCase.automatedTestRef, resolve(cwd), { echo: deps.echo });
+                    run = { ...run, note: redact(run.note, secrets), output: redact(run.output ?? '', secrets) };
+                }
+                else {
+                    const why = !testCase.automatedTestRef
+                        ? 'No test command'
+                        : `No --workdir ${testCase.repository ?? '<repository>'}=<dir> to run \`${testCase.automatedTestRef}\` in`;
+                    const answer = await askEngineer(io, testCase, why);
+                    run = { status: answer.status, note: answer.note };
+                }
+                statuses.push(run.status);
+                if (run.note)
+                    notes.push(run.note);
+                if (run.output !== undefined)
+                    output = run.output;
+            }
+            const status = combine(statuses);
+            io.out(`  → ${status}`);
+            io.out();
+            results.push({
+                caseUuid: testCase.uuid,
+                id: testCase.id,
+                status,
+                notes: summarize(status, steps, notes),
+                steps,
+                ...(output !== undefined ? { output } : {}),
+            });
+        }
+    }
+    finally {
+        await browser?.close().catch(() => { });
+    }
+    return { baseUrl: options.baseUrl, ranAt: new Date().toISOString(), results };
+}
+async function uploadScreenshot(api, saved, path) {
+    const bytes = await readFile(path);
+    const type = extname(path).toLowerCase() === '.png' ? 'image/png' : 'image/jpeg';
+    const form = new FormData();
+    form.append('file', new Blob([bytes], { type }), basename(path));
+    const uploaded = await api.request(`tickets/${saved.acceptance.ticket.uuid}/acceptance/screenshots`, {
+        method: 'POST',
+        form,
+        organization: saved.organizationUuid,
+    });
+    return uploaded.uuid;
+}
+export async function upload(api, saved, results, io) {
+    const screenshots = new Map();
+    const paths = [...new Set(results.results.flatMap((r) => r.steps.map((s) => s.screenshot)).filter((p) => Boolean(p)))];
+    if (paths.length > 0)
+        io.out(`Uploading ${paths.length} screenshot${paths.length === 1 ? '' : 's'}…`);
+    for (const path of paths) {
+        if (!existsSync(path)) {
+            io.out(`  Skipped ${path}: the file is gone.`);
+            continue;
+        }
+        if (statSync(path).size > MAX_SCREENSHOT_BYTES) {
+            io.out(`  Skipped ${path}: larger than 5 MB.`);
+            continue;
+        }
+        screenshots.set(path, await uploadScreenshot(api, saved, path));
+    }
+    const payload = buildResultsPayload(saved.acceptance.ticket.stateVersion, results.baseUrl, results.results, screenshots);
+    try {
+        return await api.request(`tickets/${saved.acceptance.ticket.uuid}/acceptance/results`, {
+            method: 'POST',
+            body: payload,
+            organization: saved.organizationUuid,
+        });
+    }
+    catch (error) {
+        if (error instanceof ApiError && error.status === 409) {
+            throw new CliError(`Sifur refused the results: ${error.message} The ticket has moved on since the cases were downloaded; run accept again.`);
+        }
+        throw error;
+    }
+}
+export function printSummary(io, results) {
+    io.out('Summary');
+    for (const result of results)
+        io.out(`  ${result.status.padEnd(7)}  ${result.id}`);
+    const overall = outcome(results);
+    const counts = ['passed', 'failed', 'blocked']
+        .map((status) => [status, results.filter((r) => r.status === status).length])
+        .filter(([, count]) => count > 0)
+        .map(([status, count]) => `${count} ${status}`);
+    io.out(`${overall === 'passed' ? 'Passed' : 'Not passed'}: ${counts.join(', ') || 'no cases'}`);
+    return overall;
+}
+export function ticketLink(consoleOrigin, ticketUuid) {
+    return consoleOrigin ? `${consoleOrigin.replace(/\/+$/, '')}/tickets/${ticketUuid}` : null;
+}
+/** The whole `accept` command; returns the exit code (0 all passed, 1 any not passed). Errors throw, for exit 2. */
+export async function accept(api, args, deps) {
+    const { io } = deps;
+    if (args.mode === 'download') {
+        if (!api)
+            throw new CliError('Run `sifur login` first.');
+        const saved = await download(api, args.ref);
+        const dir = await saveCases(args.cwd, saved);
+        describeDeploy(saved.acceptance, io);
+        io.out(`Saved to ${dir}. Run \`sifur accept ${saved.acceptance.ticket.key} --run --url <test url>\` next.`);
+        return 0;
+    }
+    if (args.mode === 'upload') {
+        if (!api)
+            throw new CliError('Run `sifur login` first.');
+        const dir = await findTicketDir(args.cwd, args.ref);
+        if (!dir)
+            throw new CliError(`Nothing downloaded for ${args.ref} in ${join(args.cwd, '.sifur')}.`);
+        const saved = await loadCases(dir);
+        if (saved.api !== api.base)
+            throw new CliError(`${args.ref} was downloaded from ${saved.api}, but you're signed in to ${api.base}.`);
+        const results = await loadResults(dir);
+        return finish(api, saved, results, args, io);
+    }
+    if (!args.url)
+        throw new CliError('--url <test url> is required: the test server the branch is deployed to.');
+    const baseUrl = parseBaseUrl(args.url);
+    let saved;
+    let dir;
+    if (args.mode === 'run') {
+        const found = await findTicketDir(args.cwd, args.ref);
+        if (!found)
+            throw new CliError(`Nothing downloaded for ${args.ref}. Run with --download first.`);
+        dir = found;
+        saved = await loadCases(dir);
+    }
+    else {
+        if (!api)
+            throw new CliError('Run `sifur login` first.');
+        saved = await download(api, args.ref);
+        dir = await saveCases(args.cwd, saved);
+    }
+    describeDeploy(saved.acceptance, io);
+    const results = await runCases(saved.acceptance, { baseUrl, outDir: join(dir, 'screenshots'), headed: args.headed, workdirs: args.workdirs }, deps);
+    const resultsPath = await saveResults(dir, results);
+    if (args.mode === 'run') {
+        const overall = printSummary(io, results.results);
+        io.out(`Saved to ${resultsPath}. Run \`sifur accept ${saved.acceptance.ticket.key} --upload\` to send them.`);
+        return overall === 'passed' ? 0 : 1;
+    }
+    try {
+        return await finish(api, saved, results, args, io);
+    }
+    catch (error) {
+        io.out(`The results are saved in ${resultsPath}; send them later with \`sifur accept ${saved.acceptance.ticket.key} --upload\`.`);
+        throw error;
+    }
+}
+async function finish(api, saved, results, args, io) {
+    const response = await upload(api, saved, results, io);
+    io.out();
+    const overall = printSummary(io, results.results);
+    if (response?.run)
+        io.out(`Recorded as run ${response.run.runNumber}: ${response.run.result}.`);
+    if (response?.state)
+        io.out(`The ticket is now in ${response.state.replaceAll('_', ' ')}.`);
+    const link = ticketLink(args.consoleOrigin, saved.acceptance.ticket.uuid);
+    if (link)
+        io.out(link);
+    return overall === 'passed' ? 0 : 1;
+}
+export function parseBaseUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (!['http:', 'https:'].includes(parsed.protocol))
+            throw new Error();
+        return parsed.toString();
+    }
+    catch {
+        throw new CliError(`--url ${url} isn't an http(s) URL.`);
+    }
+}

package/dist/api.js

@@ -0,0 +1,78 @@
+export const DEFAULT_API = 'https://api.sifur.ai';
+export class ApiError extends Error {
+    status;
+    code;
+    retryAfterSeconds;
+    constructor(message, status, code = null, retryAfterSeconds = null) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.retryAfterSeconds = retryAfterSeconds;
+        this.name = 'ApiError';
+    }
+}
+/** Something the engineer has to act on, printed without a stack trace. */
+export class CliError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CliError';
+    }
+}
+export function normalizeApi(api) {
+    return api.replace(/\/+$/, '');
+}
+export class Api {
+    token;
+    userAgent;
+    base;
+    constructor(base, token = null, userAgent = 'sifur-cli') {
+        this.token = token;
+        this.userAgent = userAgent;
+        this.base = normalizeApi(base);
+    }
+    withToken(token) {
+        return new Api(this.base, token, this.userAgent);
+    }
+    async request(path, options = {}) {
+        const headers = { Accept: 'application/json', 'User-Agent': this.userAgent };
+        if (this.token)
+            headers.Authorization = `Bearer ${this.token}`;
+        if (options.organization)
+            headers['X-Organization'] = options.organization;
+        let body;
+        if (options.form) {
+            body = options.form;
+        }
+        else if (options.body !== undefined) {
+            headers['Content-Type'] = 'application/json';
+            body = JSON.stringify(options.body);
+        }
+        let response;
+        try {
+            response = await fetch(`${this.base}/api/v1/${path.replace(/^\//, '')}`, {
+                method: options.method ?? (body === undefined ? 'GET' : 'POST'),
+                headers,
+                body,
+            });
+        }
+        catch (error) {
+            const cause = error.cause?.message;
+            throw new CliError(`Couldn't reach Sifur at ${this.base}${cause ? ` (${cause})` : ''}.`);
+        }
+        const text = await response.text();
+        let json = null;
+        try {
+            json = text ? JSON.parse(text) : null;
+        }
+        catch {
+            json = null;
+        }
+        if (!response.ok) {
+            const message = json?.message?.messages?.[0] ?? `Sifur answered ${response.status} ${response.statusText}`.trim();
+            const code = json?.code ?? json?.data?.code ?? null;
+            const retryAfter = Number(response.headers.get('retry-after'));
+            throw new ApiError(message, response.status, code, Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter : null);
+        }
+        return (json?.data ?? null);
+    }
+}

package/dist/automated.js

@@ -0,0 +1,28 @@
+import { spawn } from 'node:child_process';
+const TAIL_LINES = 5;
+export const MAX_OUTPUT_CHARS = 200_000;
+/** The case's test command in the engineer's checkout; its output streams to the terminal, its tail goes in the note. */
+export function runAutomated(command, cwd, options = {}) {
+    const echo = options.echo ?? ((chunk) => process.stdout.write(chunk));
+    return new Promise((resolve) => {
+        let output = '';
+        const child = spawn(command, { cwd, shell: true, stdio: ['ignore', 'pipe', 'pipe'] });
+        const collect = (chunk) => {
+            const text = chunk.toString();
+            echo(text);
+            output = (output + text).slice(-MAX_OUTPUT_CHARS);
+        };
+        child.stdout.on('data', collect);
+        child.stderr.on('data', collect);
+        child.on('error', (error) => resolve({ status: 'blocked', note: `\`${command}\` couldn't start in ${cwd}: ${error.message}` }));
+        child.on('close', (code, signal) => {
+            const tail = output.trimEnd().split('\n').slice(-TAIL_LINES).join('\n');
+            const ended = signal ? `was stopped by ${signal}` : `exited with ${code}`;
+            resolve({
+                status: code === 0 ? 'passed' : 'failed',
+                note: `\`${command}\` ${ended}.${tail ? `\n${tail}` : ''}`,
+                output,
+            });
+        });
+    });
+}

package/dist/bin.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { describeError, main } from './cli.js';
+import { terminalIo } from './io.js';
+const io = terminalIo();
+let code;
+try {
+    code = await main(process.argv.slice(2), io);
+}
+catch (error) {
+    process.stderr.write(`${describeError(error)}\n`);
+    code = 2;
+}
+finally {
+    io.close();
+}
+process.exit(code);

package/dist/browser.js

@@ -0,0 +1,16 @@
+import { chromium } from 'playwright-core';
+import { CliError } from './api.js';
+const CHANNELS = ['chrome', 'msedge'];
+/** The engineer's own Chrome, else Edge: playwright-core downloads no browser of its own. */
+export async function launchBrowser(options = {}) {
+    const failures = [];
+    for (const channel of CHANNELS) {
+        try {
+            return await chromium.launch({ channel, headless: !options.headed });
+        }
+        catch (error) {
+            failures.push(`${channel}: ${String(error.message ?? error).split('\n')[0]}`);
+        }
+    }
+    throw new CliError(`Couldn't start Google Chrome or Microsoft Edge. Install one of them (https://www.google.com/chrome/) and run this again.\n  ${failures.join('\n  ')}`);
+}

package/dist/cli.js

@@ -0,0 +1,123 @@
+import { readFileSync } from 'node:fs';
+import { parseArgs } from 'node:util';
+import { accept } from './accept.js';
+import { Api, ApiError, CliError, DEFAULT_API, normalizeApi } from './api.js';
+import { loadCredentials } from './config.js';
+import { login, logout } from './login.js';
+const USAGE = `Usage:
+  sifur login [--api <url>]
+  sifur logout
+  sifur accept <KEY|uuid> --url <test url> [--headed] [--workdir <repo>=<dir> …]
+  sifur accept <KEY|uuid> --download
+  sifur accept <KEY|uuid> --run --url <test url> [--headed] [--workdir <repo>=<dir> …]
+  sifur accept <KEY|uuid> --upload
+
+Options:
+  --api <url>              Sifur's API (default ${DEFAULT_API}, or SIFUR_API_URL)
+  --url <url>              Your test server, where the ticket's branch is deployed
+  --headed                 Show the browser while the cases run
+  --workdir <repo>=<dir>   Run that repository's automated cases in <dir>; repeatable
+  --download               Save the cases to ./.sifur/<KEY>/ (before a full-tunnel VPN is up)
+  --run                    Run the saved cases and save the results (no connection to Sifur)
+  --upload                 Send the saved results (after the VPN is down)
+
+Secrets: {{NAME}} in a case comes from SIFUR_SECRET_NAME, or is asked for. It never leaves this machine.
+Exit codes: 0 every case passed, 1 any case failed or was blocked, 2 an error.`;
+function version() {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+        return pkg.version;
+    }
+    catch {
+        return 'unknown';
+    }
+}
+export function parseWorkdirs(values) {
+    const workdirs = {};
+    for (const value of values) {
+        const at = value.indexOf('=');
+        if (at <= 0 || at === value.length - 1)
+            throw new CliError(`--workdir ${value}: expected <repository>=<dir>.`);
+        workdirs[value.slice(0, at)] = value.slice(at + 1);
+    }
+    return workdirs;
+}
+export async function main(argv, io, env = process.env, cwd = process.cwd()) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            api: { type: 'string' },
+            url: { type: 'string' },
+            headed: { type: 'boolean', default: false },
+            workdir: { type: 'string', multiple: true, default: [] },
+            download: { type: 'boolean', default: false },
+            run: { type: 'boolean', default: false },
+            upload: { type: 'boolean', default: false },
+            help: { type: 'boolean', short: 'h', default: false },
+            version: { type: 'boolean', short: 'v', default: false },
+        },
+    });
+    const [command, ...rest] = positionals;
+    if (values.version) {
+        io.out(version());
+        return 0;
+    }
+    if (values.help || !command || command === 'help') {
+        io.out(USAGE);
+        return command || values.help ? 0 : 2;
+    }
+    const explicitApi = values.api ?? env.SIFUR_API_URL;
+    const userAgent = `sifur-cli/${version()} node/${process.versions.node}`;
+    switch (command) {
+        case 'login': {
+            const api = new Api(explicitApi ?? DEFAULT_API, null, userAgent);
+            await login(api, { io, env });
+            return 0;
+        }
+        case 'logout':
+            await logout(io, env);
+            return 0;
+        case 'accept': {
+            const ref = rest[0];
+            if (!ref || rest.length > 1)
+                throw new CliError('Usage: sifur accept <KEY|uuid> --url <test url>');
+            const modes = ['download', 'run', 'upload'].filter((mode) => values[mode]);
+            if (modes.length > 1)
+                throw new CliError('Use one of --download, --run and --upload at a time.');
+            const mode = modes[0] ?? 'full';
+            const credentials = await loadCredentials(env);
+            let api = null;
+            if (mode !== 'run') {
+                if (!credentials)
+                    throw new CliError('Not signed in. Run `sifur login` first.');
+                if (explicitApi && normalizeApi(explicitApi) !== normalizeApi(credentials.api)) {
+                    throw new CliError(`You're signed in to ${credentials.api}, not ${explicitApi}. Run \`sifur login --api ${explicitApi}\`.`);
+                }
+                api = new Api(credentials.api, credentials.token, userAgent);
+            }
+            return accept(api, {
+                ref,
+                mode,
+                url: values.url,
+                headed: values.headed,
+                workdirs: parseWorkdirs(values.workdir ?? []),
+                cwd,
+                consoleOrigin: env.SIFUR_CONSOLE_URL ?? credentials?.console ?? null,
+            }, { io, env });
+        }
+        default:
+            throw new CliError(`Unknown command "${command}".\n\n${USAGE}`);
+    }
+}
+export function describeError(error) {
+    if (error instanceof ApiError && error.status === 401)
+        return 'Your sign-in has expired or was revoked. Run `sifur login` again.';
+    if (error instanceof ApiError)
+        return `Sifur answered ${error.status}: ${error.message}`;
+    if (error instanceof CliError)
+        return error.message;
+    if (error instanceof TypeError && error.code?.startsWith('ERR_PARSE_ARGS'))
+        return `${error.message}\n\n${USAGE}`;
+    return error instanceof Error ? (error.stack ?? error.message) : String(error);
+}

package/dist/config.js

@@ -0,0 +1,33 @@
+import { chmod, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export function configDir(env = process.env, platform = process.platform) {
+    if (env.SIFUR_CONFIG_DIR)
+        return env.SIFUR_CONFIG_DIR;
+    if (platform === 'win32')
+        return join(env.APPDATA ?? join(homedir(), 'AppData', 'Roaming'), 'sifur');
+    return join(env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'sifur');
+}
+export function credentialsPath(env = process.env) {
+    return join(configDir(env), 'credentials.json');
+}
+export async function loadCredentials(env = process.env) {
+    try {
+        const parsed = JSON.parse(await readFile(credentialsPath(env), 'utf8'));
+        return parsed.api && parsed.token ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveCredentials(credentials, env = process.env) {
+    const path = credentialsPath(env);
+    await mkdir(configDir(env), { recursive: true, mode: 0o700 });
+    await writeFile(path, `${JSON.stringify(credentials, null, 2)}\n`, { mode: 0o600 });
+    // writeFile's mode only applies when it creates the file; an older one keeps its own.
+    await chmod(path, 0o600);
+    return path;
+}
+export async function deleteCredentials(env = process.env) {
+    await rm(credentialsPath(env), { force: true });
+}

package/dist/io.js

@@ -0,0 +1,96 @@
+import { createInterface } from 'node:readline';
+import { Writable } from 'node:stream';
+import { CliError } from './api.js';
+/**
+ * The terminal: one readline over stdin for every question, muted while a secret is typed. Lines are
+ * queued as they arrive, because piped input arrives all at once, before most questions are asked.
+ */
+export function terminalIo() {
+    let muted = false;
+    let rl = null;
+    let ended = false;
+    const lines = [];
+    const waiting = [];
+    const output = new Writable({
+        write(chunk, encoding, callback) {
+            if (!muted)
+                process.stdout.write(chunk, encoding);
+            callback();
+        },
+    });
+    const inputEnded = () => new CliError('Input ended before every question was answered.');
+    function readline() {
+        if (!rl) {
+            rl = createInterface({ input: process.stdin, output, terminal: Boolean(process.stdin.isTTY) });
+            rl.on('line', (line) => {
+                const next = waiting.shift();
+                if (next)
+                    next.resolve(line);
+                else
+                    lines.push(line);
+            });
+            // In terminal mode readline swallows Ctrl-C; without this it would pause instead of quitting.
+            rl.on('SIGINT', () => {
+                rl?.close();
+                process.stdout.write('\n');
+                process.exit(130);
+            });
+            rl.on('close', () => {
+                ended = true;
+                for (const next of waiting.splice(0))
+                    next.reject(inputEnded());
+            });
+        }
+        return rl;
+    }
+    function nextLine() {
+        readline();
+        const queued = lines.shift();
+        if (queued !== undefined)
+            return Promise.resolve(queued);
+        if (ended)
+            return Promise.reject(inputEnded());
+        return new Promise((resolve, reject) => waiting.push({ resolve, reject }));
+    }
+    function question(prompt) {
+        const reader = readline();
+        reader.setPrompt(prompt);
+        reader.prompt();
+        return nextLine();
+    }
+    return {
+        out: (line = '') => void process.stdout.write(`${line}\n`),
+        ask: (prompt) => question(prompt),
+        async askHidden(prompt) {
+            const reader = readline();
+            process.stdout.write(prompt);
+            reader.setPrompt('');
+            muted = true;
+            try {
+                return await nextLine();
+            }
+            finally {
+                muted = false;
+                process.stdout.write('\n');
+            }
+        },
+        close: () => rl?.close(),
+    };
+}
+export async function confirm(io, prompt) {
+    for (;;) {
+        const answer = (await io.ask(`${prompt} [y/n] `)).trim().toLowerCase();
+        if (['y', 'yes'].includes(answer))
+            return true;
+        if (['n', 'no'].includes(answer))
+            return false;
+    }
+}
+export async function askStatus(io, prompt) {
+    const choices = { p: 'passed', passed: 'passed', f: 'failed', failed: 'failed', b: 'blocked', blocked: 'blocked' };
+    for (;;) {
+        const answer = choices[(await io.ask(`${prompt} [p]assed / [f]ailed / [b]locked: `)).trim().toLowerCase()];
+        if (answer)
+            return answer;
+    }
+}

package/dist/login.js

@@ -0,0 +1,112 @@
+import { spawn } from 'node:child_process';
+import { hostname, userInfo } from 'node:os';
+import { Api, ApiError, CliError } from './api.js';
+import { deleteCredentials, loadCredentials, saveCredentials } from './config.js';
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export function openInBrowser(url) {
+    const [command, args] = process.platform === 'darwin'
+        ? ['open', [url]]
+        : process.platform === 'win32'
+            ? ['cmd', ['/c', 'start', '""', url]]
+            : ['xdg-open', [url]];
+    try {
+        const child = spawn(command, args, { stdio: 'ignore', detached: true });
+        child.on('error', () => { });
+        child.unref();
+    }
+    catch {
+        // The URL is printed too; a machine without a browser just doesn't open one.
+    }
+}
+export function defaultClientName() {
+    let user = '';
+    try {
+        user = userInfo().username;
+    }
+    catch {
+        user = '';
+    }
+    return user ? `${user}@${hostname()}` : hostname();
+}
+export function withCode(verificationUrl, userCode) {
+    try {
+        const url = new URL(verificationUrl);
+        if (!url.searchParams.has('code'))
+            url.searchParams.set('code', userCode);
+        return url.toString();
+    }
+    catch {
+        return verificationUrl;
+    }
+}
+export async function login(api, deps) {
+    const { io } = deps;
+    const sleep = deps.sleep ?? wait;
+    const now = deps.now ?? Date.now;
+    const start = await api.request('auth/device', {
+        method: 'POST',
+        body: { clientName: (deps.clientName ?? defaultClientName()).slice(0, 100) },
+    });
+    const url = withCode(start.verificationUrl, start.userCode);
+    io.out(`Your code: ${start.userCode}`);
+    io.out(`Approve it at ${url}`);
+    io.out('Waiting for approval…');
+    (deps.openBrowser ?? openInBrowser)(url);
+    let interval = Math.max(1, start.interval ?? 5) * 1000;
+    const deadline = now() + (start.expiresIn ?? 600) * 1000;
+    for (;;) {
+        await sleep(interval);
+        try {
+            const granted = await api.request('auth/device/token', {
+                method: 'POST',
+                body: { deviceCode: start.deviceCode },
+            });
+            let consoleOrigin = null;
+            try {
+                consoleOrigin = new URL(start.verificationUrl).origin;
+            }
+            catch {
+                consoleOrigin = null;
+            }
+            const credentials = { api: api.base, token: granted.token, console: consoleOrigin };
+            const path = await saveCredentials(credentials, deps.env);
+            const who = granted.user?.email ?? granted.user?.name;
+            io.out(`Signed in${who ? ` as ${who}` : ''}. Saved to ${path}.`);
+            return credentials;
+        }
+        catch (error) {
+            if (!(error instanceof ApiError))
+                throw error;
+            if (error.code === 'authorization_pending' || error.status === 428) {
+                if (now() >= deadline)
+                    throw new CliError('The code expired before it was approved. Run `sifur login` again.');
+                continue;
+            }
+            if (error.status === 429 || error.code === 'slow_down') {
+                interval = Math.max(interval + 5000, (error.retryAfterSeconds ?? 0) * 1000);
+                continue;
+            }
+            if (error.code === 'access_denied' || error.status === 403)
+                throw new CliError('The sign-in was denied.');
+            if (error.code === 'expired_token' || error.status === 410) {
+                throw new CliError('The code expired before it was approved. Run `sifur login` again.');
+            }
+            throw error;
+        }
+    }
+}
+export async function logout(io, env = process.env) {
+    const credentials = await loadCredentials(env);
+    if (!credentials) {
+        io.out('Not signed in.');
+        return;
+    }
+    try {
+        await new Api(credentials.api, credentials.token).request('account/logout', { method: 'POST' });
+    }
+    catch {
+        // The session may already be revoked or Sifur unreachable; the local token goes either way.
+    }
+    await deleteCredentials(env);
+    io.out('Signed out.');
+}

package/dist/resolve.js

@@ -0,0 +1,35 @@
+import { ApiError, CliError } from './api.js';
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const KEY = /^([A-Za-z][A-Za-z0-9]*)-(\d+)$/;
+export function parseTicketRef(ref) {
+    if (UUID.test(ref))
+        return { uuid: ref.toLowerCase() };
+    const match = KEY.exec(ref);
+    if (!match)
+        throw new CliError(`"${ref}" is neither a ticket key (like AZA-12) nor a ticket uuid.`);
+    return { projectKey: match[1].toUpperCase(), number: Number(match[2]) };
+}
+/** Asks each of the person's organizations in turn; the first that has the ticket scopes every later call. */
+export async function resolveTicket(api, ref) {
+    const parsed = parseTicketRef(ref);
+    const organizations = (await api.request('account/organizations')) ?? [];
+    if (organizations.length === 0)
+        throw new CliError('Your account is not in any organization.');
+    const path = 'uuid' in parsed
+        ? `tickets/${parsed.uuid}`
+        : `ticket-links/${encodeURIComponent(parsed.projectKey)}/${parsed.number}`;
+    for (const organization of organizations) {
+        try {
+            const ticket = await api.request(path, { organization: organization.uuid });
+            if (!ticket?.uuid)
+                throw new CliError(`Sifur found ${ref} but didn't say which ticket it is.`);
+            return { ticketUuid: ticket.uuid, organization };
+        }
+        catch (error) {
+            if (error instanceof ApiError && [403, 404].includes(error.status))
+                continue;
+            throw error;
+        }
+    }
+    throw new CliError(`No ticket ${ref} in your organizations (${organizations.map((o) => o.name).join(', ')}).`);
+}

package/dist/results.js

@@ -0,0 +1,32 @@
+/** `screenshots` maps a local screenshot path to the uuid its upload returned. */
+export function buildResultsPayload(stateVersion, baseUrl, results, screenshots) {
+    return {
+        stateVersion,
+        via: 'cli',
+        baseUrl,
+        results: results.map((result) => ({
+            caseUuid: result.caseUuid,
+            status: result.status,
+            notes: result.notes,
+            steps: result.steps.map((step) => ({
+                n: step.n,
+                caption: step.caption,
+                ok: step.ok,
+                error: step.error,
+                screenshotUuid: step.screenshot ? (screenshots.get(step.screenshot) ?? null) : null,
+            })),
+            ...(result.output !== undefined ? { output: result.output } : {}),
+        })),
+    };
+}
+/** Failed outranks blocked: a case that both failed a check and couldn't finish another still failed. */
+export function combine(statuses) {
+    if (statuses.includes('failed'))
+        return 'failed';
+    if (statuses.includes('blocked'))
+        return 'blocked';
+    return 'passed';
+}
+export function outcome(results) {
+    return combine(results.map((result) => result.status));
+}

package/dist/runner.js

@@ -0,0 +1,130 @@
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { redact, withSecrets } from './secrets.js';
+const ASSERTIONS = new Set(['expectText', 'expectVisible', 'expectUrl']);
+const TIMEOUT = 15_000;
+// An assertion after an action waits for the page to settle, as Playwright's own do: a
+// response that lands half a second later still counts.
+export async function eventually(check, timeoutMs = 10_000) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        try {
+            return await check();
+        }
+        catch (error) {
+            if (Date.now() >= deadline)
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, 250));
+        }
+    }
+}
+function first(page, selector) {
+    if (!selector)
+        throw new Error('the step has no selector');
+    return page.locator(selector).first();
+}
+async function perform(page, step, baseUrl, secrets, settleMs) {
+    const url = step.url ? new URL(step.url, baseUrl).toString() : null;
+    switch (step.action) {
+        case 'goto':
+            if (!url)
+                throw new Error('the step has no url');
+            await page.goto(url, { waitUntil: 'networkidle' });
+            break;
+        case 'click':
+            await first(page, step.selector).click();
+            break;
+        case 'fill':
+            await first(page, step.selector).fill(withSecrets(String(step.value ?? ''), secrets));
+            break;
+        case 'press':
+            await first(page, step.selector).press(String(step.value));
+            break;
+        case 'select':
+            await first(page, step.selector).selectOption(String(step.value));
+            break;
+        case 'wait':
+            await page.waitForTimeout(Math.min(Number(step.value ?? 500), 10_000));
+            break;
+        case 'expectText': {
+            const target = step.selector ? page.locator(step.selector).first() : page.locator('body');
+            await target.waitFor();
+            await eventually(async () => {
+                const text = await target.innerText();
+                if (!text.includes(String(step.text)))
+                    throw new Error(`expected "${step.text}" in ${step.selector ?? 'the page'}`);
+            }, settleMs);
+            break;
+        }
+        case 'expectVisible':
+            await first(page, step.selector).waitFor({ state: 'visible' });
+            break;
+        case 'expectUrl':
+            await eventually(async () => {
+                if (!page.url().includes(String(step.text))) {
+                    throw new Error(`expected the URL to contain "${step.text}", got ${page.url()}`);
+                }
+            }, settleMs);
+            break;
+        case 'judge':
+            break;
+        default:
+            throw new Error(`unknown action ${step.action}`);
+    }
+}
+/** One case's UI script, as the sandbox's runner plays it: a screenshot after every step, stopping at the first failure. */
+export async function runUiCase(browser, testCase, options) {
+    const secrets = options.secrets ?? {};
+    const dir = join(options.outDir, testCase.id);
+    await mkdir(dir, { recursive: true });
+    // Light, always: an app that follows the system theme is judged in one, the same every run.
+    const context = await browser.newContext({ viewport: { width: 1440, height: 900 }, colorScheme: 'light' });
+    const page = await context.newPage();
+    page.setDefaultTimeout(options.timeoutMs ?? TIMEOUT);
+    const steps = [];
+    const notes = [];
+    let status = 'passed';
+    try {
+        for (const [index, step] of (testCase.uiScript ?? []).entries()) {
+            const n = index + 1;
+            const caption = step.caption ?? step.action;
+            let ok = true;
+            let error = null;
+            try {
+                await perform(page, step, options.baseUrl, secrets, Math.min(10_000, options.timeoutMs ?? 10_000));
+            }
+            catch (caught) {
+                ok = false;
+                error = redact(String(caught?.message ?? caught).split('\n')[0] ?? '', secrets);
+            }
+            let screenshot = join(dir, `${String(n).padStart(2, '0')}.png`);
+            await page.screenshot({ path: screenshot, fullPage: true }).catch(() => {
+                screenshot = null;
+            });
+            let judged = false;
+            if (ok && step.action === 'judge') {
+                const answer = await options.judge(step, screenshot, testCase);
+                judged = true;
+                if (answer.note)
+                    notes.push(`Step ${n} (${caption}): ${answer.note}`);
+                if (!answer.ok) {
+                    ok = false;
+                    error = answer.note ? `The engineer judged it wrong: ${answer.note}` : 'The engineer judged it wrong.';
+                }
+            }
+            steps.push({ n, action: step.action, caption, ok, error, screenshot });
+            if (!ok) {
+                // A failed assertion (or a judged screenshot that's wrong) is a failed case; anything
+                // failing before it means the case couldn't be run as written, so it's blocked.
+                status = ASSERTIONS.has(step.action) || judged ? 'failed' : 'blocked';
+                if (!judged)
+                    notes.push(`Step ${n} (${caption}): ${error}`);
+                break;
+            }
+        }
+    }
+    finally {
+        await context.close().catch(() => { });
+    }
+    return { status, steps, notes };
+}

package/dist/secrets.js

@@ -0,0 +1,32 @@
+const PLACEHOLDER = /\{\{([A-Z][A-Z0-9_]*)\}\}/g;
+export function secretNames(cases) {
+    const names = new Set();
+    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]);
+        }
+    }
+    return [...names].sort();
+}
+/** 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) {
+    const secrets = {};
+    for (const name of names) {
+        const fromEnv = env[`SIFUR_SECRET_${name}`];
+        secrets[name] = fromEnv !== undefined ? fromEnv : await io.askHidden(`${name} (or set SIFUR_SECRET_${name}): `);
+    }
+    return secrets;
+}
+export function withSecrets(value, secrets) {
+    return value.replace(PLACEHOLDER, (match, name) => secrets[name] ?? match);
+}
+export function redact(text, secrets) {
+    let redacted = text;
+    for (const value of Object.values(secrets))
+        if (value)
+            redacted = redacted.replaceAll(value, '[secret]');
+    return redacted;
+}

package/dist/store.js

@@ -0,0 +1,70 @@
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { CliError } from './api.js';
+export const STORE = '.sifur';
+export function ticketDir(root, key) {
+    return join(root, STORE, key.replace(/[^A-Za-z0-9_-]/g, '_'));
+}
+export async function saveCases(root, saved) {
+    const dir = ticketDir(root, saved.acceptance.ticket.key);
+    await mkdir(dir, { recursive: true });
+    await writeFile(join(dir, 'cases.json'), `${JSON.stringify(saved, null, 2)}\n`);
+    return dir;
+}
+function mapScreenshots(results, map) {
+    return {
+        ...results,
+        results: results.results.map((result) => ({
+            ...result,
+            steps: result.steps.map((step) => ({ ...step, screenshot: step.screenshot ? map(step.screenshot) : null })),
+        })),
+    };
+}
+/** Screenshot paths are kept relative to the ticket's folder, so the folder can move between --run and --upload. */
+export async function saveResults(dir, results) {
+    const path = join(dir, 'results.json');
+    const portable = mapScreenshots(results, (screenshot) => (isAbsolute(screenshot) ? relative(dir, screenshot) : screenshot));
+    await writeFile(path, `${JSON.stringify(portable, null, 2)}\n`);
+    return path;
+}
+async function readJson(path) {
+    try {
+        return JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw new CliError(`${path} isn't readable JSON: ${error.message}`);
+    }
+}
+/** A key names its folder; a uuid is looked for among the downloaded tickets. */
+export async function findTicketDir(root, ref) {
+    const direct = ticketDir(root, ref.toUpperCase());
+    if (await readJson(join(direct, 'cases.json')))
+        return direct;
+    let entries;
+    try {
+        entries = await readdir(join(root, STORE));
+    }
+    catch {
+        return null;
+    }
+    for (const entry of entries) {
+        const saved = await readJson(join(root, STORE, entry, 'cases.json'));
+        if (saved?.acceptance.ticket.uuid === ref.toLowerCase())
+            return join(root, STORE, entry);
+    }
+    return null;
+}
+export async function loadCases(dir) {
+    const saved = await readJson(join(dir, 'cases.json'));
+    if (!saved)
+        throw new CliError(`No downloaded cases in ${dir}. Run with --download first.`);
+    return saved;
+}
+export async function loadResults(dir) {
+    const saved = await readJson(join(dir, 'results.json'));
+    if (!saved)
+        throw new CliError(`No results in ${dir}. Run with --run first.`);
+    return mapScreenshots(saved, (screenshot) => resolve(dir, screenshot));
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,40 @@
 {
   "name": "@sifurai/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Run a Sifur ticket's acceptance cases against your own test server and upload the results.",
+  "license": "UNLICENSED",
+  "homepage": "https://sifur.ai",
+  "keywords": [
+    "sifur",
+    "acceptance-testing",
+    "cli"
+  ],
+  "type": "module",
+  "bin": {
+    "sifur": "dist/bin.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "playwright-core": "^1.64.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.43",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.7"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}