@affix-io/cli 1.2.4

package/dist/commands.js

@@ -0,0 +1,36 @@
+export { ensureAuth, runLogin, runLogout, runWhoami, runHealth, runCircuits, runAuthCheck, runProve, runVerify, } from "./commands-core.js";
+export function printUsage() {
+    console.log(`Usage: affix [command]
+
+Auth
+  login             Sign in via affix-io.com/cli/verify (browser)
+  logout            Remove local credentials
+  whoami            Show signed-in account
+
+API
+  health            API health check
+  circuits          List available circuits
+  auth              Check API key status
+  prove [--circuit <id>]
+  verify <proof> [--circuit <id>]
+
+Output locations (~/.affix/settings.json)
+  location list                 List saved output directories
+  location add <name> <path>    Register an output directory
+  location default <name>       Set default output location
+  location rm <name>            Remove a saved location
+
+Codes (Merkle-backed; index in ~/.affix/codes/)
+  qr <text|url> [--scans N --event <slug>] [--location <name>] [--out <path>] [--short]
+  qr ticket --event <slug> [--scans N] [--holder <id>]
+  barcode <data> [--type code128] [--scans N --event <slug>] [--location <name>]
+  scan <id|token|code> [--event <slug>] [--gate <id>]
+  codes             List local vault
+  show <id>         Show stored code
+  open <id>         Open file in default app
+  rm <id>           Remove from vault
+  symbologies       List barcode types
+
+Run affix with no arguments for interactive mode.
+`);
+}

package/dist/config.d.ts

@@ -0,0 +1,19 @@
+export interface AffixCredentials {
+    api_key: string;
+    email: string;
+    api_base: string;
+    hub_base: string;
+    activated_at: string;
+    client_name?: string;
+}
+export declare const DEFAULT_HUB_BASE = "https://www.affix-io.com";
+export declare const DEFAULT_API_BASE = "https://api.affix-io.com";
+export declare function affixDir(): string;
+export declare function codesDir(): string;
+export declare function credentialsPath(): string;
+/** Local placeholder credentials for offline QR/barcode rendering. */
+export declare function localCredentials(): AffixCredentials;
+export declare function loadCredentials(): AffixCredentials | null;
+export declare function hasApiKey(creds: AffixCredentials | null | undefined): boolean;
+export declare function saveCredentials(creds: AffixCredentials): void;
+export declare function clearCredentials(): void;

package/dist/config.js

@@ -0,0 +1,78 @@
+import { mkdirSync, readFileSync, writeFileSync, chmodSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const AFFIX_DIR = join(homedir(), ".affix");
+const CREDENTIALS_PATH = join(AFFIX_DIR, "credentials.json");
+const CODES_DIR = join(AFFIX_DIR, "codes");
+export const DEFAULT_HUB_BASE = "https://www.affix-io.com";
+export const DEFAULT_API_BASE = "https://api.affix-io.com";
+export function affixDir() {
+    return AFFIX_DIR;
+}
+export function codesDir() {
+    return CODES_DIR;
+}
+export function credentialsPath() {
+    return CREDENTIALS_PATH;
+}
+function loadFileCredentials() {
+    if (!existsSync(CREDENTIALS_PATH))
+        return null;
+    try {
+        const raw = readFileSync(CREDENTIALS_PATH, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed.api_key || !parsed.email)
+            return null;
+        return {
+            ...parsed,
+            api_base: parsed.api_base ?? DEFAULT_API_BASE,
+            hub_base: parsed.hub_base ?? DEFAULT_HUB_BASE,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Local placeholder credentials for offline QR/barcode rendering. */
+export function localCredentials() {
+    return {
+        api_key: "",
+        email: "local",
+        api_base: process.env.AFFIX_API_BASE?.trim() || DEFAULT_API_BASE,
+        hub_base: process.env.AFFIX_HUB_BASE?.trim() || DEFAULT_HUB_BASE,
+        activated_at: new Date().toISOString(),
+        client_name: "affix-cli",
+    };
+}
+export function loadCredentials() {
+    const file = loadFileCredentials();
+    const envKey = process.env.AFFIX_API_KEY?.trim();
+    if (envKey) {
+        return {
+            api_key: envKey,
+            email: process.env.AFFIX_EMAIL?.trim() || file?.email || "env",
+            api_base: process.env.AFFIX_API_BASE?.trim() || file?.api_base || DEFAULT_API_BASE,
+            hub_base: process.env.AFFIX_HUB_BASE?.trim() || file?.hub_base || DEFAULT_HUB_BASE,
+            activated_at: file?.activated_at || new Date().toISOString(),
+            client_name: file?.client_name || "affix-cli",
+        };
+    }
+    return file;
+}
+export function hasApiKey(creds) {
+    return Boolean(creds?.api_key?.trim());
+}
+export function saveCredentials(creds) {
+    mkdirSync(AFFIX_DIR, { recursive: true, mode: 0o700 });
+    writeFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2) + "\n", {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    chmodSync(AFFIX_DIR, 0o700);
+    chmodSync(CREDENTIALS_PATH, 0o600);
+}
+export function clearCredentials() {
+    if (!existsSync(CREDENTIALS_PATH))
+        return;
+    writeFileSync(CREDENTIALS_PATH, "", { mode: 0o600 });
+}

package/dist/generate-local.d.ts

@@ -0,0 +1,5 @@
+export declare function renderQrSvg(content: string): Promise<string>;
+export declare function renderQrPng(content: string): Promise<Buffer>;
+export declare function renderBarcodeSvg(symbology: string, content: string): Promise<string>;
+export declare function renderBarcodePng(symbology: string, content: string): Promise<Buffer>;
+export declare const DEFAULT_SYMBOLOGIES: string[];

package/dist/generate-local.js

@@ -0,0 +1,47 @@
+import QRCode from "qrcode";
+import bwipjs from "bwip-js";
+export async function renderQrSvg(content) {
+    return QRCode.toString(content, {
+        type: "svg",
+        errorCorrectionLevel: "M",
+        margin: 2,
+        width: 256,
+    });
+}
+export async function renderQrPng(content) {
+    return QRCode.toBuffer(content, {
+        type: "png",
+        errorCorrectionLevel: "M",
+        margin: 2,
+        width: 512,
+    });
+}
+export async function renderBarcodeSvg(symbology, content) {
+    return bwipjs.toSVG({
+        bcid: symbology,
+        text: content,
+        scale: 3,
+        height: 12,
+        includetext: true,
+        textxalign: "center",
+    });
+}
+export async function renderBarcodePng(symbology, content) {
+    return bwipjs.toBuffer({
+        bcid: symbology,
+        text: content,
+        scale: 3,
+        height: 12,
+        includetext: true,
+        textxalign: "center",
+    });
+}
+export const DEFAULT_SYMBOLOGIES = [
+    "code128",
+    "ean13",
+    "ean8",
+    "upca",
+    "qrcode",
+    "datamatrix",
+    "pdf417",
+];

package/dist/http.d.ts

@@ -0,0 +1,11 @@
+export type JsonResponse = {
+    status: number;
+    ok: boolean;
+    json(): Promise<Record<string, unknown>>;
+};
+export declare function requestJson(url: string, options?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    timeoutMs?: number;
+}): Promise<JsonResponse>;

package/dist/http.js

@@ -0,0 +1,62 @@
+import { existsSync, readFileSync } from "node:fs";
+import http from "node:http";
+import https from "node:https";
+import { dirname, join } from "node:path";
+import tls from "node:tls";
+import { fileURLToPath } from "node:url";
+const packageRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+const EXTRA_CA_PATH = join(packageRoot, "certs", "sectigo-r36.pem");
+let caBundle;
+function getCaBundle() {
+    if (caBundle)
+        return caBundle;
+    caBundle = [...tls.rootCertificates];
+    if (existsSync(EXTRA_CA_PATH)) {
+        caBundle.push(readFileSync(EXTRA_CA_PATH, "utf8"));
+    }
+    return caBundle;
+}
+export async function requestJson(url, options = {}) {
+    const parsed = new URL(url);
+    const isHttps = parsed.protocol === "https:";
+    const lib = isHttps ? https : http;
+    return new Promise((resolve, reject) => {
+        const req = lib.request({
+            protocol: parsed.protocol,
+            hostname: parsed.hostname,
+            port: parsed.port || (isHttps ? 443 : 80),
+            path: `${parsed.pathname}${parsed.search}`,
+            method: options.method ?? "GET",
+            headers: options.headers,
+            ca: isHttps ? getCaBundle() : undefined,
+        }, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+            res.on("end", () => {
+                const text = Buffer.concat(chunks).toString("utf8");
+                const status = res.statusCode ?? 0;
+                resolve({
+                    status,
+                    ok: status >= 200 && status < 300,
+                    async json() {
+                        try {
+                            return JSON.parse(text);
+                        }
+                        catch {
+                            return { error: "invalid_json", raw: text };
+                        }
+                    },
+                });
+            });
+        });
+        req.on("error", reject);
+        if (options.timeoutMs) {
+            req.setTimeout(options.timeoutMs, () => {
+                req.destroy(new Error("request_timeout"));
+            });
+        }
+        if (options.body)
+            req.write(options.body);
+        req.end();
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+import { printUsage, runAuthCheck, runCircuits, runHealth, runLogin, runLogout, runProve, runVerify, runWhoami, } from "./commands.js";
+import { hasApiKey, loadCredentials, localCredentials } from "./config.js";
+import { AffixApi } from "./api.js";
+import { runRepl } from "./repl.js";
+import { generateBarcode, generateQr, generateTicketCode, listSymbologies, openCode, printCodeEntry, printCodesList, removeCode, scanCode, showCode, } from "./codes.js";
+import { addOutputLocation, printLocations, removeOutputLocation, setDefaultOutputLocation, } from "./settings.js";
+function arg(name) {
+    const idx = process.argv.indexOf(name);
+    if (idx === -1)
+        return undefined;
+    return process.argv[idx + 1];
+}
+function hasFlag(name) {
+    return process.argv.includes(name);
+}
+function parseScans() {
+    const raw = arg("--scans") ?? arg("--max-uses");
+    if (raw == null)
+        return undefined;
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n < 1) {
+        console.error("--scans must be a positive integer.");
+        process.exit(1);
+    }
+    return Math.floor(n);
+}
+function positionalArgs(argv) {
+    const out = [];
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i].startsWith("--")) {
+            if (argv[i + 1] && !argv[i + 1].startsWith("--"))
+                i++;
+            continue;
+        }
+        out.push(argv[i]);
+    }
+    return out.join(" ");
+}
+function outputOpts() {
+    return {
+        location: arg("--location"),
+        out: arg("--out"),
+        maxUses: parseScans(),
+        event: arg("--event"),
+        holder: arg("--holder"),
+        seat: arg("--seat"),
+        tier: arg("--tier"),
+    };
+}
+function requireApi(creds) {
+    if (!hasApiKey(creds)) {
+        console.error("Not signed in. Run: affix login");
+        console.error("Or set AFFIX_API_KEY for API commands.");
+        process.exit(1);
+    }
+    return creds;
+}
+async function main() {
+    const command = process.argv[2];
+    if (!command || command === "chat" || command === "repl") {
+        const creds = loadCredentials() ?? localCredentials();
+        if (!hasApiKey(creds)) {
+            console.log("Local mode. Sign in for Merkle-backed codes and prove/verify.\n");
+            console.log("Run: affix login   or set AFFIX_API_KEY\n");
+        }
+        await runRepl(creds, new AffixApi(creds));
+        return;
+    }
+    if (command === "help" || command === "--help" || command === "-h") {
+        printUsage();
+        return;
+    }
+    if (command === "login") {
+        await runLogin();
+        return;
+    }
+    if (command === "logout") {
+        runLogout();
+        return;
+    }
+    if (command === "location" || command === "locations") {
+        const sub = process.argv[3];
+        if (!sub || sub === "list") {
+            printLocations();
+            return;
+        }
+        if (sub === "add") {
+            const name = process.argv[4];
+            const path = process.argv[5];
+            if (!name || !path) {
+                console.error("Usage: affix location add <name> <path>");
+                process.exit(1);
+            }
+            const entry = addOutputLocation(name, path);
+            console.log(`Added output location "${entry.name}" → ${entry.path}`);
+            return;
+        }
+        if (sub === "default") {
+            const name = process.argv[4];
+            if (!name) {
+                console.error("Usage: affix location default <name>");
+                process.exit(1);
+            }
+            setDefaultOutputLocation(name);
+            console.log(`Default output location set to "${name}".`);
+            return;
+        }
+        if (sub === "rm" || sub === "remove") {
+            const name = process.argv[4];
+            if (!name) {
+                console.error("Usage: affix location rm <name>");
+                process.exit(1);
+            }
+            removeOutputLocation(name);
+            console.log(`Removed location "${name}".`);
+            return;
+        }
+        printLocations();
+        return;
+    }
+    if (command === "codes" || command === "ls") {
+        printCodesList();
+        return;
+    }
+    if (command === "show") {
+        const id = process.argv[3];
+        if (!id) {
+            console.error("Usage: affix show <id>");
+            process.exit(1);
+        }
+        showCode(id);
+        return;
+    }
+    if (command === "open") {
+        const id = process.argv[3];
+        if (!id) {
+            console.error("Usage: affix open <id>");
+            process.exit(1);
+        }
+        openCode(id);
+        return;
+    }
+    if (command === "rm" || command === "delete") {
+        const id = process.argv[3];
+        if (!id) {
+            console.error("Usage: affix rm <id>");
+            process.exit(1);
+        }
+        removeCode(id);
+        return;
+    }
+    const creds = loadCredentials() ?? localCredentials();
+    if (command === "qr") {
+        const sub = process.argv[3];
+        const opts = {
+            ...outputOpts(),
+            both: hasFlag("--png"),
+            label: arg("--label"),
+            shortLink: hasFlag("--short"),
+        };
+        if (sub === "ticket") {
+            requireApi(creds);
+            const event = arg("--event");
+            if (!event) {
+                console.error("Usage: affix qr ticket --event <slug> [--scans N] [--holder <id>] [--location <name>]");
+                process.exit(1);
+            }
+            const entry = await generateTicketCode(creds, {
+                event,
+                holder: arg("--holder"),
+                seat: arg("--seat"),
+                tier: arg("--tier"),
+                maxUses: opts.maxUses,
+            }, opts);
+            printCodeEntry(entry);
+            return;
+        }
+        const content = positionalArgs(process.argv.slice(3));
+        if (!content) {
+            console.error("Usage: affix qr <text|url> [--scans N --event <slug>] [--png] [--short] [--location <name>] [--out <path>]");
+            process.exit(1);
+        }
+        const entry = await generateQr(creds, content, opts);
+        printCodeEntry(entry);
+        return;
+    }
+    if (command === "barcode") {
+        const content = positionalArgs(process.argv.slice(3));
+        const sym = arg("--type") ?? "code128";
+        if (!content) {
+            console.error("Usage: affix barcode <data> [--type code128] [--scans N --event <slug>] [--location <name>]");
+            process.exit(1);
+        }
+        const entry = await generateBarcode(creds, content, {
+            ...outputOpts(),
+            symbology: sym,
+            both: hasFlag("--png"),
+            label: arg("--label"),
+        });
+        printCodeEntry(entry);
+        return;
+    }
+    if (command === "symbologies") {
+        const list = await listSymbologies(creds);
+        console.log(list.join(", "));
+        return;
+    }
+    const apiCreds = requireApi(creds);
+    const api = new AffixApi(apiCreds);
+    if (command === "whoami") {
+        runWhoami(apiCreds);
+        return;
+    }
+    if (command === "health") {
+        await runHealth(api);
+        return;
+    }
+    if (command === "circuits") {
+        await runCircuits(api);
+        return;
+    }
+    if (command === "auth") {
+        await runAuthCheck(api);
+        return;
+    }
+    if (command === "prove") {
+        const circuit = arg("--circuit") ?? "ticket_local_resident";
+        await runProve(api, circuit);
+        return;
+    }
+    if (command === "verify") {
+        const proof = process.argv[3];
+        if (!proof) {
+            console.error("Usage: affix verify <proof> [--circuit <id>]");
+            process.exit(1);
+        }
+        const circuit = arg("--circuit") ?? "ticket_local_resident";
+        await runVerify(api, circuit, proof);
+        return;
+    }
+    if (command === "scan") {
+        const target = process.argv[3];
+        if (!target) {
+            console.error("Usage: affix scan <id|token|code> [--event <slug>] [--gate <id>]");
+            process.exit(1);
+        }
+        const result = await scanCode(apiCreds, target, {
+            event: arg("--event"),
+            entryPoint: arg("--gate") ?? arg("--entry"),
+            id: getStoredCodeId(target),
+        });
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    printUsage();
+    process.exit(1);
+}
+function getStoredCodeId(target) {
+    if (/^[a-f0-9]{6,}$/i.test(target))
+        return target;
+    return undefined;
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/repl.d.ts

@@ -0,0 +1,4 @@
+import type { AffixCredentials } from "./config.js";
+import type { AffixApi } from "./api.js";
+export declare const HELP: string;
+export declare function runRepl(creds: AffixCredentials, api: AffixApi): Promise<void>;