ardent-cli-beta 0.0.9 → 0.0.11

package/README.md

@@ -12,8 +12,10 @@ non-interactively. `ardent status` and `ardent logout` inspect and remove that
 local session. The CLI always talks to Ardent's production control plane. Oclif
 provides help, version, autocomplete, and native JSON command behavior. Resource
 context is retained from login. Project listing, creation, deletion, and local
-context switching are implemented; other resource commands are not implemented
-yet.
+context switching are implemented. Organization member listing, invitation,
+removal, and pending-invitation cancellation are implemented. Connector listing
+and registration are implemented; registration follows connector status, while
+credential delivery and replication readiness remain owed.
 
 Set `ARDENT_API_URL` to point the CLI at a development control plane. Without
 it, the CLI uses `https://production.tryardent.com`.
@@ -28,6 +30,12 @@ npm run build
 ./bin/run.js project create "My project"
 ./bin/run.js project switch "My project"
 ./bin/run.js project delete "My project"
+./bin/run.js member list
+./bin/run.js member invite teammate@example.com
+./bin/run.js member invite administrator@example.com --role admin
+./bin/run.js member delete teammate@example.com
+./bin/run.js connector list
+./bin/run.js connector create postgresql 'postgresql://user:password@database.example.com/app'
 ARDENT_API_URL=http://localhost:8080 ./bin/run.js login --token <token>
 ```
 

package/dist/commands/connector/create.d.ts

@@ -0,0 +1,19 @@
+import { ArdentCommand } from '../../command.js';
+interface ConnectorCreation {
+    connector_id: string;
+    status: 'registered' | 'registering';
+}
+export default class ConnectorCreate extends ArdentCommand {
+    static args: {
+        type: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        url: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static helpGroup: string;
+    static flags: {
+        environment: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<ConnectorCreation>;
+}
+export {};

package/dist/commands/connector/create.js

@@ -0,0 +1,56 @@
+import { randomUUID } from 'node:crypto';
+import { Args, Flags, ux } from '@oclif/core';
+import { loadSession } from '../../auth/credentials.js';
+import { ArdentCommand } from '../../command.js';
+import { createConnector, waitForConnectorRegistration } from '../../connectors/client.js';
+import { terminalText } from '../../terminal.js';
+export default class ConnectorCreate extends ArdentCommand {
+    static args = {
+        type: Args.string({ description: 'Connector type', required: true }),
+        url: Args.string({ description: 'PostgreSQL connection URL', required: true }),
+    };
+    static description = 'Register a PostgreSQL connector in the selected project';
+    static helpGroup = 'Connectors';
+    static flags = {
+        environment: Flags.string({ description: 'Environment ID (defaults to Ardent Cloud)' }),
+        name: Flags.string({ char: 'n', description: 'Connector name' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ConnectorCreate);
+        if (!['postgres', 'postgresql'].includes(args.type.toLowerCase())) {
+            this.error(`Unsupported connector type ${JSON.stringify(args.type)}. Supported: postgresql.`);
+        }
+        const session = await loadSession(this.config.configDir);
+        if (!session?.organization)
+            this.error('You must be logged in to run this command. Run ardent login.');
+        if (!session.selectedProject)
+            this.error('No project selected. Run ardent project list, then ardent project switch <name>.');
+        const providedName = flags.name?.trim();
+        if (flags.name !== undefined && !providedName)
+            this.error('Connector name cannot be empty.');
+        const name = providedName ?? `${session.selectedProject.name}-${randomUUID().slice(0, 8)}`;
+        const environmentID = flags.environment?.trim();
+        if (flags.environment !== undefined && !environmentID)
+            this.error('Environment ID cannot be empty.');
+        const interactive = !this.jsonEnabled() && ux.action.type === 'spinner';
+        if (interactive) {
+            ux.action.start(`${terminalText(name)} in ${terminalText(session.selectedProject.name)}`, 'registering');
+        }
+        else if (!this.jsonEnabled()) {
+            this.log(`Registering connector ${terminalText(name)} for project ${terminalText(session.selectedProject.name)}...`);
+        }
+        const registration = await createConnector(session.token, session.organization.id, session.selectedProject.id, environmentID, name, args.url);
+        if (!interactive) {
+            if (!this.jsonEnabled()) {
+                this.log(`Connector registration started (${terminalText(registration.connector_id)}).`);
+            }
+            return { connector_id: registration.connector_id, status: 'registering' };
+        }
+        await waitForConnectorRegistration(session.token, registration.connector_id, (status) => {
+            ux.action.status = status;
+        });
+        ux.action.stop(ux.colorize('green', '✓ registered'));
+        this.log('Credential delivery and replication readiness are still pending.');
+        return { connector_id: registration.connector_id, status: 'registered' };
+    }
+}

package/dist/commands/connector/list.d.ts

@@ -0,0 +1,9 @@
+import { ArdentCommand } from '../../command.js';
+import { type Connector } from '../../connectors/client.js';
+export default class ConnectorList extends ArdentCommand {
+    static description: string;
+    static helpGroup: string;
+    run(): Promise<{
+        connectors: Connector[];
+    }>;
+}

package/dist/commands/connector/list.js

@@ -0,0 +1,25 @@
+import { loadSession } from '../../auth/credentials.js';
+import { ArdentCommand } from '../../command.js';
+import { listConnectors } from '../../connectors/client.js';
+import { terminalText } from '../../terminal.js';
+export default class ConnectorList extends ArdentCommand {
+    static description = 'List connectors in the selected project';
+    static helpGroup = 'Connectors';
+    async run() {
+        const session = await loadSession(this.config.configDir);
+        if (!session?.organization)
+            this.error('You must be logged in to run this command. Run ardent login.');
+        if (!session.selectedProject)
+            this.error('No project selected. Run ardent project list, then ardent project switch <name>.');
+        const connectors = await listConnectors(session.token, session.organization.id, session.selectedProject.id);
+        if (!this.jsonEnabled()) {
+            if (connectors.length === 0)
+                this.log('No connectors found.');
+            const nameWidth = Math.max(0, ...connectors.map(({ name }) => terminalText(name).length));
+            for (const connector of connectors) {
+                this.log(`${terminalText(connector.name).padEnd(nameWidth)}  ${terminalText(connector.status)}`);
+            }
+        }
+        return { connectors };
+    }
+}

package/dist/commands/member/delete.d.ts

@@ -0,0 +1,12 @@
+import { ArdentCommand } from '../../command.js';
+export default class MemberDelete extends ArdentCommand {
+    static args: {
+        email: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static helpGroup: string;
+    run(): Promise<{
+        email: string;
+        status: 'active' | 'pending';
+    }>;
+}

package/dist/commands/member/delete.js

@@ -0,0 +1,48 @@
+import { Args } from '@oclif/core';
+import { loadSession } from '../../auth/credentials.js';
+import { ArdentCommand } from '../../command.js';
+import { deleteInvitation, deleteMembership, listInvitations, listMemberships } from '../../members/client.js';
+import { terminalText } from '../../terminal.js';
+export default class MemberDelete extends ArdentCommand {
+    static args = {
+        email: Args.string({ description: 'Member or pending invitation email', required: true }),
+    };
+    static description = 'Delete a member or pending invitation by email';
+    static helpGroup = 'Members';
+    async run() {
+        const { args } = await this.parse(MemberDelete);
+        const email = args.email.trim().toLowerCase();
+        if (!email)
+            this.error('Email cannot be empty.');
+        const session = await loadSession(this.config.configDir);
+        if (!session?.organization)
+            this.error('You must be logged in to run this command. Run ardent login.');
+        const [memberships, invitations] = await Promise.all([
+            listMemberships(session.token, session.organization.id),
+            listInvitations(session.token, session.organization.id),
+        ]);
+        const matchingMemberships = memberships.filter((candidate) => candidate.email.toLowerCase() === email);
+        const matchingInvitations = invitations.filter((candidate) => candidate.email.toLowerCase() === email);
+        if (matchingMemberships.length + matchingInvitations.length > 1) {
+            this.error(`Multiple active members or pending invitations match ${JSON.stringify(email)}.`);
+        }
+        const [membership] = matchingMemberships;
+        const [invitation] = matchingInvitations;
+        if (membership) {
+            if (!this.jsonEnabled())
+                this.log(`Deleting member ${terminalText(membership.email)}...`);
+            await deleteMembership(session.token, session.organization.id, membership.user_id);
+            if (!this.jsonEnabled())
+                this.log(`✓ Deleted member ${terminalText(membership.email)}`);
+            return { email: membership.email, status: 'active' };
+        }
+        if (!invitation)
+            this.error(`Member ${JSON.stringify(email)} not found.`);
+        if (!this.jsonEnabled())
+            this.log(`Canceling invitation for ${terminalText(invitation.email)}...`);
+        await deleteInvitation(session.token, session.organization.id, invitation.id);
+        if (!this.jsonEnabled())
+            this.log(`✓ Canceled invitation for ${terminalText(invitation.email)}`);
+        return { email: invitation.email, status: 'pending' };
+    }
+}

package/dist/commands/member/invite.d.ts

@@ -0,0 +1,13 @@
+import { ArdentCommand } from '../../command.js';
+import { type Invitation } from '../../members/client.js';
+export default class MemberInvite extends ArdentCommand {
+    static args: {
+        email: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static helpGroup: string;
+    static flags: {
+        role: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<Invitation>;
+}

package/dist/commands/member/invite.js

@@ -0,0 +1,35 @@
+import { Args, Flags } from '@oclif/core';
+import { loadSession } from '../../auth/credentials.js';
+import { ArdentCommand } from '../../command.js';
+import { inviteMember } from '../../members/client.js';
+import { terminalText } from '../../terminal.js';
+const roles = {
+    admin: 'Admin',
+    member: 'Member',
+    owner: 'Owner',
+    viewer: 'Viewer',
+};
+export default class MemberInvite extends ArdentCommand {
+    static args = {
+        email: Args.string({ description: 'Email address to invite', required: true }),
+    };
+    static description = 'Invite a member to the organization';
+    static helpGroup = 'Members';
+    static flags = {
+        role: Flags.string({ default: 'member', description: 'Role to grant', options: Object.keys(roles) }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(MemberInvite);
+        const email = args.email.trim().toLowerCase();
+        if (!email)
+            this.error('Email cannot be empty.');
+        const session = await loadSession(this.config.configDir);
+        if (!session?.organization)
+            this.error('You must be logged in to run this command. Run ardent login.');
+        const role = roles[flags.role];
+        const invitation = await inviteMember(session.token, session.organization.id, email, role);
+        if (!this.jsonEnabled())
+            this.log(`✓ Invited ${terminalText(invitation.email)} as ${terminalText(invitation.role_display_name)}`);
+        return invitation;
+    }
+}

package/dist/commands/member/list.d.ts

@@ -0,0 +1,10 @@
+import { ArdentCommand } from '../../command.js';
+import { type Invitation, type Membership } from '../../members/client.js';
+export default class MemberList extends ArdentCommand {
+    static description: string;
+    static helpGroup: string;
+    run(): Promise<{
+        invitations: Invitation[] | null;
+        memberships: Membership[];
+    }>;
+}

package/dist/commands/member/list.js

@@ -0,0 +1,41 @@
+import { loadSession } from '../../auth/credentials.js';
+import { ArdentCommand } from '../../command.js';
+import { listMemberships, listReadableInvitations } from '../../members/client.js';
+import { terminalText } from '../../terminal.js';
+export default class MemberList extends ArdentCommand {
+    static description = 'List organization members and pending invitations';
+    static helpGroup = 'Members';
+    async run() {
+        const session = await loadSession(this.config.configDir);
+        if (!session?.organization)
+            this.error('You must be logged in to run this command. Run ardent login.');
+        const [memberships, invitations] = await Promise.all([
+            listMemberships(session.token, session.organization.id),
+            listReadableInvitations(session.token, session.organization.id),
+        ]);
+        const readableInvitations = invitations ?? [];
+        if (!this.jsonEnabled()) {
+            const rows = [
+                ...memberships.map((membership) => ({
+                    email: terminalText(membership.email),
+                    role: terminalText(membership.role_display_name),
+                    status: 'Active',
+                })),
+                ...readableInvitations.map((invitation) => ({
+                    email: terminalText(invitation.email),
+                    role: terminalText(invitation.role_display_name),
+                    status: 'Pending',
+                })),
+            ];
+            if (rows.length === 0)
+                this.log('No members found.');
+            const emailWidth = Math.max(0, ...rows.map(({ email }) => email.length));
+            const roleWidth = Math.max(0, ...rows.map(({ role }) => role.length));
+            for (const row of rows)
+                this.log(`${row.email.padEnd(emailWidth)}  ${row.role.padEnd(roleWidth)}  ${row.status}`);
+            if (invitations === undefined)
+                this.log('Pending invitations are not visible with this login.');
+        }
+        return { invitations: invitations ?? null, memberships };
+    }
+}

package/dist/connectors/client.d.ts

@@ -0,0 +1,25 @@
+export interface Connector {
+    created_at: string;
+    environment_id: string;
+    id: string;
+    name: string;
+    project_id: string;
+    source: {
+        database: string;
+        host: string;
+        port: number;
+    };
+    status: string;
+    updated_at: string;
+}
+export interface ConnectorRegistration {
+    connector_id: string;
+}
+export interface ConnectorRegistrationStatus {
+    connector_id: string;
+    failure?: string;
+    status: 'failed' | 'registered' | 'registering';
+}
+export declare function listConnectors(token: string, organizationID: string, projectID: string): Promise<Connector[]>;
+export declare function createConnector(token: string, organizationID: string, projectID: string, environmentID: string | undefined, name: string, url: string): Promise<ConnectorRegistration>;
+export declare function waitForConnectorRegistration(token: string, connectorID: string, onStatus?: (status: ConnectorRegistrationStatus['status']) => void): Promise<ConnectorRegistrationStatus>;

package/dist/connectors/client.js

@@ -0,0 +1,76 @@
+import { randomUUID } from 'node:crypto';
+import { request } from '../api/client.js';
+export async function listConnectors(token, organizationID, projectID) {
+    const query = new URLSearchParams({ organization_id: organizationID, project_id: projectID });
+    const connectors = await request(token, `/connectors?${query}`);
+    if (!Array.isArray(connectors) || connectors.some((connector) => !isConnector(connector, projectID))) {
+        throw new Error('Ardent API returned an invalid connectors response.');
+    }
+    return connectors;
+}
+export async function createConnector(token, organizationID, projectID, environmentID, name, url) {
+    const requestID = randomUUID();
+    const registration = await request(token, '/connectors', {
+        body: JSON.stringify({
+            ...(environmentID ? { environment_id: environmentID } : {}),
+            name,
+            organization_id: organizationID,
+            project_id: projectID,
+            request_id: requestID,
+            url,
+        }),
+        method: 'POST',
+    });
+    if (!isConnectorRegistration(registration))
+        throw new Error('Ardent API returned an invalid connector registration response.');
+    return registration;
+}
+export async function waitForConnectorRegistration(token, connectorID, onStatus) {
+    for (;;) {
+        const status = await request(token, `/connectors/${encodeURIComponent(connectorID)}`);
+        if (!isConnectorRegistrationStatus(status, connectorID)) {
+            throw new Error('Ardent API returned an invalid connector registration status.');
+        }
+        onStatus?.(status.status);
+        if (status.status === 'registered')
+            return status;
+        if (status.status === 'failed')
+            throw new Error(status.failure || 'Connector registration failed.');
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+    }
+}
+function isConnector(value, projectID) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const connector = value;
+    const source = connector.source;
+    return (typeof connector.id === 'string' &&
+        connector.id.length > 0 &&
+        connector.project_id === projectID &&
+        typeof connector.environment_id === 'string' &&
+        connector.environment_id.length > 0 &&
+        typeof connector.name === 'string' &&
+        typeof connector.status === 'string' &&
+        connector.status.length > 0 &&
+        typeof source === 'object' &&
+        source !== null &&
+        typeof source.host === 'string' &&
+        Number.isInteger(source.port) &&
+        typeof source.database === 'string' &&
+        typeof connector.created_at === 'string' &&
+        typeof connector.updated_at === 'string');
+}
+function isConnectorRegistration(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const registration = value;
+    return typeof registration.connector_id === 'string' && registration.connector_id.length > 0;
+}
+function isConnectorRegistrationStatus(value, connectorID) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const status = value;
+    return (status.connector_id === connectorID &&
+        (status.status === 'registering' || status.status === 'registered' || status.status === 'failed') &&
+        (status.failure === undefined || typeof status.failure === 'string'));
+}

package/dist/members/client.d.ts

@@ -0,0 +1,29 @@
+export type OrganizationRole = 'Admin' | 'Member' | 'Owner' | 'Viewer';
+export interface Membership {
+    created_at: string;
+    email: string;
+    full_name: string | null;
+    organization_id: string;
+    role_display_name: string;
+    scopes: string[];
+    updated_at: string;
+    user_id: string;
+}
+export interface Invitation {
+    created_at: string;
+    created_by: string | null;
+    email: string;
+    expires_at: string;
+    id: string;
+    inviter_name: string | null;
+    organization_id: string;
+    organization_name: string;
+    role_display_name: string;
+    scopes: string[];
+}
+export declare function listMemberships(token: string, organizationID: string): Promise<Membership[]>;
+export declare function listInvitations(token: string, organizationID: string): Promise<Invitation[]>;
+export declare function listReadableInvitations(token: string, organizationID: string): Promise<Invitation[] | undefined>;
+export declare function inviteMember(token: string, organizationID: string, email: string, role: OrganizationRole): Promise<Invitation>;
+export declare function deleteMembership(token: string, organizationID: string, userID: string): Promise<void>;
+export declare function deleteInvitation(token: string, organizationID: string, invitationID: string): Promise<void>;

package/dist/members/client.js

@@ -0,0 +1,114 @@
+import { randomUUID } from 'node:crypto';
+import { APIError, request } from '../api/client.js';
+const sharedReadScopes = [
+    'organizations.read',
+    'organization_memberships.read',
+    'projects.read',
+    'environments.read',
+    'connectors.read',
+];
+const adminScopes = [
+    'organizations.read',
+    'organization_memberships.read',
+    'organization_memberships.update',
+    'organization_invitations.read',
+    'organization_invitations.create',
+    'organization_invitations.delete',
+    'projects.read',
+    'projects.create',
+    'projects.update',
+    'projects.delete',
+    'environments.read',
+    'environments.create',
+    'connectors.read',
+    'connectors.create',
+    'environments.update',
+    'branches.connect',
+    'billing.read',
+    'api_keys.read',
+    'api_keys.create',
+    'api_keys.revoke',
+];
+const standardRoleScopes = {
+    Owner: adminScopes.flatMap((scope) => (scope === 'billing.read' ? [scope, 'billing.manage'] : [scope])),
+    Admin: adminScopes,
+    Member: [...sharedReadScopes, 'projects.create', 'connectors.create', 'branches.connect'],
+    Viewer: sharedReadScopes,
+};
+export async function listMemberships(token, organizationID) {
+    const memberships = await request(token, `/organizations/${encodeURIComponent(organizationID)}/memberships`);
+    if (!Array.isArray(memberships) || memberships.some((membership) => !isMembership(membership, organizationID))) {
+        throw new Error('Ardent API returned an invalid memberships response.');
+    }
+    return memberships;
+}
+export async function listInvitations(token, organizationID) {
+    const invitations = await request(token, `/organizations/${encodeURIComponent(organizationID)}/invitations`);
+    if (!Array.isArray(invitations) || invitations.some((invitation) => !isInvitation(invitation, organizationID))) {
+        throw new Error('Ardent API returned an invalid invitations response.');
+    }
+    return invitations;
+}
+export async function listReadableInvitations(token, organizationID) {
+    try {
+        return await listInvitations(token, organizationID);
+    }
+    catch (error) {
+        if (error instanceof APIError && error.status === 403 && error.code === 'permission_denied')
+            return undefined;
+        throw error;
+    }
+}
+export async function inviteMember(token, organizationID, email, role) {
+    const invitation = await request(token, `/organizations/${encodeURIComponent(organizationID)}/invitations`, {
+        body: JSON.stringify({ email, role_display_name: role, scopes: standardRoleScopes[role] }),
+        headers: { 'Idempotency-Key': randomUUID() },
+        method: 'POST',
+    });
+    if (!isInvitation(invitation, organizationID))
+        throw new Error('Ardent API returned an invalid invitation response.');
+    return invitation;
+}
+export async function deleteMembership(token, organizationID, userID) {
+    const response = await request(token, `/organizations/${encodeURIComponent(organizationID)}/memberships/${encodeURIComponent(userID)}`, { method: 'DELETE' });
+    if (response !== undefined)
+        throw new Error('Ardent API did not confirm member deletion. Run ardent member list before retrying.');
+}
+export async function deleteInvitation(token, organizationID, invitationID) {
+    const response = await request(token, `/organizations/${encodeURIComponent(organizationID)}/invitations/${encodeURIComponent(invitationID)}`, { method: 'DELETE' });
+    if (response !== undefined)
+        throw new Error('Ardent API did not confirm invitation cancellation. Run ardent member list before retrying.');
+}
+function isMembership(value, organizationID) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const membership = value;
+    return (membership.organization_id === organizationID &&
+        typeof membership.user_id === 'string' &&
+        membership.user_id.length > 0 &&
+        typeof membership.email === 'string' &&
+        (membership.full_name === null || typeof membership.full_name === 'string') &&
+        typeof membership.role_display_name === 'string' &&
+        stringArray(membership.scopes) &&
+        typeof membership.created_at === 'string' &&
+        typeof membership.updated_at === 'string');
+}
+function isInvitation(value, organizationID) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const invitation = value;
+    return (invitation.organization_id === organizationID &&
+        typeof invitation.id === 'string' &&
+        invitation.id.length > 0 &&
+        typeof invitation.organization_name === 'string' &&
+        typeof invitation.email === 'string' &&
+        typeof invitation.role_display_name === 'string' &&
+        stringArray(invitation.scopes) &&
+        typeof invitation.expires_at === 'string' &&
+        (invitation.created_by === null || typeof invitation.created_by === 'string') &&
+        (invitation.inviter_name === null || typeof invitation.inviter_name === 'string') &&
+        typeof invitation.created_at === 'string');
+}
+function stringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}

package/oclif.manifest.json

@@ -95,6 +95,208 @@
         "status.js"
       ]
     },
+    "connector:create": {
+      "aliases": [],
+      "args": {
+        "type": {
+          "description": "Connector type",
+          "name": "type",
+          "required": true
+        },
+        "url": {
+          "description": "PostgreSQL connection URL",
+          "name": "url",
+          "required": true
+        }
+      },
+      "description": "Register a PostgreSQL connector in the selected project",
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "environment": {
+          "description": "Environment ID (defaults to Ardent Cloud)",
+          "name": "environment",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "name": {
+          "char": "n",
+          "description": "Connector name",
+          "name": "name",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "connector:create",
+      "pluginAlias": "ardent-cli-beta",
+      "pluginName": "ardent-cli-beta",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "helpGroup": "Connectors",
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "connector",
+        "create.js"
+      ]
+    },
+    "connector:list": {
+      "aliases": [],
+      "args": {},
+      "description": "List connectors in the selected project",
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "connector:list",
+      "pluginAlias": "ardent-cli-beta",
+      "pluginName": "ardent-cli-beta",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "helpGroup": "Connectors",
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "connector",
+        "list.js"
+      ]
+    },
+    "member:delete": {
+      "aliases": [],
+      "args": {
+        "email": {
+          "description": "Member or pending invitation email",
+          "name": "email",
+          "required": true
+        }
+      },
+      "description": "Delete a member or pending invitation by email",
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "member:delete",
+      "pluginAlias": "ardent-cli-beta",
+      "pluginName": "ardent-cli-beta",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "helpGroup": "Members",
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "member",
+        "delete.js"
+      ]
+    },
+    "member:invite": {
+      "aliases": [],
+      "args": {
+        "email": {
+          "description": "Email address to invite",
+          "name": "email",
+          "required": true
+        }
+      },
+      "description": "Invite a member to the organization",
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "role": {
+          "description": "Role to grant",
+          "name": "role",
+          "default": "member",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "options": [
+            "admin",
+            "member",
+            "owner",
+            "viewer"
+          ],
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "member:invite",
+      "pluginAlias": "ardent-cli-beta",
+      "pluginName": "ardent-cli-beta",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "helpGroup": "Members",
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "member",
+        "invite.js"
+      ]
+    },
+    "member:list": {
+      "aliases": [],
+      "args": {},
+      "description": "List organization members and pending invitations",
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "member:list",
+      "pluginAlias": "ardent-cli-beta",
+      "pluginName": "ardent-cli-beta",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "helpGroup": "Members",
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "member",
+        "list.js"
+      ]
+    },
     "project:create": {
       "aliases": [],
       "args": {
@@ -234,5 +436,5 @@
       ]
     }
   },
-  "version": "0.0.9"
+  "version": "0.0.11"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ardent-cli-beta",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "The Ardent command-line interface",
   "license": "Apache-2.0",
   "type": "module",