@youkno/edge-cli 1.20.2314

package/src/lib/config.ts

@@ -0,0 +1,253 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline/promises";
+
+import bundledApiConfig from "../default-edge-api-config.json";
+import { CliEnv, CliOptions, EdgeApiConfig, EffectiveConfig, ProductConfig } from "./types";
+
+const EDGE_API_CONFIG_URL = "https://cdn.youkno.ai/tools/edge-api-config.json";
+const DEFAULT_EDGE_API_PATH = path.join(os.homedir(), ".edge-api");
+
+const FILE_KEYS = ["PRODUCT", "ENV", "BASE_URL", "CLIENT_ID", "CLIENT_AUTH"] as const;
+
+type EdgeApiFileConfig = Partial<Record<(typeof FILE_KEYS)[number], string>>;
+
+function expandPath(inputPath: string): string {
+    if (inputPath.startsWith("~/")) {
+        return path.join(os.homedir(), inputPath.slice(2));
+    }
+    if (inputPath === "~") {
+        return os.homedir();
+    }
+    return inputPath;
+}
+
+function parseEdgeApiFile(filePath: string): EdgeApiFileConfig {
+    const out: EdgeApiFileConfig = {};
+    if (!fs.existsSync(filePath)) {
+        return out;
+    }
+
+    const content = fs.readFileSync(filePath, "utf8");
+    const lines = content.split(/\r?\n/);
+    for (const lineRaw of lines) {
+        const line = lineRaw.trim();
+        if (!line || line.startsWith("#")) {
+            continue;
+        }
+
+        const eqIndex = line.indexOf("=");
+        if (eqIndex <= 0) {
+            continue;
+        }
+
+        const key = line.slice(0, eqIndex).trim();
+        if (!FILE_KEYS.includes(key as (typeof FILE_KEYS)[number])) {
+            continue;
+        }
+
+        let value = line.slice(eqIndex + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+
+        out[key as (typeof FILE_KEYS)[number]] = value;
+    }
+
+    return out;
+}
+
+function toCliEnv(env?: string): CliEnv {
+    if (env === "devlocal" || env === "devel" || env === "prod") {
+        return env;
+    }
+    return "prod";
+}
+
+function resolveProductsConfig(): EdgeApiConfig {
+    const candidatePaths = [
+        process.env.EDGE_API_CONFIG_PATH ? path.resolve(expandPath(process.env.EDGE_API_CONFIG_PATH)) : undefined,
+        path.resolve(process.cwd(), "edge-api-config.json"),
+        path.resolve(process.cwd(), "..", "edge-api-config.json"),
+        path.resolve(__dirname, "..", "..", "..", "edge-api-config.json")
+    ].filter((p): p is string => Boolean(p));
+
+    for (const candidatePath of candidatePaths) {
+        if (!fs.existsSync(candidatePath)) {
+            continue;
+        }
+        try {
+            const content = fs.readFileSync(candidatePath, "utf8");
+            return JSON.parse(content) as EdgeApiConfig;
+        } catch {
+            // Try next candidate
+        }
+    }
+
+    return bundledApiConfig as EdgeApiConfig;
+}
+
+function findProduct(product: string, config: EdgeApiConfig): ProductConfig | undefined {
+    const products = config.api?.products ?? {};
+    if (products[product]) {
+        return products[product];
+    }
+    for (const productConfig of Object.values(products)) {
+        const aliases = productConfig.aliases ?? [];
+        if (aliases.includes(product)) {
+            return productConfig;
+        }
+    }
+    return undefined;
+}
+
+function listProducts(config: EdgeApiConfig): string[] {
+    const products = config.api?.products ?? {};
+    return Object.entries(products)
+        .filter(([, value]) => value.active !== false)
+        .map(([key]) => key)
+        .sort((a, b) => a.localeCompare(b));
+}
+
+async function selectProductInteractively(products: string[]): Promise<string> {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    try {
+        process.stdout.write("Select product:\n");
+        products.forEach((p, idx) => {
+            process.stdout.write(`  ${idx + 1}) ${p}\n`);
+        });
+
+        while (true) {
+            const inputRaw = await rl.question("Choose product number or name: ");
+            const input = inputRaw.trim().toLowerCase();
+            if (!input) {
+                continue;
+            }
+
+            if (/^\d+$/.test(input)) {
+                const index = Number(input) - 1;
+                if (index >= 0 && index < products.length) {
+                    return products[index];
+                }
+            }
+
+            if (products.includes(input)) {
+                return input;
+            }
+
+            process.stdout.write("Invalid selection.\n");
+        }
+    } finally {
+        rl.close();
+    }
+}
+
+function resolveProductBaseUrl(product: string, config: EdgeApiConfig): string | undefined {
+    const resolved = findProduct(product, config);
+    return resolved?.baseUrl ?? config.api?.defaultBaseUrl;
+}
+
+function resolveConsoleBaseUrl(product: string, env: CliEnv, config: EdgeApiConfig): string | undefined {
+    const resolved = findProduct(product, config);
+    if (!resolved) {
+        return undefined;
+    }
+    return env === "prod" ? resolved.consoleBaseProd : resolved.consoleBaseTest;
+}
+
+function readMergedFileConfig(options: CliOptions): { merged: EdgeApiFileConfig; usedFiles: string[] } {
+    const configFiles = [
+        "/etc/edge-api",
+        path.resolve(process.cwd(), ".edge-api"),
+        path.join(os.homedir(), ".edge-api")
+    ];
+
+    if (options.configPath) {
+        configFiles.unshift(path.resolve(process.cwd(), options.configPath));
+    }
+
+    const fileConfig = configFiles
+        .filter((filePath, index, arr) => arr.indexOf(filePath) === index)
+        .map((filePath) => ({ filePath, cfg: parseEdgeApiFile(filePath) }))
+        .filter((entry) => Object.keys(entry.cfg).length > 0);
+
+    const merged: EdgeApiFileConfig = {};
+    for (const entry of fileConfig) {
+        Object.assign(merged, entry.cfg);
+    }
+
+    return {
+        merged,
+        usedFiles: fileConfig.map((entry) => entry.filePath)
+    };
+}
+
+export async function resolveEffectiveConfig(options: CliOptions): Promise<EffectiveConfig> {
+    const { merged, usedFiles } = readMergedFileConfig(options);
+    const env = toCliEnv(options.env ?? merged.ENV);
+    const productsConfig = resolveProductsConfig();
+
+    let product = (options.product ?? merged.PRODUCT ?? "").trim().toLowerCase();
+    if (!product) {
+        if (process.stdin.isTTY && process.stdout.isTTY) {
+            const available = listProducts(productsConfig);
+            if (available.length > 0) {
+                product = await selectProductInteractively(available);
+            }
+        }
+    }
+
+    if (!product) {
+        throw new Error(
+            "No product specified. Pass --product <name>, set PRODUCT in ~/.edge-api, or run 'edge-cli product:default <name>'."
+        );
+    }
+
+    let baseUrl = options.baseUrl ?? merged.BASE_URL;
+    if (!baseUrl) {
+        if (env === "devlocal") {
+            baseUrl = "http://localhost:8080";
+        } else {
+            baseUrl = resolveProductBaseUrl(product, productsConfig);
+        }
+    }
+
+    if (!baseUrl) {
+        throw new Error(
+            `Unable to resolve base URL. Set --base-url, BASE_URL in .edge-api, or configure product '${product}' in edge-api-config.json (${EDGE_API_CONFIG_URL}).`
+        );
+    }
+
+    return {
+        product,
+        env,
+        baseUrl,
+        consoleBaseUrl: resolveConsoleBaseUrl(product, env, productsConfig),
+        clientId: options.clientId ?? merged.CLIENT_ID,
+        auth: options.auth ?? merged.CLIENT_AUTH,
+        configFiles: usedFiles
+    };
+}
+
+export function setDefaultProduct(product: string | undefined, filePath?: string): string {
+    const targetFile = path.resolve(expandPath(filePath ?? DEFAULT_EDGE_API_PATH));
+    const targetDir = path.dirname(targetFile);
+    fs.mkdirSync(targetDir, { recursive: true });
+
+    const existing = fs.existsSync(targetFile) ? fs.readFileSync(targetFile, "utf8") : "";
+    const lines = existing ? existing.split(/\r?\n/) : [];
+    const kept = lines.filter((line) => !line.trim().startsWith("PRODUCT="));
+
+    if (product && product.trim()) {
+        kept.push(`PRODUCT=${product.trim().toLowerCase()}`);
+    }
+
+    const content = kept.filter((line, idx, arr) => !(idx === arr.length - 1 && line === "")).join("\n");
+    fs.writeFileSync(targetFile, content ? `${content}\n` : "", "utf8");
+    return targetFile;
+}

package/src/lib/http.ts

@@ -0,0 +1,12 @@
+export function basicAuthHeader(username: string, password: string): string {
+    return `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`;
+}
+
+export async function getText(url: string, headers: Record<string, string>): Promise<{ status: number; body: string }> {
+    const response = await fetch(url, {
+        method: "GET",
+        headers
+    });
+    const body = await response.text();
+    return { status: response.status, body };
+}

package/src/lib/request.ts

@@ -0,0 +1,23 @@
+import { EffectiveConfig } from "./types";
+
+export function buildStateHeader(cfg: EffectiveConfig): string {
+    return `${cfg.product}.${cfg.env}`;
+}
+
+export function baseHeaders(cfg: EffectiveConfig, authHeader?: string): HeadersInit {
+    const headers: Record<string, string> = {
+        "X-edge-state": buildStateHeader(cfg)
+    };
+    if (authHeader) {
+        headers.Authorization = authHeader;
+    }
+    return headers;
+}
+
+export async function checkedText(response: Response, context: string): Promise<string> {
+    const body = await response.text();
+    if (!response.ok) {
+        throw new Error(`${context} failed (${response.status}): ${body}`);
+    }
+    return body;
+}

package/src/lib/types.ts

@@ -0,0 +1,35 @@
+export type CliEnv = "devlocal" | "devel" | "prod";
+
+export type CliOptions = {
+    product?: string;
+    env?: CliEnv;
+    baseUrl?: string;
+    clientId?: string;
+    auth?: string;
+    configPath?: string;
+};
+
+export type ProductConfig = {
+    baseUrl?: string;
+    active?: boolean;
+    aliases?: string[];
+    consoleBaseProd?: string;
+    consoleBaseTest?: string;
+};
+
+export type EdgeApiConfig = {
+    api?: {
+        defaultBaseUrl?: string;
+        products?: Record<string, ProductConfig>;
+    };
+};
+
+export type EffectiveConfig = {
+    product: string;
+    env: CliEnv;
+    baseUrl: string;
+    consoleBaseUrl?: string;
+    clientId?: string;
+    auth?: string;
+    configFiles: string[];
+};

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "strict": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*.ts", "src/**/*.json"]
+}