@buildinternet/uploads 0.1.0

package/dist/commands/config.js

@@ -0,0 +1,202 @@
+import { existsSync } from "node:fs";
+import { DEFAULT_API_URL, DEFAULT_WORKSPACE, UPLOADS_CONFIG_KEYS, describeConfigSources, redactToken, resolveConfig, resolveConfigPath, resolvePutDefaults, writeConfigKeys, } from "../config.js";
+import { flagBool, flagString, parseCommandArgs, UsageError } from "../cli-args.js";
+const CONFIG_HELP = `uploads config — manage shared buildinternet config
+
+Shared file (with github-screenshots and other skills):
+  ~/.config/buildinternet/config
+  or $XDG_CONFIG_HOME/buildinternet/config
+  or override with $BUILDINTERNET_CONFIG
+
+Subcommands:
+  path                Print the resolved config file path
+  show                Show effective settings (token redacted)
+  init                Create or update UPLOADS_* keys in the config file
+  set <key> <value>   Set one UPLOADS_* key
+
+Keys:
+  UPLOADS_API_URL           API base URL (default: ${DEFAULT_API_URL})
+  UPLOADS_WORKSPACE         Workspace / bucket tenant (default: ${DEFAULT_WORKSPACE})
+  UPLOADS_TOKEN             Bearer token for the workspace
+  UPLOADS_DEFAULT_PREFIX    Default key prefix for put/list
+  UPLOADS_DEFAULT_REPO      Default repo segment for put
+  UPLOADS_DEFAULT_REF       Default ref segment for put
+  UPLOADS_DEFAULT_WIDTH     Default markdown image width
+  UPLOADS_NO_GIT            Set to 1 to skip git remote for --repo
+
+Examples:
+  uploads config path
+  uploads config show
+  uploads config init --token up_default_… --workspace default
+  uploads config set UPLOADS_TOKEN up_default_…
+  uploads config init --api-url http://localhost:8787 --force
+`;
+const VALID_KEYS = new Set(UPLOADS_CONFIG_KEYS);
+function writeStdout(text) {
+    process.stdout.write(text);
+}
+function writeJson(payload) {
+    process.stdout.write(JSON.stringify(payload, null, 2) + "\n");
+}
+export async function runConfig(args, opts, help = false) {
+    const parsed = parseCommandArgs(args);
+    if (help || parsed.help || parsed.positionals.length === 0) {
+        process.stderr.write(CONFIG_HELP);
+        return 0;
+    }
+    const sub = parsed.positionals[0];
+    const rest = parsed.positionals.slice(1);
+    const subArgs = args.slice(args.indexOf(sub) + 1);
+    switch (sub) {
+        case "path":
+            return runConfigPath(subArgs, opts, help);
+        case "show":
+            return runConfigShow(subArgs, opts, help);
+        case "init":
+            return runConfigInit(subArgs, opts, help);
+        case "set":
+            return runConfigSet(rest, subArgs, opts, help);
+        default:
+            process.stderr.write(`unknown config subcommand: ${sub}\n\n${CONFIG_HELP}`);
+            return 2;
+    }
+}
+async function runConfigPath(args, opts, help) {
+    if (help || parseCommandArgs(args).help) {
+        process.stderr.write(`uploads config path\n\nPrint the resolved config file path.\n`);
+        return 0;
+    }
+    const path = resolveConfigPath({ envFile: opts.envFile });
+    const payload = { path, exists: existsSync(path) };
+    if (opts.json)
+        writeJson(payload);
+    else
+        writeStdout(`${path}\n`);
+    return 0;
+}
+async function runConfigShow(args, opts, help) {
+    if (help || parseCommandArgs(args).help) {
+        process.stderr.write(`uploads config show\n\nShow effective settings (token redacted).\n`);
+        return 0;
+    }
+    const config = resolveConfig({ envFile: opts.envFile, requireToken: false });
+    const sources = describeConfigSources({ envFile: opts.envFile });
+    const defaults = resolvePutDefaults({ envFile: opts.envFile });
+    const payload = {
+        configPath: config.configPath,
+        configExists: config.configExists,
+        apiUrl: config.apiUrl,
+        workspace: config.workspace,
+        token: redactToken(config.token || undefined),
+        sources,
+        defaults,
+    };
+    if (opts.json) {
+        writeJson(payload);
+        return 0;
+    }
+    const lines = [
+        `config:    ${config.configPath}${config.configExists ? "" : " (missing)"}`,
+        `api:       ${config.apiUrl} (${sources.apiUrl})`,
+        `workspace: ${config.workspace} (${sources.workspace})`,
+        `token:     ${redactToken(config.token || undefined)} (${sources.token})`,
+    ];
+    if (defaults.prefix)
+        lines.push(`prefix:    ${defaults.prefix}`);
+    if (defaults.repo)
+        lines.push(`repo:      ${defaults.repo}`);
+    if (defaults.ref)
+        lines.push(`ref:       ${defaults.ref}`);
+    if (defaults.width != null)
+        lines.push(`width:     ${defaults.width}`);
+    if (defaults.noGit)
+        lines.push("no-git:    true");
+    writeStdout(lines.join("\n") + "\n");
+    return 0;
+}
+async function runConfigInit(args, opts, help) {
+    const parsed = parseCommandArgs(args);
+    if (help || parsed.help) {
+        process.stderr.write(`uploads config init [options]
+
+Create or update UPLOADS_* keys in the shared config file.
+
+Options:
+  --api-url <url>
+  --workspace, -w <name>
+  --token <token>
+  --path <file>       Write to this file instead of the default
+  --force             Overwrite existing non-empty values
+
+Examples:
+  uploads config init --token up_default_…
+  uploads config init --api-url http://localhost:8787 --workspace default --token up_default_…
+`);
+        return 0;
+    }
+    const apiUrl = flagString(parsed.flags, "--api-url");
+    const workspace = flagString(parsed.flags, "--workspace") ?? flagString(parsed.flags, "-w");
+    const token = flagString(parsed.flags, "--token");
+    const path = flagString(parsed.flags, "--path") ?? resolveConfigPath({ envFile: opts.envFile });
+    const force = flagBool(parsed.flags, "--force");
+    const keys = {};
+    if (apiUrl)
+        keys.UPLOADS_API_URL = apiUrl;
+    if (workspace)
+        keys.UPLOADS_WORKSPACE = workspace;
+    if (token)
+        keys.UPLOADS_TOKEN = token;
+    if (Object.keys(keys).length === 0) {
+        keys.UPLOADS_API_URL = DEFAULT_API_URL;
+        keys.UPLOADS_WORKSPACE = DEFAULT_WORKSPACE;
+    }
+    try {
+        const result = writeConfigKeys(path, keys, { force });
+        const payload = { ...result, keys: Object.keys(keys) };
+        if (opts.json)
+            writeJson(payload);
+        else {
+            const verb = result.created ? "created" : "updated";
+            process.stdout.write(`${verb} ${result.path}\n`);
+            if (result.updated.length)
+                process.stdout.write(`keys: ${result.updated.join(", ")}\n`);
+            if (!token) {
+                process.stderr.write("hint: add a token with uploads config set UPLOADS_TOKEN <token>\n");
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        throw new UsageError(err instanceof Error ? err.message : String(err));
+    }
+}
+async function runConfigSet(positionals, args, opts, help) {
+    const parsed = parseCommandArgs(args);
+    if (help || parsed.help) {
+        process.stderr.write(`uploads config set <key> <value> [--path <file>] [--force]
+
+Examples:
+  uploads config set UPLOADS_TOKEN up_default_…
+  uploads config set UPLOADS_WORKSPACE acme
+`);
+        return 0;
+    }
+    const key = positionals[0];
+    const value = positionals[1];
+    if (!key || !value) {
+        process.stderr.write(`uploads config set <key> <value>\n`);
+        return 2;
+    }
+    if (!VALID_KEYS.has(key)) {
+        throw new UsageError(`unknown key: ${key} (expected ${[...VALID_KEYS].join(", ")})`);
+    }
+    const path = flagString(parsed.flags, "--path") ?? resolveConfigPath({ envFile: opts.envFile });
+    const force = flagBool(parsed.flags, "--force");
+    const result = writeConfigKeys(path, { [key]: value }, { force });
+    const payload = { ...result, key, value: key === "UPLOADS_TOKEN" ? redactToken(value) : value };
+    if (opts.json)
+        writeJson(payload);
+    else
+        process.stdout.write(`set ${key} in ${result.path}\n`);
+    return 0;
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,4 @@
+export declare function runSetup(args: string[], opts: {
+    json?: boolean;
+    envFile?: string;
+}, help?: boolean): Promise<number>;

package/dist/commands/setup.js

@@ -0,0 +1,223 @@
+import { createUploadsClient } from "../client.js";
+import { DEFAULT_API_URL, DEFAULT_WORKSPACE, describeConfigSources, putDefaultsToConfigValues, redactToken, resolveApiUrl, resolveConfig, resolveConfigPath, resolvePutDefaults, writeConfigKeys, workspaceFromToken, } from "../config.js";
+import { flagBool, flagInt, flagString, parseCommandArgs, UsageError } from "../cli-args.js";
+import { UploadsError } from "../errors.js";
+const SETUP_HELP = `uploads setup — guided CLI configuration
+
+Writes UPLOADS_* keys to the shared buildinternet config file and prints
+step-by-step instructions for anything still missing.
+
+Without flags: shows current status and the next steps to finish setup.
+With flags: saves provided values, then optionally verifies with doctor.
+
+Options:
+  --api-url <url>       API base (default: ${DEFAULT_API_URL})
+  --workspace, -w <name>
+  --token <token>       Bearer token (mint via admin endpoint — see below)
+  --prefix <path>       Default key prefix for put/list (default: screenshots)
+  --repo <owner/repo>   Default repo segment for put
+  --ref <id>            Default ref segment for put (PR/issue/branch/date)
+  --width <px>          Default markdown image width
+  --no-git              Don't derive --repo from git remote
+  --path <file>         Config file (default: ~/.config/buildinternet/config)
+  --force               Overwrite existing non-empty values
+  --check               Run doctor after saving (default when --token is set)
+  --no-check            Skip doctor after saving
+
+Examples:
+  uploads setup
+  uploads setup --token up_default_…
+  uploads setup --api-url http://localhost:8787 --workspace default --token up_default_…
+  uploads setup --prefix screenshots --repo myorg/myapp --check
+`;
+function buildStatus(envFile) {
+    const config = resolveConfig({ envFile, requireToken: false });
+    return {
+        configPath: config.configPath,
+        apiUrl: config.apiUrl,
+        workspace: config.workspace,
+        token: config.token || undefined,
+        defaults: resolvePutDefaults({ envFile }),
+        sources: describeConfigSources({ envFile }),
+    };
+}
+function mintTokenCommand(apiUrl, workspace) {
+    const body = workspace && workspace !== DEFAULT_WORKSPACE
+        ? ` \\\n  -H "Content-Type: application/json" \\\n  -d '{"workspace":"${workspace}","label":"cli"}'`
+        : "";
+    return [
+        `curl -XPOST ${apiUrl}/admin/tokens \\`,
+        `  -H "Authorization: Bearer $ADMIN_TOKEN"${body}`,
+    ].join("\n");
+}
+function formatWizard(status) {
+    const lines = ["uploads setup", ""];
+    lines.push(`Config file: ${status.configPath}`);
+    lines.push(`API:         ${status.apiUrl} (${status.sources.apiUrl})`);
+    lines.push(`Workspace:   ${status.workspace} (${status.sources.workspace})`);
+    lines.push(`Token:       ${redactToken(status.token)} (${status.sources.token})`);
+    const d = status.defaults;
+    if (d.prefix || d.repo || d.ref || d.width != null || d.noGit) {
+        lines.push("Defaults:");
+        if (d.prefix)
+            lines.push(`  prefix: ${d.prefix}`);
+        if (d.repo)
+            lines.push(`  repo:   ${d.repo}`);
+        if (d.ref)
+            lines.push(`  ref:    ${d.ref}`);
+        if (d.width != null)
+            lines.push(`  width:  ${d.width}`);
+        if (d.noGit)
+            lines.push("  no-git: true");
+    }
+    lines.push("");
+    if (!status.token) {
+        lines.push("Step 1 — Mint a token");
+        lines.push("  You need ADMIN_TOKEN for the API (ask your uploads.sh admin, or set it locally in apps/api/.dev.vars).");
+        lines.push("  Mint:");
+        lines.push(`    ${mintTokenCommand(status.apiUrl, status.workspace)}`);
+        lines.push("  Save:");
+        lines.push("    uploads setup --token up_<workspace>_…");
+        lines.push("");
+    }
+    else {
+        lines.push("Step 1 — Token: ok");
+        lines.push("");
+    }
+    if (status.apiUrl.includes("localhost") || status.apiUrl.includes("127.0.0.1")) {
+        lines.push("Note — local API");
+        lines.push("  Tokens minted with workspace:add --local only work against localhost.");
+        lines.push("  Prod tokens need UPLOADS_API_URL=https://api.uploads.sh");
+        lines.push("");
+    }
+    lines.push("Step 2 — Optional put defaults");
+    lines.push("  uploads setup --prefix screenshots --repo myorg/myapp");
+    lines.push("  uploads config set UPLOADS_DEFAULT_REPO myorg/myapp");
+    lines.push("");
+    lines.push("Step 3 — Verify");
+    lines.push("  uploads doctor");
+    lines.push("  uploads put ./shot.png");
+    lines.push("");
+    if (status.token) {
+        lines.push("Quick save (all-in-one):");
+        lines.push(`  uploads setup --api-url ${status.apiUrl} --workspace ${status.workspace} --token <token> --check`);
+    }
+    return lines.join("\n");
+}
+export async function runSetup(args, opts, help = false) {
+    const parsed = parseCommandArgs(args);
+    if (help || parsed.help) {
+        process.stderr.write(SETUP_HELP);
+        return 0;
+    }
+    const apiUrl = flagString(parsed.flags, "--api-url");
+    const workspace = flagString(parsed.flags, "--workspace") ?? flagString(parsed.flags, "-w");
+    const token = flagString(parsed.flags, "--token");
+    const prefix = flagString(parsed.flags, "--prefix");
+    const repo = flagString(parsed.flags, "--repo");
+    const ref = flagString(parsed.flags, "--ref");
+    const width = flagInt(parsed.flags, "--width", "--width");
+    const noGit = flagBool(parsed.flags, "--no-git");
+    const path = flagString(parsed.flags, "--path") ?? resolveConfigPath({ envFile: opts.envFile });
+    const force = flagBool(parsed.flags, "--force");
+    const checkExplicit = flagBool(parsed.flags, "--check");
+    const noCheck = flagBool(parsed.flags, "--no-check");
+    const hasWrites = apiUrl != null ||
+        workspace != null ||
+        token != null ||
+        prefix != null ||
+        repo != null ||
+        ref != null ||
+        width != null ||
+        noGit;
+    if (!hasWrites) {
+        const status = buildStatus(opts.envFile);
+        if (opts.json) {
+            process.stdout.write(JSON.stringify({
+                ...status,
+                token: redactToken(status.token),
+                complete: Boolean(status.token),
+                next: status.token ? "doctor" : "mint-token",
+            }, null, 2) + "\n");
+        }
+        else {
+            process.stdout.write(formatWizard(status));
+        }
+        return status.token ? 0 : 1;
+    }
+    const keys = {};
+    if (apiUrl)
+        keys.UPLOADS_API_URL = apiUrl;
+    if (workspace)
+        keys.UPLOADS_WORKSPACE = workspace;
+    if (token)
+        keys.UPLOADS_TOKEN = token;
+    Object.assign(keys, putDefaultsToConfigValues({
+        prefix: prefix ?? undefined,
+        repo: repo ?? undefined,
+        ref: ref ?? undefined,
+        width: width ?? undefined,
+        noGit: noGit || undefined,
+    }));
+    if (Object.keys(keys).length === 0) {
+        throw new UsageError("no setup values provided");
+    }
+    const result = writeConfigKeys(path, keys, { force });
+    const savedApiUrl = apiUrl ?? resolveApiUrl({ envFile: opts.envFile });
+    const savedWorkspace = workspace ?? (token ? workspaceFromToken(token) : undefined) ?? DEFAULT_WORKSPACE;
+    const shouldCheck = !noCheck && (checkExplicit || Boolean(token));
+    let doctorOk;
+    let doctorError;
+    if (shouldCheck) {
+        const cfg = resolveConfig({ envFile: opts.envFile, requireToken: false });
+        if (!cfg.token) {
+            doctorError = "no token configured — run uploads setup --token <token>";
+        }
+        else {
+            try {
+                const client = createUploadsClient({
+                    apiUrl: cfg.apiUrl,
+                    workspace: cfg.workspace,
+                    token: cfg.token,
+                });
+                const health = await client.health();
+                if (!health.ok)
+                    throw new UploadsError("API unhealthy", "API_ERROR");
+                await client.list({ limit: 1 });
+                doctorOk = true;
+            }
+            catch (err) {
+                doctorOk = false;
+                doctorError = err instanceof UploadsError ? err.message : String(err);
+            }
+        }
+    }
+    const payload = {
+        ...result,
+        keys: Object.keys(keys),
+        apiUrl: savedApiUrl,
+        workspace: savedWorkspace,
+        doctor: shouldCheck ? { ok: doctorOk, error: doctorError } : undefined,
+    };
+    if (opts.json) {
+        process.stdout.write(JSON.stringify(payload, null, 2) + "\n");
+        return doctorOk === false ? 1 : 0;
+    }
+    const verb = result.created ? "created" : "updated";
+    process.stdout.write(`${verb} ${result.path}\n`);
+    if (result.updated.length)
+        process.stdout.write(`keys: ${result.updated.join(", ")}\n`);
+    if (shouldCheck) {
+        if (doctorOk)
+            process.stdout.write("doctor: ok\n");
+        else
+            process.stderr.write(`doctor: failed — ${doctorError}\n`);
+    }
+    else if (token || checkExplicit) {
+        process.stderr.write("hint: run uploads doctor to verify\n");
+    }
+    else {
+        process.stderr.write("hint: run uploads setup to see minting instructions\n");
+    }
+    return doctorOk === false ? 1 : 0;
+}

package/dist/commands.d.ts

@@ -0,0 +1,19 @@
+import { type UploadsClient } from "./client.js";
+import { type ResolvedConfig } from "./config.js";
+import { type CommandRunner } from "./github-gh.js";
+export interface CliContext {
+    config: ResolvedConfig;
+    client: UploadsClient;
+    json: boolean;
+    quiet: boolean;
+    envFile?: string;
+}
+export declare function runAttach(ctx: CliContext, args: string[], help?: boolean, run?: CommandRunner): Promise<number>;
+export declare function runPut(ctx: CliContext, args: string[], help?: boolean, run?: CommandRunner): Promise<number>;
+export declare function runList(ctx: CliContext, args: string[], help?: boolean, run?: CommandRunner): Promise<number>;
+export declare function runDelete(ctx: CliContext, args: string[], help?: boolean): Promise<number>;
+export declare function runComment(ctx: CliContext, args: string[], help?: boolean, run?: CommandRunner): Promise<number>;
+export declare function runHealth(ctx: Pick<CliContext, "json"> & {
+    apiUrl: string;
+}, args: string[], help?: boolean): Promise<number>;
+export declare function runDoctor(ctx: CliContext, args: string[], help?: boolean): Promise<number>;