ts-prorm-orm 1.1.0 → 1.2.1

package/dist/cli/commands/store.js

@@ -0,0 +1,274 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commands = void 0;
+// Storage command module for the prorm CLI. Manages the S3-backed user/team
+// "store" via the dashboard API, which brokers presigned URLs so file bytes flow
+// directly between the CLI and S3 (never through the dashboard). Also manages the
+// set of buckets registered for the account/team.
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const framework_1 = require("../framework");
+const cloud_1 = require("../cloud");
+const prompt_1 = require("../prompt");
+const io_1 = require("../io");
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+const CONTENT_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.txt': 'text/plain',
+    '.json': 'application/json',
+};
+function contentTypeFor(file) {
+    return CONTENT_TYPES[path.extname(file).toLowerCase()] ?? 'application/octet-stream';
+}
+/** Read an optional string flag, treating empty strings as absent. */
+function str(ctx, name) {
+    const v = ctx.flags[name];
+    return typeof v === 'string' && v ? v : undefined;
+}
+// ─── Commands ─────────────────────────────────────────────────────────────────
+const push = (0, framework_1.defineCommand)({
+    name: 'store push',
+    description: 'Upload one or more files to the store via presigned URLs.',
+    group: 'Storage',
+    positionals: [{ name: 'files', description: 'Path(s) or globs to upload.', required: true, variadic: true }],
+    flags: [
+        {
+            name: 'kind',
+            type: 'string',
+            description: 'Object kind.',
+            choices: ['avatar', 'log', 'image', 'file'],
+            default: 'file',
+        },
+        { name: 'team', type: 'string', description: 'Team slug or id to upload under.' },
+        { name: 'public', type: 'boolean', description: 'Make the object publicly readable.' },
+        { name: 'name', type: 'string', description: 'Override the stored object name (single file only).' },
+        { name: 'content-type', type: 'string', description: 'Override the guessed MIME type.' },
+        { name: 'dry-run', type: 'boolean', description: 'Show what would be uploaded without uploading.' },
+    ],
+    examples: [
+        'orm-cli store push ./avatar.png --kind avatar',
+        'orm-cli store push ./logs/*.log --kind log',
+        'orm-cli store push ./report.json --team acme --name reports/latest.json',
+    ],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const files = (0, io_1.expandGlobs)(ctx.positionals);
+        if (!files.length) {
+            framework_1.out.error('No files to upload.');
+            return 1;
+        }
+        const kind = (str(ctx, 'kind') ?? 'file');
+        const team = str(ctx, 'team');
+        const isPublic = ctx.flags.public === true;
+        const nameOverride = str(ctx, 'name');
+        const ctOverride = str(ctx, 'content-type');
+        if (nameOverride && files.length > 1) {
+            framework_1.out.error('--name can only be used with a single file.');
+            return 1;
+        }
+        if (ctx.flags['dry-run']) {
+            framework_1.out.info(`Would upload ${files.length} file(s):`);
+            files.forEach((f) => framework_1.out.dim(`  ${f} → ${nameOverride ?? path.basename(f)} (${ctOverride ?? contentTypeFor(f)})`));
+            return 0;
+        }
+        for (const file of files) {
+            if (!fs.existsSync(file)) {
+                framework_1.out.warn(`Skipping missing file: ${file}`);
+                continue;
+            }
+            const name = nameOverride ?? path.basename(file);
+            const contentType = ctOverride ?? contentTypeFor(file);
+            const { url, key } = await (0, cloud_1.api)('/api/dashboard/storage/presign', {
+                method: 'POST',
+                body: { name, kind, team, contentType, public: isPublic },
+            });
+            const spin = (0, io_1.spinner)(`Uploading ${name}…`);
+            let size;
+            try {
+                size = await (0, io_1.uploadFile)(url, file, contentType);
+            }
+            finally {
+                spin.stop();
+            }
+            await (0, cloud_1.api)('/api/dashboard/storage/commit', {
+                method: 'POST',
+                body: { key, size, kind, team, public: isPublic },
+            });
+            framework_1.out.success(`Uploaded ${key}`);
+        }
+        return 0;
+    },
+});
+const pull = (0, framework_1.defineCommand)({
+    name: 'store pull',
+    description: 'Download an object from the store via a presigned URL.',
+    group: 'Storage',
+    positionals: [{ name: 'key', description: 'The object key to download.', required: true }],
+    flags: [
+        { name: 'out', type: 'string', description: 'Output path (default: basename of key).' },
+        { name: 'yes', alias: 'y', type: 'boolean', description: 'Overwrite an existing local file without prompting.' },
+    ],
+    examples: [
+        'orm-cli store pull avatars/me.png',
+        'orm-cli store pull reports/latest.json --out ./latest.json',
+    ],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const key = ctx.positionals[0];
+        const dest = str(ctx, 'out') ?? path.basename(key);
+        const assumeYes = ctx.flags.yes === true || (0, framework_1.getGlobalOptions)().assumeYes;
+        if (!(await (0, io_1.ensureOverwrite)(dest, assumeYes)))
+            return 1;
+        const { url } = await (0, cloud_1.api)('/api/dashboard/storage/presign-get', {
+            query: { key },
+        });
+        const spin = (0, io_1.spinner)(`Downloading ${key}…`);
+        try {
+            await (0, io_1.downloadFile)(url, dest);
+        }
+        finally {
+            spin.stop();
+        }
+        framework_1.out.success(`Downloaded ${key} → ${dest}`);
+        return 0;
+    },
+});
+const list = (0, framework_1.defineCommand)({
+    name: 'store list',
+    description: 'List objects in the store.',
+    group: 'Storage',
+    flags: [
+        { name: 'team', type: 'string', description: 'Filter by team slug or id.' },
+        { name: 'kind', type: 'string', description: 'Filter by object kind.' },
+        { name: 'prefix', type: 'string', description: 'Filter by object key prefix.' },
+        { name: 'limit', type: 'number', description: 'Max objects to return.', default: 50 },
+        { name: 'offset', type: 'number', description: 'Skip this many objects.' },
+        { name: 'json', type: 'boolean', description: 'Output raw JSON.' },
+    ],
+    examples: [
+        'orm-cli store list',
+        'orm-cli store list --team acme --kind image',
+        'orm-cli store list --prefix logs/ --limit 100 --offset 100',
+    ],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const { objects } = await (0, cloud_1.api)('/api/dashboard/storage', {
+            query: {
+                team: str(ctx, 'team'),
+                kind: str(ctx, 'kind'),
+                prefix: str(ctx, 'prefix'),
+                limit: typeof ctx.flags.limit === 'number' ? ctx.flags.limit : undefined,
+                offset: typeof ctx.flags.offset === 'number' ? ctx.flags.offset : undefined,
+            },
+        });
+        if (ctx.flags.json) {
+            framework_1.out.json(objects);
+            return;
+        }
+        framework_1.out.table(objects.map((o) => ({
+            key: o.key,
+            kind: o.kind,
+            size: o.size,
+            contentType: o.contentType,
+            createdAt: o.createdAt,
+        })));
+    },
+});
+const rm = (0, framework_1.defineCommand)({
+    name: 'store rm',
+    description: 'Delete an object from the store.',
+    group: 'Storage',
+    positionals: [{ name: 'key', description: 'The object key to delete.', required: true }],
+    flags: [{ name: 'yes', alias: 'y', type: 'boolean', description: 'Skip the confirmation prompt.' }],
+    examples: ['orm-cli store rm logs/old.log --yes', 'orm-cli store rm avatars/me.png -y'],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const key = ctx.positionals[0];
+        const assumeYes = ctx.flags.yes === true || (0, framework_1.getGlobalOptions)().assumeYes;
+        framework_1.out.warn(`This will permanently delete ${key}.`);
+        if (!(await (0, prompt_1.confirm)(`Delete ${key}?`, { assumeYes, default: false }))) {
+            framework_1.out.info('Aborted (pass --yes to skip this prompt in a non-interactive session).');
+            return 1;
+        }
+        await (0, cloud_1.api)('/api/dashboard/storage', { method: 'DELETE', query: { key } });
+        framework_1.out.success(`Deleted ${key}`);
+        return 0;
+    },
+});
+const bucketList = (0, framework_1.defineCommand)({
+    name: 'bucket list',
+    description: 'List the buckets registered for the account.',
+    group: 'Storage',
+    flags: [{ name: 'json', type: 'boolean', description: 'Output raw JSON.' }],
+    examples: ['orm-cli bucket list', 'orm-cli bucket list --json'],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const { buckets } = await (0, cloud_1.api)('/api/dashboard/storage/buckets');
+        if (ctx.flags.json) {
+            framework_1.out.json(buckets);
+            return;
+        }
+        framework_1.out.table(buckets.map((b) => ({ name: b.name, region: b.region, default: b.default })));
+    },
+});
+const bucketAdd = (0, framework_1.defineCommand)({
+    name: 'bucket add',
+    description: 'Register a new bucket for the account or team.',
+    group: 'Storage',
+    flags: [
+        { name: 'name', type: 'string', description: 'Bucket name.', required: true },
+        { name: 'region', type: 'string', description: 'AWS region.', default: 'us-east-1' },
+        { name: 'team', type: 'string', description: 'Team slug or id to register the bucket under.' },
+    ],
+    examples: [
+        'orm-cli bucket add --name my-bucket',
+        'orm-cli bucket add --name my-bucket --region eu-west-1 --team acme',
+    ],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const name = str(ctx, 'name');
+        const region = str(ctx, 'region') ?? 'us-east-1';
+        const team = str(ctx, 'team');
+        await (0, cloud_1.api)('/api/dashboard/storage/buckets', {
+            method: 'POST',
+            body: { name, region, team },
+        });
+        framework_1.out.success(`Added bucket ${name} (${region})`);
+    },
+});
+exports.commands = [push, pull, list, rm, bucketList, bucketAdd];

package/dist/cli/commands/system.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from '../framework';
+interface VersionInfo {
+    current: string;
+    latest?: string;
+    updateAvailable: boolean;
+}
+/** Query the npm registry for the latest published version (best-effort). */
+export declare function fetchLatestVersion(current: string): Promise<VersionInfo>;
+export declare const commands: Command[];
+export {};

package/dist/cli/commands/system.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commands = void 0;
+exports.fetchLatestVersion = fetchLatestVersion;
+// System commands for the prorm CLI: shell completion script generation and a
+// self-update helper with an "update available" check against the npm registry.
+const child_process_1 = require("child_process");
+const framework_1 = require("../framework");
+const cloud_1 = require("../cloud");
+const PKG = 'ts-prorm-orm';
+const BIN = 'orm-cli';
+/** Unique top-level command words (first token of each registered command). */
+function topLevelWords() {
+    return [...new Set((0, framework_1.allCommands)().map((cmd) => cmd.name.split(' ')[0]))].sort();
+}
+/** Subcommand words for a given top-level word (e.g. add/list for "db"). */
+function subWords(top) {
+    return [
+        ...new Set((0, framework_1.allCommands)()
+            .filter((cmd) => cmd.name.startsWith(top + ' '))
+            .map((cmd) => cmd.name.split(' ')[1])),
+    ].sort();
+}
+function bashScript() {
+    const tops = topLevelWords();
+    const caseArms = tops
+        .filter((t) => subWords(t).length)
+        .map((t) => `      ${t}) opts="${subWords(t).join(' ')}" ;;`)
+        .join('\n');
+    return `# bash completion for ${BIN}
+_${BIN.replace(/-/g, '_')}() {
+  local cur prev words cword
+  _init_completion 2>/dev/null || { cur="\${COMP_WORDS[COMP_CWORD]}"; prev="\${COMP_WORDS[COMP_CWORD-1]}"; }
+  local tops="${tops.join(' ')}"
+  if [ "\$COMP_CWORD" -eq 1 ]; then
+    COMPREPLY=( \$(compgen -W "\$tops" -- "\$cur") ); return 0
+  fi
+  local opts=""
+  case "\${COMP_WORDS[1]}" in
+${caseArms}
+  esac
+  COMPREPLY=( \$(compgen -W "\$opts" -- "\$cur") )
+}
+complete -F _${BIN.replace(/-/g, '_')} ${BIN}
+`;
+}
+function zshScript() {
+    const tops = topLevelWords();
+    const subCases = tops
+        .filter((t) => subWords(t).length)
+        .map((t) => `      ${t}) compadd ${subWords(t).join(' ')} ;;`)
+        .join('\n');
+    return `#compdef ${BIN}
+_${BIN.replace(/-/g, '_')}() {
+  local -a tops
+  tops=(${tops.join(' ')})
+  if (( CURRENT == 2 )); then
+    compadd \${tops[@]}
+    return
+  fi
+  case "\${words[2]}" in
+${subCases}
+  esac
+}
+_${BIN.replace(/-/g, '_')} "\$@"
+`;
+}
+function fishScript() {
+    const lines = [`# fish completion for ${BIN}`];
+    for (const top of topLevelWords()) {
+        lines.push(`complete -c ${BIN} -n "__fish_use_subcommand" -a "${top}"`);
+        for (const sub of subWords(top)) {
+            lines.push(`complete -c ${BIN} -n "__fish_seen_subcommand_from ${top}" -a "${sub}"`);
+        }
+    }
+    return lines.join('\n') + '\n';
+}
+const completion = (0, framework_1.defineCommand)({
+    name: 'completion',
+    description: 'Print a shell completion script (bash, zsh, or fish).',
+    group: 'System',
+    positionals: [
+        { name: 'shell', description: 'Target shell.', required: true, choices: ['bash', 'zsh', 'fish'] },
+    ],
+    examples: [
+        'orm-cli completion bash >> ~/.bashrc',
+        'orm-cli completion zsh > "${fpath[1]}/_orm-cli"',
+        'orm-cli completion fish > ~/.config/fish/completions/orm-cli.fish',
+    ],
+    run: (ctx) => {
+        const shell = ctx.positionals[0];
+        const script = shell === 'bash' ? bashScript() : shell === 'zsh' ? zshScript() : fishScript();
+        process.stdout.write(script);
+        return 0;
+    },
+});
+/** Compare two dotted semver-ish strings; returns true if `b` is newer. */
+function isNewer(a, b) {
+    const pa = a.split('.').map((n) => parseInt(n, 10) || 0);
+    const pb = b.split('.').map((n) => parseInt(n, 10) || 0);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        if ((pb[i] ?? 0) > (pa[i] ?? 0))
+            return true;
+        if ((pb[i] ?? 0) < (pa[i] ?? 0))
+            return false;
+    }
+    return false;
+}
+/** Query the npm registry for the latest published version (best-effort). */
+async function fetchLatestVersion(current) {
+    try {
+        const data = await (0, cloud_1.api)(`https://registry.npmjs.org/${PKG}/latest`, {
+            auth: false,
+            retries: 1,
+            timeoutMs: 5000,
+        });
+        const latest = data?.version;
+        return { current, latest, updateAvailable: Boolean(latest && isNewer(current, latest)) };
+    }
+    catch {
+        return { current, updateAvailable: false };
+    }
+}
+const upgrade = (0, framework_1.defineCommand)({
+    name: 'upgrade',
+    description: 'Check for and install a newer version of the CLI.',
+    group: 'System',
+    flags: [
+        { name: 'check', type: 'boolean', description: 'Only check; do not install.' },
+    ],
+    examples: ['orm-cli upgrade', 'orm-cli upgrade --check', 'orm-cli upgrade --json'],
+    run: async (ctx) => {
+        // Resolve the current version from package.json via the same helper misc uses.
+        let current = '0.0.0';
+        try {
+            current = require('../../../package.json').version || current;
+        }
+        catch {
+            // ignore
+        }
+        const info = await fetchLatestVersion(current);
+        if (ctx.flags.json) {
+            framework_1.out.json(info);
+            return info.updateAvailable ? 0 : 0;
+        }
+        if (!info.latest) {
+            framework_1.out.warn('Could not determine the latest version (registry unreachable).');
+            return 1;
+        }
+        if (!info.updateAvailable) {
+            framework_1.out.success(`Up to date (v${current}).`);
+            return 0;
+        }
+        framework_1.out.info(`Update available: v${current} → v${info.latest}`);
+        if (ctx.flags.check) {
+            framework_1.out.info(`Run \`npm install -g ${PKG}\` (or \`orm-cli upgrade\`) to update.`);
+            return 0;
+        }
+        framework_1.out.info(`Installing ${PKG}@${info.latest} …`);
+        const r = (0, child_process_1.spawnSync)('npm', ['install', '-g', `${PKG}@${info.latest}`], { stdio: 'inherit' });
+        if (r.status !== 0) {
+            framework_1.out.error('Upgrade failed. Try running the install command manually.');
+            return 1;
+        }
+        framework_1.out.success(`Upgraded to v${info.latest}.`);
+        return 0;
+    },
+});
+exports.commands = [completion, upgrade];

package/dist/cli/commands/teams.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from '../framework';
+export declare const commands: Command[];

package/dist/cli/commands/teams.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commands = void 0;
+// Teams command module for the prorm CLI. Manages teams, membership, and the
+// currently-selected team context against the dashboard API.
+const framework_1 = require("../framework");
+const cloud_1 = require("../cloud");
+/** Resolve the target team slug from --team or the stored current team. */
+function resolveTeam(ctx) {
+    const flag = ctx.flags.team;
+    if (typeof flag === 'string' && flag)
+        return flag;
+    return (0, cloud_1.loadConfig)().teamSlug;
+}
+const create = (0, framework_1.defineCommand)({
+    name: 'team create',
+    description: 'Create a new team.',
+    group: 'Teams',
+    flags: [
+        { name: 'name', type: 'string', description: 'Team display name.', required: true },
+        { name: 'slug', type: 'string', description: 'URL slug (server derives one if omitted).' },
+    ],
+    examples: [
+        'orm-cli team create --name "Acme Inc"',
+        'orm-cli team create --name "Acme Inc" --slug acme',
+    ],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const body = { name: ctx.flags.name };
+        if (typeof ctx.flags.slug === 'string' && ctx.flags.slug)
+            body.slug = ctx.flags.slug;
+        const team = await (0, cloud_1.api)('/api/dashboard/teams', { method: 'POST', body });
+        framework_1.out.success(`Created team ${team.slug}`);
+    },
+});
+const list = (0, framework_1.defineCommand)({
+    name: 'team list',
+    description: 'List teams you belong to.',
+    group: 'Teams',
+    flags: [{ name: 'json', type: 'boolean', description: 'Output raw JSON.' }],
+    examples: ['orm-cli team list', 'orm-cli team list --json'],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const { teams } = await (0, cloud_1.api)('/api/dashboard/teams');
+        if (ctx.flags.json) {
+            framework_1.out.json(teams);
+            return;
+        }
+        const current = (0, cloud_1.loadConfig)().teamSlug;
+        framework_1.out.table(teams.map((t) => ({
+            current: t.slug === current ? '*' : '',
+            id: t.id,
+            name: t.name,
+            slug: t.slug,
+            role: t.role ?? '',
+        })));
+    },
+});
+const switchTeam = (0, framework_1.defineCommand)({
+    name: 'team switch',
+    description: 'Switch the current team context.',
+    group: 'Teams',
+    positionals: [{ name: 'slug', description: 'Team slug to switch to.', required: true }],
+    examples: ['orm-cli team switch acme'],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const slug = ctx.positionals[0];
+        const { teams } = await (0, cloud_1.api)('/api/dashboard/teams', { query: { slug } });
+        const found = teams.find((t) => t.slug === slug);
+        if (!found) {
+            framework_1.out.error(`Team not found: ${slug}`);
+            return 1;
+        }
+        (0, cloud_1.updateConfig)({ teamId: found.id, teamSlug: slug });
+        framework_1.out.success(`Switched to ${slug}`);
+        return 0;
+    },
+});
+const invite = (0, framework_1.defineCommand)({
+    name: 'team invite',
+    description: 'Invite a user to a team by email.',
+    group: 'Teams',
+    positionals: [{ name: 'email', description: 'Email address to invite.', required: true }],
+    flags: [
+        { name: 'role', type: 'string', description: 'Role for the invitee.', choices: ['admin', 'member'], default: 'member' },
+        { name: 'team', type: 'string', description: 'Team slug (defaults to current team).' },
+    ],
+    examples: [
+        'orm-cli team invite dev@acme.com',
+        'orm-cli team invite dev@acme.com --role admin --team acme',
+    ],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const team = resolveTeam(ctx);
+        if (!team) {
+            framework_1.out.error('No team selected. Use --team or `team switch`.');
+            return 1;
+        }
+        const email = ctx.positionals[0];
+        const role = ctx.flags.role;
+        const res = await (0, cloud_1.api)('/api/dashboard/teams/' + team + '/invites', { method: 'POST', body: { email, role } });
+        framework_1.out.success(`Invited ${email}`);
+        if (res.inviteUrl)
+            framework_1.out.info(res.inviteUrl);
+        return 0;
+    },
+});
+const members = (0, framework_1.defineCommand)({
+    name: 'team members',
+    description: 'List members of a team.',
+    group: 'Teams',
+    flags: [
+        { name: 'team', type: 'string', description: 'Team slug (defaults to current team).' },
+        { name: 'limit', type: 'number', description: 'Max members to return.', default: 50 },
+        { name: 'offset', type: 'number', description: 'Skip this many members.' },
+        { name: 'json', type: 'boolean', description: 'Output raw JSON.' },
+    ],
+    examples: ['orm-cli team members', 'orm-cli team members --team acme --limit 100'],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const team = resolveTeam(ctx);
+        if (!team) {
+            framework_1.out.error('No team selected. Use --team or `team switch`.');
+            return 1;
+        }
+        const { members: rows } = await (0, cloud_1.api)('/api/dashboard/teams/' + team + '/members', {
+            query: {
+                limit: typeof ctx.flags.limit === 'number' ? ctx.flags.limit : undefined,
+                offset: typeof ctx.flags.offset === 'number' ? ctx.flags.offset : undefined,
+            },
+        });
+        if (ctx.flags.json) {
+            framework_1.out.json(rows);
+            return;
+        }
+        framework_1.out.table(rows.map((m) => ({
+            userId: m.userId,
+            email: m.email,
+            name: m.name ?? '',
+            role: m.role,
+            joinedAt: m.joinedAt ?? '',
+        })));
+        return 0;
+    },
+});
+const current = (0, framework_1.defineCommand)({
+    name: 'team current',
+    description: 'Print the currently-selected team context.',
+    group: 'Teams',
+    flags: [{ name: 'json', type: 'boolean', description: 'Output raw JSON.' }],
+    examples: ['orm-cli team current', 'orm-cli team current --json'],
+    run: (ctx) => {
+        const cfg = (0, cloud_1.loadConfig)();
+        if (ctx.flags.json) {
+            framework_1.out.json({ teamSlug: cfg.teamSlug ?? null, teamId: cfg.teamId ?? null });
+            return 0;
+        }
+        if (!cfg.teamSlug && !cfg.teamId) {
+            framework_1.out.info('No team selected. Use `team switch <slug>` or --team.');
+            return 0;
+        }
+        framework_1.out.info(`Team: ${cfg.teamSlug ?? '(unknown slug)'}${cfg.teamId ? ` (${cfg.teamId})` : ''}`);
+        return 0;
+    },
+});
+const removeMember = (0, framework_1.defineCommand)({
+    name: 'team remove-member',
+    description: 'Remove a member from a team.',
+    group: 'Teams',
+    positionals: [{ name: 'userId', description: 'User ID to remove.', required: true }],
+    flags: [{ name: 'team', type: 'string', description: 'Team slug (defaults to current team).' }],
+    examples: [
+        'orm-cli team remove-member user_123',
+        'orm-cli team remove-member user_123 --team acme',
+    ],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const team = resolveTeam(ctx);
+        if (!team) {
+            framework_1.out.error('No team selected. Use --team or `team switch`.');
+            return 1;
+        }
+        const userId = ctx.positionals[0];
+        await (0, cloud_1.api)('/api/dashboard/teams/' + team + '/members/' + userId, { method: 'DELETE' });
+        framework_1.out.success(`Removed member ${userId}`);
+        return 0;
+    },
+});
+exports.commands = [create, list, switchTeam, current, invite, members, removeMember];

package/dist/cli/commands/user.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from '../framework';
+export declare const commands: Command[];