@youkno/edge-cli 1.20.2314

package/dist/lib/request.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStateHeader = buildStateHeader;
+exports.baseHeaders = baseHeaders;
+exports.checkedText = checkedText;
+function buildStateHeader(cfg) {
+    return `${cfg.product}.${cfg.env}`;
+}
+function baseHeaders(cfg, authHeader) {
+    const headers = {
+        "X-edge-state": buildStateHeader(cfg)
+    };
+    if (authHeader) {
+        headers.Authorization = authHeader;
+    }
+    return headers;
+}
+async function checkedText(response, context) {
+    const body = await response.text();
+    if (!response.ok) {
+        throw new Error(`${context} failed (${response.status}): ${body}`);
+    }
+    return body;
+}

package/dist/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@youkno/edge-cli",
+  "version": "1.20.2314",
+  "description": "Cross-platform Edge CLI",
+  "bin": "dist/index.js",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "commander": "^14.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.4.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2"
+  }
+}

package/src/commands/config.ts

@@ -0,0 +1,28 @@
+import { Command } from "commander";
+
+import { resolveEffectiveConfig } from "../lib/config";
+import { CliOptions } from "../lib/types";
+
+export function registerConfig(program: Command): void {
+    program
+        .command("config")
+        .description("Print effective configuration")
+        .option("--json", "Print as JSON")
+        .action(async function configAction(this: Command, commandOptions: { json?: boolean }) {
+            const parent = this.parent;
+            const opts = (parent?.opts() ?? {}) as CliOptions;
+            const resolved = await resolveEffectiveConfig(opts);
+
+            if (commandOptions.json) {
+                process.stdout.write(`${JSON.stringify(resolved, null, 2)}\n`);
+                return;
+            }
+
+            process.stdout.write(`product=${resolved.product}\n`);
+            process.stdout.write(`env=${resolved.env}\n`);
+            process.stdout.write(`baseUrl=${resolved.baseUrl}\n`);
+            process.stdout.write(`clientId=${resolved.clientId ?? ""}\n`);
+            process.stdout.write(`auth=${resolved.auth ? "<configured>" : ""}\n`);
+            process.stdout.write(`configFiles=${resolved.configFiles.join(",") || "<none>"}\n`);
+        });
+}

package/src/commands/healthCheck.ts

@@ -0,0 +1,35 @@
+import { Command } from "commander";
+
+import { resolveEffectiveConfig } from "../lib/config";
+import { getText, basicAuthHeader } from "../lib/http";
+import { CliOptions } from "../lib/types";
+
+export function registerHealthCheck(program: Command): void {
+    program
+        .command("health-check")
+        .description("Call /health_check on the selected API")
+        .option("--key <key>", "Health check key; can also come from HEALTH_CHECK_KEY")
+        .action(async function healthCheckAction(this: Command, commandOptions: { key?: string }) {
+            const parent = this.parent;
+            const opts = (parent?.opts() ?? {}) as CliOptions;
+            const resolved = await resolveEffectiveConfig(opts);
+            const key = commandOptions.key ?? process.env.HEALTH_CHECK_KEY;
+
+            if (!key) {
+                throw new Error("Missing health check key. Pass --key or set HEALTH_CHECK_KEY.");
+            }
+
+            const stateHeader = `${resolved.product}.${resolved.env}`;
+            const url = `${resolved.baseUrl.replace(/\/$/, "")}/health_check`;
+            const { status, body } = await getText(url, {
+                "X-edge-state": stateHeader,
+                Authorization: basicAuthHeader("api_user", key)
+            });
+
+            if (status >= 400) {
+                throw new Error(`Health check failed (${status}) for ${url}: ${body}`);
+            }
+
+            process.stdout.write(body.endsWith("\n") ? body : `${body}\n`);
+        });
+}

package/src/commands/login.ts

@@ -0,0 +1,59 @@
+import { Command } from "commander";
+
+import { login, listLogins, logout, setDefaultLogin } from "../lib/auth";
+import { resolveEffectiveConfig } from "../lib/config";
+import { CliOptions } from "../lib/types";
+
+export function registerLogin(program: Command): void {
+    program
+        .command("login")
+        .description("Authenticate via browser and store JWT tokens")
+        .action(async function loginAction(this: Command) {
+            const parent = this.parent;
+            const opts = (parent?.opts() ?? {}) as CliOptions;
+            const cfg = await resolveEffectiveConfig(opts);
+            const email = await login(cfg);
+            process.stdout.write(`Successfully authenticated as ${email}\n`);
+        });
+
+    program
+        .command("login:list")
+        .description("List saved accounts for current product/environment")
+        .action(async function listAction(this: Command) {
+            const parent = this.parent;
+            const opts = (parent?.opts() ?? {}) as CliOptions;
+            const cfg = await resolveEffectiveConfig(opts);
+            const accounts = listLogins(cfg);
+            if (accounts.length === 0) {
+                process.stdout.write(`No saved JWT session for ${cfg.product}/${cfg.env}.\n`);
+                return;
+            }
+            for (const account of accounts) {
+                process.stdout.write(`${account.isDefault ? "*" : " "} ${account.email}\n`);
+            }
+        });
+
+    program
+        .command("login:use")
+        .description("Set default account for current product/environment")
+        .argument("<email>")
+        .action(async function useAction(this: Command, email: string) {
+            const parent = this.parent;
+            const opts = (parent?.opts() ?? {}) as CliOptions;
+            const cfg = await resolveEffectiveConfig(opts);
+            setDefaultLogin(cfg, email);
+            process.stdout.write(`Default account: ${email}\n`);
+        });
+
+    program
+        .command("logout")
+        .description("Logout account (default if not provided)")
+        .argument("[email]")
+        .action(async function logoutAction(this: Command, email?: string) {
+            const parent = this.parent;
+            const opts = (parent?.opts() ?? {}) as CliOptions;
+            const cfg = await resolveEffectiveConfig(opts);
+            const removed = await logout(cfg, email);
+            process.stdout.write(`Logged out: ${removed}\n`);
+        });
+}

package/src/commands/product.ts

@@ -0,0 +1,24 @@
+import { Command } from "commander";
+
+import { setDefaultProduct } from "../lib/config";
+
+export function registerProduct(program: Command): void {
+    program
+        .command("product:default")
+        .description("Set or clear default PRODUCT in .edge-api")
+        .argument("[product]", "Product key (e.g. belong, stash, alleaves)")
+        .option("--file <path>", "Target edge-api config file (default: ~/.edge-api)")
+        .option("--clear", "Remove PRODUCT from target .edge-api file")
+        .action(function productDefaultAction(product: string | undefined, options: { file?: string; clear?: boolean }) {
+            if (!options.clear && !product) {
+                throw new Error("Missing product. Pass <product> or use --clear.");
+            }
+
+            const target = setDefaultProduct(options.clear ? undefined : product, options.file);
+            if (options.clear) {
+                process.stdout.write(`Cleared PRODUCT in ${target}\n`);
+            } else {
+                process.stdout.write(`Set PRODUCT=${(product ?? "").toLowerCase()} in ${target}\n`);
+            }
+        });
+}

package/src/commands/shell.ts

@@ -0,0 +1,213 @@
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+
+import { Command } from "commander";
+
+import { resolveAuthHeader } from "../lib/auth";
+import { resolveEffectiveConfig } from "../lib/config";
+import { baseHeaders, checkedText } from "../lib/request";
+import { CliOptions, EffectiveConfig } from "../lib/types";
+
+type ShellOptions = {
+    json?: boolean;
+    dryRun?: boolean;
+    validate?: boolean;
+    continueOnError?: boolean;
+    requestId?: string;
+    vars?: string[];
+};
+
+function resolveInlineScript(script: string, vars?: string[]): string {
+    const header = (vars ?? []).join("\n");
+    return header ? `${header}\n${script}\n` : `${script}\n`;
+}
+
+function renderEsh(filePath: string, stack: string[] = []): string {
+    const absolutePath = path.resolve(filePath);
+    if (stack.includes(absolutePath)) {
+        throw new Error(`Circular include detected: ${absolutePath}`);
+    }
+    if (!fs.existsSync(absolutePath)) {
+        throw new Error(`Script file not found: ${absolutePath}`);
+    }
+
+    const lines = fs.readFileSync(absolutePath, "utf8").split(/\r?\n/);
+    const out: string[] = [];
+    const nextStack = [...stack, absolutePath];
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        const trimmed = line.trim();
+        if (trimmed.startsWith("include ")) {
+            let includePath = trimmed.replace(/^include\s+/, "").trim();
+            if ((includePath.startsWith('"') && includePath.endsWith('"')) || (includePath.startsWith("'") && includePath.endsWith("'"))) {
+                includePath = includePath.slice(1, -1);
+            }
+            if (!includePath) {
+                throw new Error(`Missing include path in ${absolutePath}:${i + 1}`);
+            }
+            const includeFile = path.isAbsolute(includePath)
+                ? includePath
+                : path.resolve(path.dirname(absolutePath), includePath);
+            out.push(renderEsh(includeFile, nextStack));
+            continue;
+        }
+        out.push(line);
+    }
+
+    return out.join("\n");
+}
+
+async function shellCmd(cfg: EffectiveConfig, authHeader: string, cmd: string, wantJson: boolean) {
+    const url = new URL(`${cfg.baseUrl.replace(/\/$/, "")}/shell`);
+    url.searchParams.set("cmd", cmd);
+
+    const headers = baseHeaders(cfg, authHeader) as Record<string, string>;
+    if (wantJson) {
+        headers.Accept = "application/json";
+    }
+
+    const response = await fetch(url, {
+        method: "GET",
+        headers
+    });
+    const body = await checkedText(response, "shell");
+
+    if (wantJson) {
+        try {
+            const parsed = JSON.parse(body);
+            process.stdout.write(`${JSON.stringify(parsed, null, 2)}\n`);
+            return;
+        } catch {
+            // fall through
+        }
+    }
+    process.stdout.write(body.endsWith("\n") ? body : `${body}\n`);
+}
+
+async function shellScript(
+    cfg: EffectiveConfig,
+    authHeader: string,
+    scriptText: string,
+    options: ShellOptions,
+    scriptName = "inline.esh"
+) {
+    const url = new URL(`${cfg.baseUrl.replace(/\/$/, "")}/shell/script`);
+    url.searchParams.set("scriptName", scriptName);
+    url.searchParams.set("dryRun", String(Boolean(options.dryRun || options.validate)));
+    url.searchParams.set("continueOnError", String(Boolean(options.continueOnError)));
+    if (options.requestId) {
+        url.searchParams.set("requestId", options.requestId);
+    }
+
+    const headers = baseHeaders(cfg, authHeader) as Record<string, string>;
+    headers["Content-Type"] = "text/plain";
+    if (options.json) {
+        headers.Accept = "application/json";
+    }
+
+    const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: scriptText
+    });
+    const body = await checkedText(response, "shell script");
+
+    if (options.json) {
+        try {
+            const parsed = JSON.parse(body);
+            process.stdout.write(`${JSON.stringify(parsed, null, 2)}\n`);
+            return;
+        } catch {
+            // fall through
+        }
+    }
+    process.stdout.write(body.endsWith("\n") ? body : `${body}\n`);
+}
+
+async function repl(cfg: EffectiveConfig, authHeader: string, options: ShellOptions) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true
+    });
+
+    process.stdout.write("Type Ctrl-D to exit, 'help' for help\n");
+    rl.setPrompt(`${cfg.env}> `);
+    rl.prompt();
+
+    rl.on("line", async (line) => {
+        const cmd = line.trim();
+        if (!cmd) {
+            rl.prompt();
+            return;
+        }
+        try {
+            await shellCmd(cfg, authHeader, cmd, Boolean(options.json));
+        } catch (err) {
+            process.stderr.write(`ERROR: ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+        rl.prompt();
+    });
+
+    await new Promise<void>((resolve) => {
+        rl.on("close", () => {
+            process.stdout.write("\n");
+            resolve();
+        });
+    });
+}
+
+export function registerShell(program: Command): void {
+    program
+        .command("shell")
+        .description("Run shell command/script against Edge API")
+        .option("--json", "request JSON output when available")
+        .option("--dry-run", "run script in dry-run mode")
+        .option("--validate", "alias for --dry-run")
+        .option("--continue-on-error", "continue script execution on errors")
+        .option("--request-id <id>", "request ID")
+        .option("-v, --var <key=value>", "script variable", (value: string, prev: string[] = []) => {
+            if (!value.includes("=")) {
+                throw new Error(`Invalid variable assignment: ${value} (expected key=value)`);
+            }
+            prev.push(value);
+            return prev;
+        })
+        .argument("[target]", "Command or .esh file")
+        .argument("[inlineScript...]", "Inline script chunks when using --")
+        .action(async function shellAction(this: Command, target?: string, inlineScript?: string[]) {
+            const parent = this.parent;
+            const rootOpts = (parent?.opts() ?? {}) as CliOptions;
+            const cfg = await resolveEffectiveConfig(rootOpts);
+            const options = this.opts<ShellOptions>();
+            const authHeader = await resolveAuthHeader(cfg);
+
+            if (!target && (!inlineScript || inlineScript.length === 0)) {
+                await repl(cfg, authHeader, options);
+                return;
+            }
+
+            if (target?.endsWith(".esh")) {
+                const rendered = renderEsh(target);
+                const payload = resolveInlineScript(rendered, options.vars);
+                await shellScript(cfg, authHeader, payload, options, path.basename(target));
+                return;
+            }
+
+            if (inlineScript && inlineScript.length > 0) {
+                const payload = resolveInlineScript(inlineScript.join(" "), options.vars);
+                await shellScript(cfg, authHeader, payload, options, "inline.esh");
+                return;
+            }
+
+            if (options.dryRun || options.validate || options.continueOnError || options.requestId || (options.vars?.length ?? 0) > 0) {
+                const payload = resolveInlineScript(target ?? "", options.vars);
+                await shellScript(cfg, authHeader, payload, options, "inline.esh");
+                return;
+            }
+
+            await shellCmd(cfg, authHeader, target ?? "", Boolean(options.json));
+        });
+}

package/src/commands/token.ts

@@ -0,0 +1,26 @@
+import { Command } from "commander";
+
+import { resolveAccessToken } from "../lib/auth";
+import { resolveEffectiveConfig } from "../lib/config";
+import { CliOptions } from "../lib/types";
+
+export function registerToken(program: Command): void {
+    program
+        .command("token")
+        .description("Print a JWT access token for API calls (e.g. Postman)")
+        .option("--refresh", "Force refresh using refresh token when available")
+        .option("--header", "Print as Authorization header line")
+        .action(async function tokenAction(this: Command, commandOptions: { refresh?: boolean; header?: boolean }) {
+            const parent = this.parent;
+            const opts = (parent?.opts() ?? {}) as CliOptions;
+            const cfg = await resolveEffectiveConfig(opts);
+            const token = await resolveAccessToken(cfg, Boolean(commandOptions.refresh));
+
+            if (commandOptions.header) {
+                process.stdout.write(`Authorization: Bearer ${token}\n`);
+                return;
+            }
+
+            process.stdout.write(`${token}\n`);
+        });
+}

package/src/commands/uploadUsers.ts

@@ -0,0 +1,63 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { Command } from "commander";
+
+import { resolveAuthHeader } from "../lib/auth";
+import { resolveEffectiveConfig } from "../lib/config";
+import { baseHeaders, checkedText } from "../lib/request";
+import { CliOptions } from "../lib/types";
+
+export function registerUploadUsers(program: Command): void {
+    program
+        .command("upload-users")
+        .description("Upload users CSV for a client")
+        .option("-q, --quiet", "quiet mode")
+        .option("-l, --lenient", "lenient parser mode")
+        .option("-p, --partial", "partial mode")
+        .argument("<file>", "CSV file")
+        .action(async function uploadUsersAction(
+            this: Command,
+            file: string,
+            commandOptions: { quiet?: boolean; lenient?: boolean; partial?: boolean }
+        ) {
+            const parent = this.parent;
+            const opts = (parent?.opts() ?? {}) as CliOptions;
+            const cfg = await resolveEffectiveConfig(opts);
+
+            if (!cfg.clientId) {
+                throw new Error("No client ID specified. Pass --client or set CLIENT_ID in .edge-api.");
+            }
+
+            const absoluteFile = path.resolve(process.cwd(), file);
+            if (!fs.existsSync(absoluteFile)) {
+                throw new Error(`File not found: ${absoluteFile}`);
+            }
+
+            const authHeader = await resolveAuthHeader(cfg);
+            const url = new URL(`${cfg.baseUrl.replace(/\/$/, "")}/api/v1/clients/${cfg.clientId}/users`);
+            url.searchParams.set("dummy", "true");
+            if (commandOptions.partial) {
+                url.searchParams.set("partial", "true");
+            }
+            if (commandOptions.lenient) {
+                url.searchParams.set("lenient", "true");
+            }
+            if (commandOptions.quiet) {
+                url.searchParams.set("quiet", "true");
+            }
+
+            const data = fs.readFileSync(absoluteFile);
+            const form = new FormData();
+            form.append("file", new Blob([data], { type: "text/csv" }), path.basename(absoluteFile));
+
+            const response = await fetch(url, {
+                method: "POST",
+                headers: baseHeaders(cfg, authHeader),
+                body: form
+            });
+
+            const body = await checkedText(response, "upload-users");
+            process.stdout.write(body.endsWith("\n") ? body : `${body}\n`);
+        });
+}

package/src/default-edge-api-config.json

@@ -0,0 +1,61 @@
+{
+  "api": {
+    "defaultBaseUrl": "https://api.youkno.ai",
+    "products": {
+      "youkno": {
+        "baseUrl": "https://api.youkno.ai",
+        "active": false,
+        "aliases": ["belong"],
+        "consoleBaseProd": "https://belong-prod.web.app",
+        "consoleBaseTest": "https://belong-prod--testapp-q8kk4dm6.web.app"
+      },
+      "stash": {
+        "baseUrl": "https://api.mystash.co",
+        "active": false,
+        "aliases": [],
+        "consoleBaseProd": "https://stash-prod.web.app",
+        "consoleBaseTest": "https://stash-prod--testapp-ef23abcf.web.app"
+      },
+      "alleaves": {
+        "baseUrl": "https://api.alleaves.shop",
+        "active": true,
+        "aliases": [],
+        "consoleBaseProd": "https://console.alleaves.shop",
+        "consoleBaseTest": "https://alleaves-prod--testapp-vn1b2q7v.web.app"
+      },
+      "vera": {
+        "baseUrl": "https://edge-server-dfkcix6pxa-uc.a.run.app",
+        "active": false,
+        "aliases": [],
+        "consoleBaseProd": "https://vera-af0c2.web.app",
+        "consoleBaseTest": "https://vera-af0c2--testapp-23e7fe3c.web.app"
+      },
+      "vip": {
+        "baseUrl": "https://edge-server-a465iqwona-uc.a.run.app",
+        "active": false,
+        "aliases": [],
+        "consoleBaseProd": "https://vip-app-6a3d4.web.app",
+        "consoleBaseTest": "https://vip-app-6a3d4--testapp-h34bc19a.web.app"
+      },
+      "dinamo1948": {
+        "baseUrl": "https://api.dinamo1948.ro",
+        "active": true,
+        "aliases": [],
+        "consoleBaseProd": "https://console.dinamo1948.ro",
+        "consoleBaseTest": "https://dinamo1948-prod--testapp-f48fznbf.web.app"
+      },
+      "propatrimonio": {
+        "baseUrl": "https://api.propatrimonio.org",
+        "active": true,
+        "aliases": []
+      },
+      "campaigns": {
+        "baseUrl": "https://api.getcampaigns.com",
+        "active": true,
+        "aliases": [],
+        "consoleBaseProd": "https://console.getcampaigns.com",
+        "consoleBaseTest": "https://campaigns-abd4a--testapp-ht9twxoz.web.app"
+      }
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+
+import { registerConfig } from "./commands/config";
+import { registerHealthCheck } from "./commands/healthCheck";
+import { registerLogin } from "./commands/login";
+import { registerProduct } from "./commands/product";
+import { registerShell } from "./commands/shell";
+import { registerToken } from "./commands/token";
+import { registerUploadUsers } from "./commands/uploadUsers";
+import { CliEnv } from "./lib/types";
+
+const program = new Command();
+
+program
+    .name("edge-cli")
+    .description("Edge API command line client")
+    .version("0.2.0")
+    .option("-p, --product <product>", "Product key (youkno, stash, alleaves, ...)")
+    .option("--env <env>", "Environment (devlocal|devel|prod)", "prod")
+    .option("--base-url <url>", "Override API base URL")
+    .option("--client <clientId>", "Client ID")
+    .option("--auth <token:secret>", "Client auth token")
+    .option("--config-path <path>", "Additional edge-api style config file")
+    .hook("preAction", (command) => {
+        const env = command.opts().env as string;
+        const validEnvs: CliEnv[] = ["devlocal", "devel", "prod"];
+        if (!validEnvs.includes(env as CliEnv)) {
+            throw new Error(`Invalid --env '${env}'. Expected one of: ${validEnvs.join(", ")}`);
+        }
+    });
+
+registerConfig(program);
+registerHealthCheck(program);
+registerProduct(program);
+registerLogin(program);
+registerToken(program);
+registerShell(program);
+registerUploadUsers(program);
+
+program.parseAsync(process.argv).catch((error) => {
+    process.stderr.write(`ERROR: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+});