@podge/cli 0.2.0-beta.0

package/dist/commands/items.js

@@ -0,0 +1,170 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerItemCommands = void 0;
+const fs = __importStar(require("fs"));
+const client_1 = require("../lib/client");
+const config_1 = require("../lib/config");
+const output_1 = require("../lib/output");
+const chalk_1 = __importDefault(require("chalk"));
+function requireFullContext(opts) {
+    const cfg = (0, config_1.getConfig)();
+    const ws = opts.workspace || cfg.workspace;
+    const env = opts.environment || cfg.environment;
+    const col = opts.collection;
+    if (!ws || !env || !col) {
+        console.error(chalk_1.default.red("Workspace, environment, and collection required. Use flags or `podge config set`."));
+        process.exit(1);
+    }
+    return { ws, env, col };
+}
+function registerItemCommands(program) {
+    const items = program.command("items").description("Manage collection items");
+    items
+        .command("create")
+        .description("Create an item from JSON")
+        .requiredOption("-c, --collection <key>", "Collection key")
+        .option("-w, --workspace <key>", "Workspace key")
+        .option("-e, --environment <key>", "Environment key")
+        .option("-f, --file <path>", "JSON file path")
+        .option("-d, --data <json>", "Inline JSON data")
+        .option("--dry-run", "Validate without persisting")
+        .action(async (opts) => {
+        try {
+            const { ws, env, col } = requireFullContext(opts);
+            let body;
+            if (opts.file) {
+                body = JSON.parse(fs.readFileSync(opts.file, "utf-8"));
+            }
+            else if (opts.data) {
+                body = JSON.parse(opts.data);
+            }
+            else {
+                console.error(chalk_1.default.red("Provide --file or --data"));
+                process.exit(1);
+            }
+            const url = `/api/v1/workspace/${ws}/environment/${env}/collection/${col}/item${opts.dryRun ? "?dryRun=true" : ""}`;
+            const { data } = await (0, client_1.getClient)().post(url, body);
+            if (opts.dryRun) {
+                (0, output_1.printSuccess)("Dry run successful");
+            }
+            else {
+                (0, output_1.printSuccess)("Item created");
+            }
+            (0, output_1.printJson)(data);
+        }
+        catch (err) {
+            (0, client_1.handleError)(err);
+        }
+    });
+    items
+        .command("get <documentId>")
+        .description("Get a document by ID")
+        .requiredOption("-c, --collection <key>", "Collection key")
+        .option("-w, --workspace <key>", "Workspace key")
+        .option("-e, --environment <key>", "Environment key")
+        .action(async (documentId, opts) => {
+        try {
+            const { ws, env, col } = requireFullContext(opts);
+            const { data } = await (0, client_1.getClient)().get(`/api/v1/workspace/${ws}/environment/${env}/collection/${col}/document/${documentId}`);
+            (0, output_1.printJson)(data);
+        }
+        catch (err) {
+            (0, client_1.handleError)(err);
+        }
+    });
+    items
+        .command("import")
+        .description("Create a bulk import job from a file")
+        .requiredOption("-c, --collection <key>", "Collection key")
+        .requiredOption("-f, --file <path>", "JSON file with items array")
+        .option("-w, --workspace <key>", "Workspace key")
+        .option("-e, --environment <key>", "Environment key")
+        .action(async (opts) => {
+        try {
+            const { ws, env, col } = requireFullContext(opts);
+            const body = JSON.parse(fs.readFileSync(opts.file, "utf-8"));
+            const items = Array.isArray(body) ? body : body.items || [body];
+            const url = `/api/v1/workspace/${ws}/environment/${env}/collection/${col}/items`;
+            const { data } = await (0, client_1.getClient)().post(url, { items });
+            (0, output_1.printSuccess)(`Batch import submitted (${items.length} items)`);
+            (0, output_1.printJson)(data);
+        }
+        catch (err) {
+            (0, client_1.handleError)(err);
+        }
+    });
+    items
+        .command("delete <documentId>")
+        .description("Delete a document by ID")
+        .requiredOption("-c, --collection <slug>", "Collection slug")
+        .option("-w, --workspace <slug>", "Workspace slug")
+        .option("-e, --environment <slug>", "Environment slug")
+        .action(async (documentId, opts) => {
+        try {
+            const { ws, env, col } = requireFullContext(opts);
+            const { data } = await (0, client_1.getClient)().delete(`/api/v1/workspace/${ws}/environment/${env}/collection/${col}/document/${documentId}`);
+            (0, output_1.printSuccess)(`Document ${documentId} deleted`);
+            (0, output_1.printJson)(data);
+        }
+        catch (err) {
+            (0, client_1.handleError)(err);
+        }
+    });
+    items
+        .command("update <documentId>")
+        .description("Update a document by ID")
+        .requiredOption("-c, --collection <slug>", "Collection slug")
+        .option("-w, --workspace <slug>", "Workspace slug")
+        .option("-e, --environment <slug>", "Environment slug")
+        .option("-f, --file <path>", "JSON file path")
+        .option("-d, --data <json>", "Inline JSON data")
+        .action(async (documentId, opts) => {
+        try {
+            const { ws, env, col } = requireFullContext(opts);
+            let body;
+            if (opts.file) {
+                body = JSON.parse(fs.readFileSync(opts.file, "utf-8"));
+            }
+            else if (opts.data) {
+                body = JSON.parse(opts.data);
+            }
+            else {
+                console.error(chalk_1.default.red("Provide --file or --data"));
+                process.exit(1);
+            }
+            const { data } = await (0, client_1.getClient)().patch(`/api/v1/workspace/${ws}/environment/${env}/collection/${col}/document/${documentId}`, body);
+            (0, output_1.printSuccess)(`Document ${documentId} update submitted`);
+            (0, output_1.printJson)(data);
+        }
+        catch (err) {
+            (0, client_1.handleError)(err);
+        }
+    });
+}
+exports.registerItemCommands = registerItemCommands;

package/dist/commands/search.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerSearchCommands(program: Command): void;

package/dist/commands/search.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSearchCommands = void 0;
+const client_1 = require("../lib/client");
+const config_1 = require("../lib/config");
+const output_1 = require("../lib/output");
+const chalk_1 = __importDefault(require("chalk"));
+function registerSearchCommands(program) {
+    const search = program
+        .command("search <query>")
+        .description("Search a collection")
+        .requiredOption("-c, --collection <key>", "Collection key")
+        .option("-w, --workspace <key>", "Workspace key")
+        .option("-e, --environment <key>", "Environment key")
+        .option("--json", "Output as JSON")
+        .option("--no-cache", "Bypass query cache")
+        .option("--mode <mode>", "Search mode: keyword, semantic, or hybrid")
+        .action(async (query, opts) => {
+        try {
+            const cfg = (0, config_1.getConfig)();
+            const ws = opts.workspace || cfg.workspace;
+            const env = opts.environment || cfg.environment;
+            const col = opts.collection;
+            if (!ws || !env || !col) {
+                console.error(chalk_1.default.red("Workspace, environment, and collection required."));
+                process.exit(1);
+            }
+            const headers = {};
+            if (opts.noCache === false) {
+                headers["x-no-query-cache"] = "true";
+            }
+            const body = { search: query };
+            if (opts.mode) {
+                body.options = { mode: opts.mode };
+            }
+            const { data } = await (0, client_1.getClient)().post(`/api/v1/workspace/${ws}/environment/${env}/collection/${col}/search`, body, { headers });
+            if (opts.json) {
+                (0, output_1.printJson)(data);
+            }
+            else {
+                const hits = data.hits || data.results || data;
+                if (Array.isArray(hits) && hits.length > 0) {
+                    const keys = Object.keys(hits[0]).slice(0, 5);
+                    const rows = hits.map((h) => keys.map((k) => String(h[k] ?? "")));
+                    (0, output_1.printTable)(keys.map((k) => k.toUpperCase()), rows);
+                }
+                else {
+                    console.log("No results found.");
+                }
+            }
+        }
+        catch (err) {
+            (0, client_1.handleError)(err);
+        }
+    });
+}
+exports.registerSearchCommands = registerSearchCommands;

package/dist/commands/workspaces.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerWorkspaceCommands(program: Command): void;

package/dist/commands/workspaces.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWorkspaceCommands = void 0;
+const client_1 = require("../lib/client");
+const output_1 = require("../lib/output");
+function registerWorkspaceCommands(program) {
+    const ws = program
+        .command("workspaces")
+        .alias("ws")
+        .description("Manage workspaces");
+    ws.command("list")
+        .description("List all workspaces")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        try {
+            const { data } = await (0, client_1.getClient)().get("/api/v1/workspaces");
+            if (opts.json) {
+                (0, output_1.printJson)(data);
+            }
+            else {
+                const rows = (Array.isArray(data) ? data : [data]).map((w) => [
+                    String(w.id),
+                    w.key,
+                    w.name,
+                ]);
+                (0, output_1.printTable)(["ID", "KEY", "NAME"], rows);
+            }
+        }
+        catch (err) {
+            (0, client_1.handleError)(err);
+        }
+    });
+    ws.command("get <key>")
+        .description("Get workspace details")
+        .option("--json", "Output as JSON")
+        .action(async (key, opts) => {
+        try {
+            const { data } = await (0, client_1.getClient)().get(`/api/v1/workspace/${key}`);
+            if (opts.json) {
+                (0, output_1.printJson)(data);
+            }
+            else {
+                console.log(`Name: ${data.name}`);
+                console.log(`Key: ${data.key}`);
+                console.log(`Description: ${data.description || "(none)"}`);
+            }
+        }
+        catch (err) {
+            (0, client_1.handleError)(err);
+        }
+    });
+}
+exports.registerWorkspaceCommands = registerWorkspaceCommands;

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const auth_1 = require("./commands/auth");
+const config_1 = require("./commands/config");
+const workspaces_1 = require("./commands/workspaces");
+const environments_1 = require("./commands/environments");
+const collections_1 = require("./commands/collections");
+const items_1 = require("./commands/items");
+const search_1 = require("./commands/search");
+const apikeys_1 = require("./commands/apikeys");
+const debug_1 = require("./commands/debug");
+const pkg = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, "..", "package.json"), "utf-8"));
+const program = new commander_1.Command();
+program
+    .name("podge")
+    .description("Podge CLI — manage workspaces, collections, and search")
+    .version(pkg.version);
+(0, auth_1.registerAuthCommands)(program);
+(0, config_1.registerConfigCommands)(program);
+(0, workspaces_1.registerWorkspaceCommands)(program);
+(0, environments_1.registerEnvironmentCommands)(program);
+(0, collections_1.registerCollectionCommands)(program);
+(0, items_1.registerItemCommands)(program);
+(0, search_1.registerSearchCommands)(program);
+(0, apikeys_1.registerApiKeyCommands)(program);
+(0, debug_1.registerDebugCommands)(program);
+program.parse();

package/dist/lib/auth-server.d.ts

@@ -0,0 +1,7 @@
+export interface AuthResult {
+    token: string;
+}
+export declare function startAuthServer(expectedState: string, timeoutMs?: number): Promise<{
+    port: number;
+    tokenPromise: Promise<AuthResult>;
+}>;

package/dist/lib/auth-server.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startAuthServer = void 0;
+const http = __importStar(require("http"));
+const url = __importStar(require("url"));
+function startAuthServer(expectedState, timeoutMs = 120000) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const server = http.createServer();
+        const tokenPromise = new Promise((resToken, rejToken) => {
+            const timer = setTimeout(() => {
+                if (!settled) {
+                    settled = true;
+                    server.close();
+                    rejToken(new Error("Authentication timed out after 120 seconds."));
+                }
+            }, timeoutMs);
+            server.on("request", (req, res) => {
+                const parsed = url.parse(req.url ?? "", true);
+                if (parsed.pathname !== "/callback") {
+                    res.writeHead(404);
+                    res.end("Not found");
+                    return;
+                }
+                const { token, state, error } = parsed.query;
+                // Always respond with HTML
+                res.writeHead(200, { "Content-Type": "text/html" });
+                if (error) {
+                    res.end("<html><body><h2>Authentication failed</h2><p>You can close this tab.</p></body></html>");
+                    clearTimeout(timer);
+                    settled = true;
+                    server.close();
+                    rejToken(new Error(`Authentication failed: ${error}`));
+                    return;
+                }
+                if (state !== expectedState) {
+                    res.end("<html><body><h2>Authentication failed</h2><p>Invalid state parameter.</p></body></html>");
+                    clearTimeout(timer);
+                    settled = true;
+                    server.close();
+                    rejToken(new Error("Invalid state parameter — possible CSRF attack."));
+                    return;
+                }
+                if (!token) {
+                    res.end("<html><body><h2>Authentication failed</h2><p>No token received.</p></body></html>");
+                    clearTimeout(timer);
+                    settled = true;
+                    server.close();
+                    rejToken(new Error("No token received from the browser."));
+                    return;
+                }
+                res.end("<html><body><h2>Authentication successful!</h2><p>You can close this tab and return to the terminal.</p></body></html>");
+                clearTimeout(timer);
+                settled = true;
+                server.close();
+                resToken({ token });
+            });
+        });
+        server.listen(0, "127.0.0.1", () => {
+            const addr = server.address();
+            if (!addr || typeof addr === "string") {
+                reject(new Error("Failed to start auth server"));
+                return;
+            }
+            resolve({ port: addr.port, tokenPromise });
+        });
+        server.on("error", (err) => {
+            reject(err);
+        });
+    });
+}
+exports.startAuthServer = startAuthServer;

package/dist/lib/client.d.ts

@@ -0,0 +1,3 @@
+import { AxiosInstance } from "axios";
+export declare function getClient(): AxiosInstance;
+export declare function handleError(err: unknown): never;

package/dist/lib/client.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleError = exports.getClient = void 0;
+const axios_1 = __importStar(require("axios"));
+const config_1 = require("./config");
+const chalk_1 = __importDefault(require("chalk"));
+let clientInstance = null;
+function getClient() {
+    if (clientInstance)
+        return clientInstance;
+    const creds = (0, config_1.getCredentials)();
+    if (!creds) {
+        console.error(chalk_1.default.red("Not authenticated. Run `podge auth login` first."));
+        process.exit(1);
+    }
+    clientInstance = axios_1.default.create({
+        baseURL: creds.apiUrl,
+        headers: {
+            Authorization: `Bearer ${creds.token}`,
+            "Content-Type": "application/json",
+        },
+    });
+    return clientInstance;
+}
+exports.getClient = getClient;
+function handleError(err) {
+    if (err instanceof axios_1.AxiosError) {
+        const status = err.response?.status;
+        const data = err.response?.data;
+        const envelope = data?.error;
+        if (envelope) {
+            const code = envelope.code || "UNKNOWN";
+            const message = envelope.message || err.message;
+            console.error(chalk_1.default.red(`Error ${status} [${code}]: ${message}`));
+            if (envelope.details) {
+                console.error(chalk_1.default.dim(JSON.stringify(envelope.details, null, 2)));
+            }
+        }
+        else {
+            const message = data?.message || err.message;
+            console.error(chalk_1.default.red(`Error (${status}): ${message}`));
+        }
+    }
+    else if (err instanceof Error) {
+        console.error(chalk_1.default.red(`Error: ${err.message}`));
+    }
+    else {
+        console.error(chalk_1.default.red("An unexpected error occurred"));
+    }
+    process.exit(1);
+}
+exports.handleError = handleError;

package/dist/lib/config.d.ts

@@ -0,0 +1,18 @@
+export interface Credentials {
+    token: string;
+    apiUrl: string;
+}
+export interface Config {
+    workspace?: string;
+    environment?: string;
+    appUrl?: string;
+    apiUrl?: string;
+}
+export declare function getCredentials(): Credentials | null;
+export declare function saveCredentials(creds: Credentials): void;
+export declare function clearCredentials(): void;
+export declare function getConfig(): Config;
+export declare function saveConfig(config: Config): void;
+export declare function writeConfig(config: Config): void;
+export declare function getApiUrl(): string;
+export declare function getAppUrl(): string;

package/dist/lib/config.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppUrl = exports.getApiUrl = exports.writeConfig = exports.saveConfig = exports.getConfig = exports.clearCredentials = exports.saveCredentials = exports.getCredentials = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const CONFIG_DIR = path.join(os.homedir(), ".podge");
+const CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials.json");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function ensureConfigDir() {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+function getCredentials() {
+    if (!fs.existsSync(CREDENTIALS_FILE))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(CREDENTIALS_FILE, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+exports.getCredentials = getCredentials;
+function saveCredentials(creds) {
+    ensureConfigDir();
+    fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(creds, null, 2), {
+        mode: 0o600,
+    });
+}
+exports.saveCredentials = saveCredentials;
+function clearCredentials() {
+    if (fs.existsSync(CREDENTIALS_FILE)) {
+        fs.unlinkSync(CREDENTIALS_FILE);
+    }
+}
+exports.clearCredentials = clearCredentials;
+function getConfig() {
+    if (!fs.existsSync(CONFIG_FILE))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+exports.getConfig = getConfig;
+function saveConfig(config) {
+    ensureConfigDir();
+    const existing = getConfig();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify({ ...existing, ...config }, null, 2));
+}
+exports.saveConfig = saveConfig;
+function writeConfig(config) {
+    ensureConfigDir();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+exports.writeConfig = writeConfig;
+const DEFAULT_API_URL = "https://dev.podge.dev/api";
+const DEFAULT_APP_URL = "https://app.podge.io";
+function getApiUrl() {
+    const config = getConfig();
+    return config.apiUrl ?? DEFAULT_API_URL;
+}
+exports.getApiUrl = getApiUrl;
+function getAppUrl() {
+    const config = getConfig();
+    return config.appUrl ?? DEFAULT_APP_URL;
+}
+exports.getAppUrl = getAppUrl;

package/dist/lib/open-browser.d.ts

@@ -0,0 +1 @@
+export declare function openBrowser(url: string): void;

package/dist/lib/open-browser.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openBrowser = void 0;
+const child_process_1 = require("child_process");
+function openBrowser(url) {
+    const cmd = process.platform === "darwin"
+        ? "open"
+        : process.platform === "win32"
+            ? "start"
+            : "xdg-open";
+    (0, child_process_1.exec)(`${cmd} "${url}"`, (err) => {
+        if (err) {
+            console.log(`Open this URL in your browser:\n  ${url}`);
+        }
+    });
+}
+exports.openBrowser = openBrowser;

package/dist/lib/output.d.ts

@@ -0,0 +1,4 @@
+export declare function printTable(headers: string[], rows: string[][]): void;
+export declare function printJson(data: unknown): void;
+export declare function printSuccess(message: string): void;
+export declare function printInfo(message: string): void;