@affix-io/cli 1.2.4

package/dist/repl.js

@@ -0,0 +1,347 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { generateBarcode, generateQr, generateTicketCode, listSymbologies, openCode, printCodeEntry, printCodesList, removeCode, scanCode, showCode, } from "./codes.js";
+import { addOutputLocation, printLocations, removeOutputLocation, setDefaultOutputLocation, } from "./settings.js";
+import { runAuthCheck, runCircuits, runHealth, runLogin, runLogout, runProve, runVerify, runWhoami, } from "./commands-core.js";
+const BANNER = `
+AffixIO CLI
+───────────
+Merkle-backed QR · barcode · scan · vault
+Type help for commands, exit to quit.
+`.trim();
+export const HELP = `
+Commands
+  help                         Show this list
+  whoami                       Account on this machine
+  health                       API health check
+  auth                         Verify API key
+  circuits                     List circuits
+  prove [circuit]              Demo prove
+  verify <proof> [circuit]     Verify a proof
+
+  location list                Output directories
+  location add <name> <path>   Add output directory
+  location default <name>      Set default output
+
+  qr <text|url> [--scans N --event <slug>] [--location <name>] [--short]
+  qr ticket --event <slug> [--scans N]
+  barcode <data> [--type sym] [--scans N --event <slug>]
+  scan <id|token|code>         Merkle-audited scan
+  codes                        List local vault
+  show <id>                    Show stored code metadata
+  open <id>                    Open SVG in default app
+  rm <id>                      Remove from local vault
+  symbologies                  List barcode types
+
+  login                        Re-authenticate via cli/verify
+  logout                       Sign out
+  exit                         Quit
+`.trim();
+function parseFlags(args) {
+    const positional = [];
+    const flags = {};
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a.startsWith("--")) {
+            const key = a.slice(2);
+            const next = args[i + 1];
+            if (next && !next.startsWith("--")) {
+                flags[key] = next;
+                i++;
+            }
+            else {
+                flags[key] = true;
+            }
+        }
+        else {
+            positional.push(a);
+        }
+    }
+    return { positional, flags };
+}
+function genOpts(flags) {
+    const scansRaw = flags.scans ?? flags["max-uses"];
+    let maxUses;
+    if (typeof scansRaw === "string") {
+        const n = Number(scansRaw);
+        if (Number.isFinite(n) && n >= 1)
+            maxUses = Math.floor(n);
+    }
+    return {
+        both: Boolean(flags.png),
+        label: typeof flags.label === "string" ? flags.label : undefined,
+        location: typeof flags.location === "string" ? flags.location : undefined,
+        out: typeof flags.out === "string" ? flags.out : undefined,
+        maxUses,
+        event: typeof flags.event === "string" ? flags.event : undefined,
+        holder: typeof flags.holder === "string" ? flags.holder : undefined,
+        seat: typeof flags.seat === "string" ? flags.seat : undefined,
+        tier: typeof flags.tier === "string" ? flags.tier : undefined,
+        shortLink: Boolean(flags.short),
+    };
+}
+function requireSignedIn(localMode) {
+    if (localMode) {
+        console.error("Sign in required. Run: login");
+        return false;
+    }
+    return true;
+}
+async function prompt(rl, label, fallback = "") {
+    const answer = (await rl.question(`${label}: `)).trim();
+    return answer || fallback;
+}
+async function interactiveQr(rl, creds) {
+    const content = await prompt(rl, "QR content (text or URL)");
+    if (!content) {
+        console.error("Content required.");
+        return;
+    }
+    const entry = await generateQr(creds, content, {});
+    printCodeEntry(entry);
+}
+async function interactiveBarcode(rl, creds) {
+    const content = await prompt(rl, "Barcode data");
+    if (!content) {
+        console.error("Data required.");
+        return;
+    }
+    const sym = await prompt(rl, "Symbology", "code128");
+    const entry = await generateBarcode(creds, content, { symbology: sym });
+    printCodeEntry(entry);
+}
+async function dispatchLine(line, creds, api, rl) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return "continue";
+    const parts = trimmed.match(/(?:[^\s"]+|"[^"]*")+/g) ?? [];
+    const tokens = parts.map((p) => p.replace(/^"|"$/g, ""));
+    const [cmd, ...rest] = tokens;
+    const localMode = creds.email === "local" || !creds.api_key;
+    switch (cmd.toLowerCase()) {
+        case "help":
+        case "?":
+            console.log(HELP);
+            break;
+        case "exit":
+        case "quit":
+            return "exit";
+        case "whoami":
+            if (localMode) {
+                console.error("Not signed in. Run: login");
+                break;
+            }
+            runWhoami(creds);
+            break;
+        case "health":
+            if (localMode) {
+                console.error("Sign in required. Run: login");
+                break;
+            }
+            await runHealth(api);
+            break;
+        case "auth":
+            if (localMode) {
+                console.error("Sign in required. Run: login");
+                break;
+            }
+            await runAuthCheck(api);
+            break;
+        case "circuits":
+            if (localMode) {
+                console.error("Sign in required. Run: login");
+                break;
+            }
+            await runCircuits(api);
+            break;
+        case "prove":
+            if (localMode) {
+                console.error("Sign in required. Run: login");
+                break;
+            }
+            await runProve(api, rest[0] ?? "ticket_local_resident");
+            break;
+        case "verify":
+            if (localMode) {
+                console.error("Sign in required. Run: login");
+                break;
+            }
+            if (!rest[0]) {
+                console.error("Usage: verify <proof> [circuit]");
+                break;
+            }
+            await runVerify(api, rest[1] ?? "ticket_local_resident", rest[0]);
+            break;
+        case "location":
+        case "locations": {
+            const sub = rest[0]?.toLowerCase();
+            if (!sub || sub === "list") {
+                printLocations();
+                break;
+            }
+            if (sub === "add" && rest[1] && rest[2]) {
+                const entry = addOutputLocation(rest[1], rest[2]);
+                console.log(`Added "${entry.name}" → ${entry.path}`);
+                break;
+            }
+            if (sub === "default" && rest[1]) {
+                setDefaultOutputLocation(rest[1]);
+                console.log(`Default output: ${rest[1]}`);
+                break;
+            }
+            if ((sub === "rm" || sub === "remove") && rest[1]) {
+                removeOutputLocation(rest[1]);
+                console.log(`Removed location "${rest[1]}".`);
+                break;
+            }
+            printLocations();
+            break;
+        }
+        case "scan": {
+            if (!requireSignedIn(localMode))
+                break;
+            if (!rest[0]) {
+                console.error("Usage: scan <id|token|code>");
+                break;
+            }
+            const { flags } = parseFlags(rest.slice(1));
+            const result = await scanCode(creds, rest[0], {
+                event: typeof flags.event === "string" ? flags.event : undefined,
+                entryPoint: typeof flags.gate === "string"
+                    ? flags.gate
+                    : typeof flags.entry === "string"
+                        ? flags.entry
+                        : undefined,
+                id: /^[a-f0-9]{6,}$/i.test(rest[0]) ? rest[0] : undefined,
+            });
+            console.log(JSON.stringify(result, null, 2));
+            break;
+        }
+        case "qr": {
+            if (!requireSignedIn(localMode))
+                break;
+            const { positional, flags } = parseFlags(rest);
+            const opts = genOpts(flags);
+            if (positional[0] === "ticket") {
+                const event = String(flags.event ?? positional[1] ?? "");
+                if (!event) {
+                    const slug = await prompt(rl, "Event slug");
+                    if (!slug)
+                        break;
+                    const entry = await generateTicketCode(creds, {
+                        event: slug,
+                        holder: opts.holder,
+                        seat: opts.seat,
+                        tier: opts.tier,
+                        maxUses: opts.maxUses,
+                    }, opts);
+                    printCodeEntry(entry);
+                    break;
+                }
+                const entry = await generateTicketCode(creds, {
+                    event,
+                    holder: opts.holder,
+                    seat: opts.seat,
+                    tier: opts.tier,
+                    maxUses: opts.maxUses,
+                }, opts);
+                printCodeEntry(entry);
+                break;
+            }
+            const content = positional.join(" ");
+            if (!content) {
+                await interactiveQr(rl, creds);
+                break;
+            }
+            const entry = await generateQr(creds, content, opts);
+            printCodeEntry(entry);
+            break;
+        }
+        case "barcode": {
+            if (!requireSignedIn(localMode))
+                break;
+            const { positional, flags } = parseFlags(rest);
+            const sym = typeof flags.type === "string" ? flags.type : "code128";
+            const content = positional.join(" ");
+            if (!content) {
+                await interactiveBarcode(rl, creds);
+                break;
+            }
+            const entry = await generateBarcode(creds, content, {
+                ...genOpts(flags),
+                symbology: sym,
+            });
+            printCodeEntry(entry);
+            break;
+        }
+        case "codes":
+        case "ls":
+            printCodesList();
+            break;
+        case "show":
+            if (!rest[0]) {
+                console.error("Usage: show <id>");
+                break;
+            }
+            showCode(rest[0]);
+            break;
+        case "open":
+            if (!rest[0]) {
+                console.error("Usage: open <id>");
+                break;
+            }
+            openCode(rest[0]);
+            break;
+        case "rm":
+        case "delete":
+            if (!rest[0]) {
+                console.error("Usage: rm <id>");
+                break;
+            }
+            removeCode(rest[0]);
+            break;
+        case "symbologies": {
+            if (!requireSignedIn(localMode))
+                break;
+            const list = await listSymbologies(creds);
+            console.log(list.join(", "));
+            break;
+        }
+        case "login":
+            await runLogin();
+            break;
+        case "logout":
+            runLogout();
+            return "exit";
+        default:
+            console.log(`Unknown command: ${cmd}. Type help.`);
+    }
+    return "continue";
+}
+export async function runRepl(creds, api) {
+    const rl = createInterface({ input, output, terminal: true });
+    const localMode = creds.email === "local" || !creds.api_key;
+    console.log(BANNER);
+    if (localMode) {
+        console.log("Not signed in · run login for Merkle-backed codes\n");
+    }
+    else {
+        console.log(`Signed in as ${creds.email}\n`);
+    }
+    try {
+        while (true) {
+            const line = await rl.question("affix› ");
+            try {
+                const next = await dispatchLine(line, creds, api, rl);
+                if (next === "exit")
+                    return;
+            }
+            catch (err) {
+                console.error(err instanceof Error ? err.message : String(err));
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/settings.d.ts

@@ -0,0 +1,23 @@
+export interface OutputLocation {
+    name: string;
+    path: string;
+}
+export interface AffixSettings {
+    output_locations: OutputLocation[];
+    default_output?: string;
+}
+export declare function settingsPath(): string;
+export declare function loadSettings(): AffixSettings;
+export declare function saveSettings(settings: AffixSettings): void;
+export declare function listOutputLocations(): OutputLocation[];
+export declare function addOutputLocation(name: string, dirPath: string): OutputLocation;
+export declare function removeOutputLocation(name: string): void;
+export declare function setDefaultOutputLocation(name: string): void;
+export declare function resolveOutputDir(opts?: {
+    location?: string;
+    out?: string;
+}): {
+    name: string;
+    path: string;
+};
+export declare function printLocations(): void;

package/dist/settings.js

@@ -0,0 +1,116 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
+import { join, resolve } from "node:path";
+import { affixDir, codesDir } from "./config.js";
+const SETTINGS_PATH = join(affixDir(), "settings.json");
+const DEFAULT_LOCATION = "default";
+function defaultSettings() {
+    return {
+        output_locations: [{ name: DEFAULT_LOCATION, path: codesDir() }],
+        default_output: DEFAULT_LOCATION,
+    };
+}
+export function settingsPath() {
+    return SETTINGS_PATH;
+}
+export function loadSettings() {
+    mkdirSync(affixDir(), { recursive: true, mode: 0o700 });
+    if (!existsSync(SETTINGS_PATH)) {
+        const defaults = defaultSettings();
+        saveSettings(defaults);
+        return defaults;
+    }
+    try {
+        const raw = readFileSync(SETTINGS_PATH, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed.output_locations) || !parsed.output_locations.length) {
+            return defaultSettings();
+        }
+        return parsed;
+    }
+    catch {
+        return defaultSettings();
+    }
+}
+export function saveSettings(settings) {
+    mkdirSync(affixDir(), { recursive: true, mode: 0o700 });
+    writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n", {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    chmodSync(affixDir(), 0o700);
+}
+export function listOutputLocations() {
+    return loadSettings().output_locations;
+}
+export function addOutputLocation(name, dirPath) {
+    const trimmedName = name.trim().toLowerCase();
+    const abs = resolve(dirPath.trim());
+    if (!trimmedName)
+        throw new Error("Location name is required.");
+    if (!abs)
+        throw new Error("Path is required.");
+    const settings = loadSettings();
+    if (settings.output_locations.some((l) => l.name === trimmedName)) {
+        throw new Error(`Location "${trimmedName}" already exists.`);
+    }
+    mkdirSync(abs, { recursive: true, mode: 0o700 });
+    chmodSync(abs, 0o700);
+    const entry = { name: trimmedName, path: abs };
+    settings.output_locations.push(entry);
+    if (!settings.default_output) {
+        settings.default_output = trimmedName;
+    }
+    saveSettings(settings);
+    return entry;
+}
+export function removeOutputLocation(name) {
+    const trimmedName = name.trim().toLowerCase();
+    const settings = loadSettings();
+    const remaining = settings.output_locations.filter((l) => l.name !== trimmedName);
+    if (remaining.length === settings.output_locations.length) {
+        throw new Error(`No location named "${trimmedName}".`);
+    }
+    if (remaining.length === 0) {
+        throw new Error("Cannot remove the last output location.");
+    }
+    if (settings.default_output === trimmedName) {
+        settings.default_output = remaining[0]?.name;
+    }
+    settings.output_locations = remaining;
+    saveSettings(settings);
+}
+export function setDefaultOutputLocation(name) {
+    const trimmedName = name.trim().toLowerCase();
+    const settings = loadSettings();
+    if (!settings.output_locations.some((l) => l.name === trimmedName)) {
+        throw new Error(`No location named "${trimmedName}".`);
+    }
+    settings.default_output = trimmedName;
+    saveSettings(settings);
+}
+export function resolveOutputDir(opts) {
+    if (opts?.out) {
+        const abs = resolve(opts.out.trim());
+        mkdirSync(abs, { recursive: true, mode: 0o700 });
+        chmodSync(abs, 0o700);
+        return { name: "_custom", path: abs };
+    }
+    const settings = loadSettings();
+    const wanted = (opts?.location ?? settings.default_output ?? DEFAULT_LOCATION).trim().toLowerCase();
+    const found = settings.output_locations.find((l) => l.name === wanted);
+    if (!found) {
+        throw new Error(`Unknown output location "${wanted}". Add one with: affix location add <name> <path>`);
+    }
+    mkdirSync(found.path, { recursive: true, mode: 0o700 });
+    chmodSync(found.path, 0o700);
+    return found;
+}
+export function printLocations() {
+    const settings = loadSettings();
+    console.log(`Settings: ${SETTINGS_PATH}\n`);
+    for (const loc of settings.output_locations) {
+        const mark = loc.name === settings.default_output ? " (default)" : "";
+        console.log(`  ${loc.name}${mark}`);
+        console.log(`    ${loc.path}`);
+    }
+}

package/dist/site-api.d.ts

@@ -0,0 +1,8 @@
+import type { AffixCredentials } from "./config.js";
+export declare function cliApiBase(creds: AffixCredentials): string;
+export declare function generateQrMerkle(creds: AffixCredentials, body: Record<string, unknown>): Promise<Record<string, unknown>>;
+export declare function generateBarcodeMerkle(creds: AffixCredentials, body: Record<string, unknown>): Promise<Record<string, unknown>>;
+export declare function performCliScan(creds: AffixCredentials, body: Record<string, unknown>): Promise<Record<string, unknown>>;
+export declare function fetchBarcodeSymbologies(creds: AffixCredentials): Promise<string[]>;
+/** @deprecated Use generateQrMerkle via hub proxy */
+export declare function generateTicketQr(creds: AffixCredentials, body: Record<string, unknown>): Promise<Record<string, unknown>>;

package/dist/site-api.js

@@ -0,0 +1,57 @@
+import { DEFAULT_HUB_BASE } from "./config.js";
+import { requestJson } from "./http.js";
+export function cliApiBase(creds) {
+    const base = (creds.hub_base || DEFAULT_HUB_BASE).replace(/\/$/, "");
+    return `${base}/cli/v1`;
+}
+async function cliPost(creds, path, body) {
+    const res = await requestJson(`${cliApiBase(creds)}${path}`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${creds.api_key}`,
+            "Content-Type": "application/json",
+            Accept: "application/json",
+        },
+        body: JSON.stringify(body),
+        timeoutMs: 120_000,
+    });
+    const data = await res.json();
+    if (!res.ok) {
+        throw new Error(data.error || data.message || `Request failed (${res.status})`);
+    }
+    return data;
+}
+async function cliGet(creds, path) {
+    const res = await requestJson(`${cliApiBase(creds)}${path}`, {
+        headers: {
+            Authorization: `Bearer ${creds.api_key}`,
+            Accept: "application/json",
+        },
+        timeoutMs: 60_000,
+    });
+    const data = await res.json();
+    if (!res.ok) {
+        throw new Error(data.error || data.message || `Request failed (${res.status})`);
+    }
+    return data;
+}
+export async function generateQrMerkle(creds, body) {
+    return cliPost(creds, "/qr/generate", body);
+}
+export async function generateBarcodeMerkle(creds, body) {
+    return cliPost(creds, "/barcode/generate", body);
+}
+export async function performCliScan(creds, body) {
+    return cliPost(creds, "/scan", body);
+}
+export async function fetchBarcodeSymbologies(creds) {
+    const data = await cliGet(creds, "/barcode/symbologies");
+    const list = data.symbologies;
+    if (!Array.isArray(list))
+        return ["code128", "ean13", "qrcode"];
+    return list.map((s) => s.bcid || s.id || "").filter(Boolean);
+}
+/** @deprecated Use generateQrMerkle via hub proxy */
+export async function generateTicketQr(creds, body) {
+    return generateQrMerkle(creds, body);
+}

package/dist/store.d.ts

@@ -0,0 +1,43 @@
+export type CodeKind = "qr" | "barcode";
+export type CodeFormat = "svg" | "png";
+export interface StoredCode {
+    id: string;
+    kind: CodeKind;
+    label: string;
+    content: string;
+    symbology?: string;
+    format: CodeFormat;
+    created_at: string;
+    output_location?: string;
+    output_path?: string;
+    scans_total?: number | null;
+    scans_remaining?: number | null;
+    files: {
+        svg?: string;
+        png?: string;
+    };
+    meta?: Record<string, unknown>;
+}
+export declare function newCodeId(): string;
+export declare function codeFilePath(id: string, ext: "svg" | "png", outputDir?: string): string;
+export declare function listStoredCodes(): StoredCode[];
+export declare function getStoredCode(id: string): StoredCode | null;
+export declare function saveStoredCode(entry: StoredCode): StoredCode;
+export declare function deleteStoredCode(id: string): boolean;
+export declare function vaultSummary(): {
+    total: number;
+    qr: number;
+    barcode: number;
+    dir: string;
+};
+export interface WriteCodeOptions {
+    location?: string;
+    out?: string;
+}
+export declare function writeCodeFile(id: string, ext: "svg" | "png", body: Buffer | string, opts?: WriteCodeOptions): {
+    path: string;
+    locationName: string;
+    locationPath: string;
+};
+export declare function listOrphanFiles(): string[];
+export declare function updateScanCounts(id: string, scansRemaining: number | null, scansTotal?: number | null): StoredCode | null;

package/dist/store.js

@@ -0,0 +1,96 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { codesDir } from "./config.js";
+import { resolveOutputDir } from "./settings.js";
+const INDEX_FILE = "index.json";
+function indexPath() {
+    return join(codesDir(), INDEX_FILE);
+}
+function ensureVault() {
+    const dir = codesDir();
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    chmodSync(dir, 0o700);
+    if (!existsSync(indexPath())) {
+        writeFileSync(indexPath(), "[]\n", { mode: 0o600 });
+    }
+}
+function readIndex() {
+    ensureVault();
+    try {
+        const raw = readFileSync(indexPath(), "utf8");
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+function writeIndex(entries) {
+    ensureVault();
+    writeFileSync(indexPath(), JSON.stringify(entries, null, 2) + "\n", { mode: 0o600 });
+}
+export function newCodeId() {
+    return randomBytes(6).toString("hex");
+}
+export function codeFilePath(id, ext, outputDir) {
+    return join(outputDir ?? codesDir(), `${id}.${ext}`);
+}
+export function listStoredCodes() {
+    return readIndex().sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+}
+export function getStoredCode(id) {
+    const prefix = id.trim().toLowerCase();
+    return (readIndex().find((e) => e.id === prefix || e.id.startsWith(prefix)) ?? null);
+}
+export function saveStoredCode(entry) {
+    const items = readIndex().filter((e) => e.id !== entry.id);
+    items.unshift(entry);
+    writeIndex(items);
+    return entry;
+}
+export function deleteStoredCode(id) {
+    const entry = getStoredCode(id);
+    if (!entry)
+        return false;
+    const items = readIndex().filter((e) => e.id !== entry.id);
+    writeIndex(items);
+    for (const path of Object.values(entry.files)) {
+        if (path && existsSync(path))
+            unlinkSync(path);
+    }
+    return true;
+}
+export function vaultSummary() {
+    const items = listStoredCodes();
+    return {
+        total: items.length,
+        qr: items.filter((i) => i.kind === "qr").length,
+        barcode: items.filter((i) => i.kind === "barcode").length,
+        dir: codesDir(),
+    };
+}
+export function writeCodeFile(id, ext, body, opts) {
+    ensureVault();
+    const resolved = resolveOutputDir(opts);
+    const path = codeFilePath(id, ext, resolved.path);
+    writeFileSync(path, body, ext === "svg" ? { encoding: "utf8", mode: 0o600 } : { mode: 0o600 });
+    return { path, locationName: resolved.name, locationPath: resolved.path };
+}
+export function listOrphanFiles() {
+    ensureVault();
+    const indexed = new Set(readIndex().flatMap((e) => Object.values(e.files).filter(Boolean)));
+    return readdirSync(codesDir())
+        .filter((f) => f.endsWith(".svg") || f.endsWith(".png"))
+        .map((f) => join(codesDir(), f))
+        .filter((p) => !indexed.has(p));
+}
+export function updateScanCounts(id, scansRemaining, scansTotal) {
+    const entry = getStoredCode(id);
+    if (!entry)
+        return null;
+    entry.scans_remaining = scansRemaining;
+    if (scansTotal !== undefined)
+        entry.scans_total = scansTotal;
+    return saveStoredCode(entry);
+}