@evcraddock/slug-cli 0.2.0

package/dist/config.d.ts

@@ -0,0 +1,17 @@
+export interface SlugConfig {
+    apiBaseUrl?: string;
+    apiKey?: string;
+    apiKeyReference?: string;
+}
+export interface DisplayConfig {
+    apiBaseUrl?: string;
+    apiKeyConfigured: boolean;
+    apiKeyReference?: string;
+}
+export declare function createDefaultConfig(): SlugConfig;
+export declare function getConfigPath(environment?: NodeJS.ProcessEnv): string;
+export declare function readConfig(configPath: string): Promise<SlugConfig>;
+export declare function writeConfig(configPath: string, config: SlugConfig): Promise<void>;
+export declare function setConfigApiBaseUrl(config: SlugConfig, apiBaseUrl: string): SlugConfig;
+export declare function setConfigApiKey(config: SlugConfig, apiKey: string): SlugConfig;
+export declare function toDisplayConfig(config: SlugConfig): DisplayConfig;

package/dist/config.js

@@ -0,0 +1,125 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export function createDefaultConfig() {
+    return {};
+}
+export function getConfigPath(environment = process.env) {
+    const configHome = environment.SLUG_CONFIG_HOME ?? environment.XDG_CONFIG_HOME ?? join(homedir(), ".config");
+    return join(configHome, "slug", "config.yaml");
+}
+export async function readConfig(configPath) {
+    try {
+        const content = await readFile(configPath, "utf8");
+        return parseConfig(content);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return createDefaultConfig();
+        }
+        throw error;
+    }
+}
+export async function writeConfig(configPath, config) {
+    await mkdir(dirname(configPath), { recursive: true });
+    await writeFile(configPath, serializeConfig(config), "utf8");
+}
+export function setConfigApiBaseUrl(config, apiBaseUrl) {
+    return { ...config, apiBaseUrl };
+}
+export function setConfigApiKey(config, apiKey) {
+    const nextConfig = { ...config, apiKey };
+    delete nextConfig.apiKeyReference;
+    return nextConfig;
+}
+export function toDisplayConfig(config) {
+    return {
+        apiBaseUrl: config.apiBaseUrl,
+        apiKeyConfigured: config.apiKey !== undefined || config.apiKeyReference !== undefined,
+        apiKeyReference: config.apiKeyReference,
+    };
+}
+function parseConfig(content) {
+    const trimmed = content.trim();
+    if (trimmed === "" || trimmed === "{}") {
+        return createDefaultConfig();
+    }
+    if (trimmed.startsWith("{")) {
+        return normalizeParsedConfig(JSON.parse(trimmed));
+    }
+    const parsed = {};
+    for (const [index, rawLine] of content.split(/\r?\n/).entries()) {
+        const line = stripComment(rawLine).trim();
+        if (line === "" || line === "---") {
+            continue;
+        }
+        const match = /^(apiBaseUrl|apiKey|apiKeyReference):(?:\s*(.*))?$/.exec(line);
+        if (match === null) {
+            throw new Error(`Invalid slug config YAML at line ${index + 1}`);
+        }
+        const [, key, rawValue = ""] = match;
+        parsed[key] = parseScalar(rawValue.trim());
+    }
+    return normalizeParsedConfig(parsed);
+}
+function serializeConfig(config) {
+    const lines = [];
+    if (config.apiBaseUrl !== undefined) {
+        lines.push(`apiBaseUrl: ${formatScalar(config.apiBaseUrl)}`);
+    }
+    if (config.apiKey !== undefined) {
+        lines.push(`apiKey: ${formatScalar(config.apiKey)}`);
+    }
+    if (config.apiKeyReference !== undefined) {
+        lines.push(`apiKeyReference: ${formatScalar(config.apiKeyReference)}`);
+    }
+    return lines.length === 0 ? "{}\n" : `${lines.join("\n")}\n`;
+}
+function normalizeParsedConfig(config) {
+    const normalized = {};
+    if (typeof config.apiBaseUrl === "string") {
+        normalized.apiBaseUrl = config.apiBaseUrl;
+    }
+    if (typeof config.apiKey === "string") {
+        normalized.apiKey = config.apiKey;
+    }
+    if (typeof config.apiKeyReference === "string") {
+        normalized.apiKeyReference = config.apiKeyReference;
+    }
+    return normalized;
+}
+function stripComment(line) {
+    let quote;
+    for (let index = 0; index < line.length; index += 1) {
+        const char = line[index];
+        if (quote !== undefined) {
+            if (char === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === "#") {
+            return line.slice(0, index);
+        }
+    }
+    return line;
+}
+function parseScalar(value) {
+    if (value.startsWith('"') && value.endsWith('"')) {
+        return JSON.parse(value);
+    }
+    if (value.startsWith("'") && value.endsWith("'")) {
+        return value.slice(1, -1).replaceAll("''", "'");
+    }
+    return value;
+}
+function formatScalar(value) {
+    if (/^[A-Za-z0-9._~:/?#[\]@!$&'()*+,;=%-]+$/.test(value)) {
+        return value;
+    }
+    return JSON.stringify(value);
+}

package/dist/errors.d.ts

@@ -0,0 +1,13 @@
+export declare const ExitCode: {
+    readonly Ok: 0;
+    readonly InvalidUsage: 2;
+    readonly NetworkError: 10;
+    readonly AuthenticationError: 11;
+    readonly ApiError: 12;
+};
+export type ExitCode = (typeof ExitCode)[keyof typeof ExitCode];
+export declare class CliError extends Error {
+    readonly exitCode: ExitCode;
+    constructor(message: string, exitCode: ExitCode);
+}
+export declare function createInvalidUsageError(message: string): CliError;

package/dist/errors.js

@@ -0,0 +1,18 @@
+export const ExitCode = {
+    Ok: 0,
+    InvalidUsage: 2,
+    NetworkError: 10,
+    AuthenticationError: 11,
+    ApiError: 12,
+};
+export class CliError extends Error {
+    exitCode;
+    constructor(message, exitCode) {
+        super(message);
+        this.name = "CliError";
+        this.exitCode = exitCode;
+    }
+}
+export function createInvalidUsageError(message) {
+    return new CliError(message, ExitCode.InvalidUsage);
+}

package/dist/http.d.ts

@@ -0,0 +1,27 @@
+export interface HttpClientOptions {
+    apiBaseUrl: string;
+    apiKey?: string;
+    fetchImpl?: typeof fetch;
+}
+export interface HttpRequestOptions {
+    method?: string;
+    path: string;
+    body?: unknown;
+}
+export interface ApiErrorBody {
+    error?: {
+        code?: string;
+        message?: string;
+        operation?: string;
+    };
+}
+export declare class SlugHttpClient {
+    private readonly apiBaseUrl;
+    private readonly apiKey;
+    private readonly fetchImpl;
+    constructor(options: HttpClientOptions);
+    requestJson<TResponse>(options: HttpRequestOptions): Promise<TResponse>;
+    requestVoid(options: HttpRequestOptions): Promise<void>;
+    private request;
+    private createHeaders;
+}

package/dist/http.js

@@ -0,0 +1,71 @@
+import { CliError, ExitCode } from "./errors.js";
+export class SlugHttpClient {
+    apiBaseUrl;
+    apiKey;
+    fetchImpl;
+    constructor(options) {
+        this.apiBaseUrl = options.apiBaseUrl.replace(/\/$/, "");
+        this.apiKey = options.apiKey;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+    }
+    async requestJson(options) {
+        const response = await this.request(options);
+        return (await response.json());
+    }
+    async requestVoid(options) {
+        await this.request(options);
+    }
+    async request(options) {
+        const url = `${this.apiBaseUrl}${options.path}`;
+        try {
+            const response = await this.fetchImpl(url, {
+                method: options.method ?? "GET",
+                headers: this.createHeaders(options.body),
+                body: createRequestBody(options.body),
+            });
+            if (response.status === 401 || response.status === 403) {
+                throw new CliError(await readApiErrorMessage(response, "Authentication failed"), ExitCode.AuthenticationError);
+            }
+            if (!response.ok) {
+                throw new CliError(await readApiErrorMessage(response, `API request failed with status ${response.status}`), ExitCode.ApiError);
+            }
+            return response;
+        }
+        catch (error) {
+            if (error instanceof CliError) {
+                throw error;
+            }
+            throw new CliError("Network request failed", ExitCode.NetworkError);
+        }
+    }
+    createHeaders(body) {
+        const headers = {
+            accept: "application/json",
+        };
+        if (body !== undefined && !(body instanceof FormData)) {
+            headers["content-type"] = "application/json";
+        }
+        if (this.apiKey !== undefined) {
+            headers.authorization = `Bearer ${this.apiKey}`;
+        }
+        return headers;
+    }
+}
+function createRequestBody(body) {
+    if (body === undefined) {
+        return undefined;
+    }
+    if (body instanceof FormData) {
+        return body;
+    }
+    return JSON.stringify(body);
+}
+async function readApiErrorMessage(response, fallback) {
+    try {
+        const body = (await response.json());
+        return body.error?.message ?? fallback;
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(args?: string[]): Promise<number>;

package/dist/index.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { readFileSync, realpathSync } from "node:fs";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { getConfigPath } from "./config.js";
+import { runCommand } from "./commands.js";
+import { CliError, ExitCode, createInvalidUsageError } from "./errors.js";
+import { createConsoleWriter } from "./output.js";
+export async function main(args = process.argv.slice(2)) {
+    const writer = createConsoleWriter();
+    try {
+        const parsedArgs = parseGlobalOptions(args);
+        const result = await runCommand({
+            args: parsedArgs.commandArgs,
+            configPath: parsedArgs.configPath ?? getConfigPath(),
+            packageVersion: readPackageVersion(),
+            writer,
+            openUrl,
+            prompt: promptUser,
+        });
+        return result.exitCode;
+    }
+    catch (error) {
+        if (error instanceof CliError) {
+            writer.stderr(error.message);
+            return error.exitCode;
+        }
+        writer.stderr("Unexpected error");
+        return ExitCode.ApiError;
+    }
+}
+async function openUrl(url) {
+    const command = getOpenCommand(url);
+    const child = spawn(command.command, command.args, {
+        stdio: "ignore",
+    });
+    await new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("close", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Browser opener exited with code ${code ?? "unknown"}`));
+            }
+        });
+    });
+}
+async function promptUser(message) {
+    const readline = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return await readline.question(message);
+    }
+    finally {
+        readline.close();
+    }
+}
+function parseGlobalOptions(args) {
+    const commandArgs = [];
+    let configPath;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--config") {
+            const value = args[index + 1];
+            if (value === undefined || value.startsWith("--")) {
+                throw createInvalidUsageError("Usage: slug --config <file> <command>");
+            }
+            configPath = value;
+            index += 1;
+            continue;
+        }
+        if (arg?.startsWith("--config=")) {
+            const value = arg.slice("--config=".length);
+            if (value === "") {
+                throw createInvalidUsageError("Usage: slug --config <file> <command>");
+            }
+            configPath = value;
+            continue;
+        }
+        commandArgs.push(arg);
+    }
+    return { commandArgs, configPath };
+}
+function getOpenCommand(url) {
+    if (process.platform === "darwin") {
+        return { command: "open", args: [url] };
+    }
+    if (process.platform === "win32") {
+        return { command: "cmd", args: ["/c", "start", url] };
+    }
+    return { command: "xdg-open", args: [url] };
+}
+function readPackageVersion() {
+    const packageJsonPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return packageJson.version;
+}
+if (process.argv[1] !== undefined &&
+    realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    process.exitCode = await main();
+}

package/dist/output.d.ts

@@ -0,0 +1,10 @@
+export interface OutputWriter {
+    stdout(message: string): void;
+    stderr(message: string): void;
+}
+export interface JsonOutput {
+    json: boolean;
+}
+export declare function createConsoleWriter(): OutputWriter;
+export declare function writeJson(writer: OutputWriter, value: unknown): void;
+export declare function redactSecret(value: string | undefined): string | undefined;

package/dist/output.js

@@ -0,0 +1,15 @@
+export function createConsoleWriter() {
+    return {
+        stdout: (message) => console.log(message),
+        stderr: (message) => console.error(message),
+    };
+}
+export function writeJson(writer, value) {
+    writer.stdout(JSON.stringify(value));
+}
+export function redactSecret(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return "[redacted]";
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@evcraddock/slug-cli",
+  "version": "0.2.0",
+  "description": "Command-line tool for Slugkit sites.",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "slug": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "node --import tsx src/index.ts",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run --config ../vitest.config.ts src",
+    "test:watch": "vitest --config ../vitest.config.ts src"
+  },
+  "dependencies": {
+    "tar": "^7.5.16"
+  }
+}