@podge/cli 0.2.0-beta.0

package/README.md

@@ -0,0 +1,97 @@
+# Podge CLI
+
+Command-line interface for managing Podge workspaces, environments, collections, and search.
+
+## Installation
+
+```sh
+npm install -g @podge/cli
+```
+
+That's it — the `podge` command is now available globally.
+
+## Quick Start
+
+```sh
+# Authenticate with your personal access token
+podge auth login --token pdgu_your_token_here
+
+# Set a default workspace and environment
+podge config set --workspace my-workspace --environment production
+
+# Start using it
+podge workspaces list
+podge search "my query" -c my-collection
+```
+
+## Authentication
+
+```sh
+podge auth login --token <token>   # Log in (token must start with pdgu_)
+podge auth login --token <token> --api-url https://custom.api.url
+podge auth status                  # Check auth status
+podge auth logout                  # Remove stored credentials
+```
+
+Credentials are stored in `~/.podge/credentials.json`.
+
+## Configuration
+
+Set defaults so you don't have to pass `-w` and `-e` on every command:
+
+```sh
+podge config set --workspace my-workspace --environment production
+podge config get
+```
+
+## Commands
+
+### Workspaces
+
+```sh
+podge workspaces list
+podge workspaces get <key>
+```
+
+### Environments
+
+```sh
+podge environments list
+podge environments get <key>
+```
+
+### Collections
+
+```sh
+podge collections list
+podge collections get <key>
+podge collections schema <key>
+```
+
+### Items
+
+```sh
+podge items create -c <collection> -d '{"field": "value"}'
+podge items create -c <collection> -f data.json
+podge items get <documentId> -c <collection>
+podge items import -c <collection> -f items.json
+```
+
+### Search
+
+```sh
+podge search "my query" -c <collection>
+podge search "my query" -c <collection> --json --no-cache
+```
+
+All commands support `-w <workspace>` and `-e <environment>` flags to override your configured defaults. Add `--json` to list/get commands for machine-readable output.
+
+Run `podge <command> --help` for detailed usage on any command.
+
+## Development
+
+```sh
+pnpm install    # Install deps + build
+pnpm dev        # Watch mode
+pnpm build      # One-off build
+```

package/dist/commands/apikeys.d.ts

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

package/dist/commands/apikeys.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerApiKeyCommands = 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 requireWorkspace(opts) {
+    const cfg = (0, config_1.getConfig)();
+    const ws = opts.workspace || cfg.workspace;
+    if (!ws) {
+        console.error(chalk_1.default.red("Workspace required. Use -w flag or `podge config set`."));
+        process.exit(1);
+    }
+    return ws;
+}
+function registerApiKeyCommands(program) {
+    const apikeys = program
+        .command("apikeys")
+        .alias("api-keys")
+        .description("Manage API keys");
+    apikeys
+        .command("list")
+        .description("List API keys")
+        .option("-w, --workspace <slug>", "Workspace slug")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        try {
+            const ws = requireWorkspace(opts);
+            const { data } = await (0, client_1.getClient)().get(`/api/v1/workspace/${ws}/api-keys`);
+            if (opts.json) {
+                (0, output_1.printJson)(data);
+            }
+            else {
+                const keys = Array.isArray(data) ? data : [];
+                if (keys.length === 0) {
+                    console.log("No API keys found.");
+                    return;
+                }
+                (0, output_1.printTable)(["ID", "NAME", "PREFIX", "REVOKED", "CREATED"], keys.map((k) => [
+                    String(k.id),
+                    k.name,
+                    k.keyPrefix,
+                    k.revoked ? "yes" : "no",
+                    k.createdAt,
+                ]));
+            }
+        }
+        catch (err) {
+            (0, client_1.handleError)(err);
+        }
+    });
+    apikeys
+        .command("create")
+        .description("Create an API key")
+        .requiredOption("--name <name>", "Key name")
+        .option("-e, --environment <slug>", "Scope to environment")
+        .option("-w, --workspace <slug>", "Workspace slug")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        try {
+            const ws = requireWorkspace(opts);
+            const body = {
+                name: opts.name,
+            };
+            if (opts.environment) {
+                body.environmentKey = opts.environment;
+            }
+            const { data } = await (0, client_1.getClient)().post(`/api/v1/workspace/${ws}/api-keys`, body);
+            if (opts.json) {
+                (0, output_1.printJson)(data);
+            }
+            else {
+                (0, output_1.printSuccess)(`API key created: ${data.name}`);
+                if (data.key) {
+                    console.log(chalk_1.default.yellow(`\n  Key: ${data.key}\n\n  Save this key — it will not be shown again.\n`));
+                }
+                (0, output_1.printJson)(data);
+            }
+        }
+        catch (err) {
+            (0, client_1.handleError)(err);
+        }
+    });
+    apikeys
+        .command("delete <keyId>")
+        .description("Revoke/delete an API key")
+        .option("-w, --workspace <slug>", "Workspace slug")
+        .action(async (keyId, opts) => {
+        try {
+            const ws = requireWorkspace(opts);
+            await (0, client_1.getClient)().delete(`/api/v1/workspace/${ws}/api-keys/${keyId}`);
+            (0, output_1.printSuccess)(`API key ${keyId} revoked`);
+        }
+        catch (err) {
+            (0, client_1.handleError)(err);
+        }
+    });
+}
+exports.registerApiKeyCommands = registerApiKeyCommands;

package/dist/commands/auth.d.ts

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

package/dist/commands/auth.js

@@ -0,0 +1,110 @@
+"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.registerAuthCommands = void 0;
+const crypto = __importStar(require("crypto"));
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../lib/config");
+const output_1 = require("../lib/output");
+const auth_server_1 = require("../lib/auth-server");
+const open_browser_1 = require("../lib/open-browser");
+function registerAuthCommands(program) {
+    const auth = program.command("auth").description("Manage authentication");
+    auth
+        .command("login", { isDefault: true })
+        .description("Authenticate with the browser or a personal access token")
+        .option("--token <token>", "Personal access token (pdgu_...)")
+        .option("--no-browser", "Print the login URL instead of opening the browser")
+        .action(async (opts) => {
+        if (opts.token) {
+            // Manual token flow
+            if (!opts.token.startsWith("pdgu_")) {
+                console.error(chalk_1.default.red('Invalid token format. Token must start with "pdgu_".'));
+                process.exit(1);
+            }
+            (0, config_1.saveCredentials)({ token: opts.token, apiUrl: (0, config_1.getApiUrl)() });
+            (0, output_1.printSuccess)("Authenticated successfully. Credentials saved to ~/.podge/credentials.json");
+            return;
+        }
+        // Browser auth flow
+        const state = crypto.randomBytes(16).toString("hex");
+        let port;
+        let tokenPromise;
+        try {
+            const server = await (0, auth_server_1.startAuthServer)(state);
+            port = server.port;
+            tokenPromise = server.tokenPromise;
+        }
+        catch (err) {
+            console.error(chalk_1.default.red("Failed to start local auth server."));
+            process.exit(1);
+        }
+        const appUrl = (0, config_1.getAppUrl)();
+        const loginUrl = `${appUrl}/cli-auth?port=${port}&state=${state}`;
+        if (opts.browser) {
+            (0, output_1.printInfo)("Opening browser to authenticate...");
+            (0, open_browser_1.openBrowser)(loginUrl);
+        }
+        else {
+            (0, output_1.printInfo)("Open this URL in your browser to authenticate:");
+            console.log(`\n  ${loginUrl}\n`);
+        }
+        (0, output_1.printInfo)("Waiting for authentication...");
+        try {
+            const result = await tokenPromise;
+            (0, config_1.saveCredentials)({ token: result.token, apiUrl: (0, config_1.getApiUrl)() });
+            (0, output_1.printSuccess)("Authenticated successfully. Credentials saved to ~/.podge/credentials.json");
+        }
+        catch (err) {
+            console.error(chalk_1.default.red(err instanceof Error ? err.message : "Authentication failed."));
+            process.exit(1);
+        }
+    });
+    auth
+        .command("logout")
+        .description("Remove stored credentials")
+        .action(() => {
+        (0, config_1.clearCredentials)();
+        (0, output_1.printSuccess)("Logged out. Credentials removed.");
+    });
+    auth
+        .command("status")
+        .description("Show current authentication status")
+        .action(() => {
+        const creds = (0, config_1.getCredentials)();
+        if (creds) {
+            console.log(chalk_1.default.green("Authenticated"));
+            console.log(`  API URL: ${creds.apiUrl}`);
+            console.log(`  Token:   ${creds.token.substring(0, 12)}...`);
+        }
+        else {
+            console.log(chalk_1.default.yellow("Not authenticated"));
+        }
+    });
+}
+exports.registerAuthCommands = registerAuthCommands;

package/dist/commands/collections.d.ts

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

package/dist/commands/collections.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCollectionCommands = 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 requireContext(opts) {
+    const cfg = (0, config_1.getConfig)();
+    const ws = opts.workspace || cfg.workspace;
+    const env = opts.environment || cfg.environment;
+    if (!ws || !env) {
+        console.error(chalk_1.default.red("Workspace and environment required. Use --workspace/--environment or `podge config set`."));
+        process.exit(1);
+    }
+    return { ws, env };
+}
+function registerCollectionCommands(program) {
+    const col = program
+        .command("collections")
+        .alias("col")
+        .description("Manage collections");
+    col
+        .command("list")
+        .description("List collections")
+        .option("-w, --workspace <key>", "Workspace key")
+        .option("-e, --environment <key>", "Environment key")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        try {
+            const { ws, env } = requireContext(opts);
+            const { data } = await (0, client_1.getClient)().get(`/api/v1/workspace/${ws}/environment/${env}/collections`);
+            if (opts.json) {
+                (0, output_1.printJson)(data);
+            }
+            else {
+                const rows = (Array.isArray(data) ? data : []).map((c) => [
+                    String(c.id),
+                    c.key,
+                    c.name,
+                ]);
+                (0, output_1.printTable)(["ID", "KEY", "NAME"], rows);
+            }
+        }
+        catch (err) {
+            (0, client_1.handleError)(err);
+        }
+    });
+    col
+        .command("get <key>")
+        .description("Get collection details")
+        .option("-w, --workspace <key>", "Workspace key")
+        .option("-e, --environment <key>", "Environment key")
+        .option("--json", "Output as JSON")
+        .action(async (key, opts) => {
+        try {
+            const { ws, env } = requireContext(opts);
+            const { data } = await (0, client_1.getClient)().get(`/api/v1/workspace/${ws}/environment/${env}/collection/${key}`);
+            if (opts.json) {
+                (0, output_1.printJson)(data);
+            }
+            else {
+                console.log(`Name: ${data.name}`);
+                console.log(`Key: ${data.key}`);
+            }
+        }
+        catch (err) {
+            (0, client_1.handleError)(err);
+        }
+    });
+    col
+        .command("schema <key>")
+        .description("Get collection schema")
+        .option("-w, --workspace <key>", "Workspace key")
+        .option("-e, --environment <key>", "Environment key")
+        .action(async (key, opts) => {
+        try {
+            const { ws, env } = requireContext(opts);
+            const { data } = await (0, client_1.getClient)().get(`/api/v1/workspace/${ws}/environment/${env}/collection/${key}/schema`);
+            (0, output_1.printJson)(data);
+        }
+        catch (err) {
+            (0, client_1.handleError)(err);
+        }
+    });
+}
+exports.registerCollectionCommands = registerCollectionCommands;

package/dist/commands/config.d.ts

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

package/dist/commands/config.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerConfigCommands = void 0;
+const config_1 = require("../lib/config");
+const output_1 = require("../lib/output");
+function registerConfigCommands(program) {
+    const config = program
+        .command("config")
+        .description("Manage CLI configuration");
+    config
+        .command("set")
+        .description("Set a configuration value")
+        .requiredOption("--workspace <key>", "Default workspace key")
+        .option("--environment <key>", "Default environment key")
+        .action((opts) => {
+        const updates = {};
+        if (opts.workspace)
+            updates.workspace = opts.workspace;
+        if (opts.environment)
+            updates.environment = opts.environment;
+        (0, config_1.saveConfig)(updates);
+        (0, output_1.printSuccess)("Configuration updated.");
+    });
+    config
+        .command("get")
+        .description("Show current configuration")
+        .action(() => {
+        const cfg = (0, config_1.getConfig)();
+        if (Object.keys(cfg).length === 0) {
+            (0, output_1.printInfo)("No configuration set. Use `podge config set` to configure defaults.");
+            return;
+        }
+        for (const [key, value] of Object.entries(cfg)) {
+            console.log(`  ${key}: ${value}`);
+        }
+    });
+}
+exports.registerConfigCommands = registerConfigCommands;

package/dist/commands/debug.d.ts

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

package/dist/commands/debug.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDebugCommands = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../lib/config");
+const output_1 = require("../lib/output");
+function registerDebugCommands(program) {
+    const debug = program
+        .command("debug")
+        .description("Internal commands for Podge developers")
+        .addHelpText("before", chalk_1.default.yellow("⚠  These commands are for Podge developers only.\n"));
+    debug
+        .command("set-api <url>")
+        .description("Override the API base URL (e.g. http://localhost:3000/api)")
+        .action((url) => {
+        (0, config_1.saveConfig)({ apiUrl: url });
+        (0, output_1.printSuccess)(`API URL set to ${url}`);
+        console.log(chalk_1.default.dim("Run `podge auth login` again to apply the new URL."));
+    });
+    debug
+        .command("reset-api")
+        .description("Reset API URL to the default")
+        .action(() => {
+        const { apiUrl: _, ...rest } = (0, config_1.getConfig)();
+        (0, config_1.writeConfig)(rest);
+        (0, output_1.printSuccess)("API URL reset to default.");
+    });
+    debug
+        .command("status")
+        .description("Show resolved URLs and config")
+        .action(() => {
+        const config = (0, config_1.getConfig)();
+        console.log(`  API URL: ${(0, config_1.getApiUrl)()}${config.apiUrl ? " (override)" : ""}`);
+        console.log(`  App URL: ${(0, config_1.getAppUrl)()}${config.appUrl ? " (override)" : ""}`);
+        console.log(`  Config:  ~/.podge/config.json`);
+    });
+}
+exports.registerDebugCommands = registerDebugCommands;

package/dist/commands/environments.d.ts

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

package/dist/commands/environments.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEnvironmentCommands = 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 requireWorkspace(opts) {
+    const ws = opts.workspace || (0, config_1.getConfig)().workspace;
+    if (!ws) {
+        console.error(chalk_1.default.red("Workspace required. Use --workspace or `podge config set --workspace <key>`."));
+        process.exit(1);
+    }
+    return ws;
+}
+function registerEnvironmentCommands(program) {
+    const env = program
+        .command("environments")
+        .alias("env")
+        .description("Manage environments");
+    env
+        .command("list")
+        .description("List environments")
+        .option("-w, --workspace <key>", "Workspace key")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        try {
+            const ws = requireWorkspace(opts);
+            const { data } = await (0, client_1.getClient)().get(`/api/v1/workspace/${ws}/environments`);
+            if (opts.json) {
+                (0, output_1.printJson)(data);
+            }
+            else {
+                const rows = (Array.isArray(data) ? data : []).map((e) => [
+                    String(e.id),
+                    e.key,
+                    e.name,
+                ]);
+                (0, output_1.printTable)(["ID", "KEY", "NAME"], rows);
+            }
+        }
+        catch (err) {
+            (0, client_1.handleError)(err);
+        }
+    });
+    env
+        .command("get <key>")
+        .description("Get environment details")
+        .option("-w, --workspace <key>", "Workspace key")
+        .option("--json", "Output as JSON")
+        .action(async (key, opts) => {
+        try {
+            const ws = requireWorkspace(opts);
+            const { data } = await (0, client_1.getClient)().get(`/api/v1/workspace/${ws}/environment/${key}`);
+            if (opts.json) {
+                (0, output_1.printJson)(data);
+            }
+            else {
+                console.log(`Name: ${data.name}`);
+                console.log(`Key: ${data.key}`);
+            }
+        }
+        catch (err) {
+            (0, client_1.handleError)(err);
+        }
+    });
+}
+exports.registerEnvironmentCommands = registerEnvironmentCommands;

package/dist/commands/items.d.ts

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