ardent-cli-beta 0.0.8 → 0.0.10

package/README.md

@@ -11,8 +11,10 @@ API token for CI and automation; `ARDENT_TOKEN` supplies the same flag
 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, and local context
-switching are implemented; other resource commands are not implemented yet.
+context is retained from login. Project listing, creation, deletion, and local
+context switching are implemented. Organization member listing, invitation,
+removal, and pending-invitation cancellation are implemented; other resource
+commands are not implemented yet.
 
 Set `ARDENT_API_URL` to point the CLI at a development control plane. Without
 it, the CLI uses `https://production.tryardent.com`.
@@ -26,6 +28,11 @@ npm run build
 ./bin/run.js project list
 ./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
 ARDENT_API_URL=http://localhost:8080 ./bin/run.js login --token <token>
 ```
 

package/dist/api/client.js

@@ -48,6 +48,8 @@ async function requestJSON(path, init) {
         }
         throw new APIError(detail.message ?? `Ardent API request failed with HTTP ${response.status}.`, response.status, detail.error);
     }
+    if (response.status === 204)
+        return undefined;
     try {
         return JSON.parse(text);
     }

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/commands/project/delete.d.ts

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

package/dist/commands/project/delete.js

@@ -0,0 +1,33 @@
+import { Args } from '@oclif/core';
+import { loadSession } from '../../auth/credentials.js';
+import { ArdentCommand } from '../../command.js';
+import { deleteProject, listProjects } from '../../projects/client.js';
+import { replaceProjectCache } from '../../projects/context.js';
+import { terminalText } from '../../terminal.js';
+export default class ProjectDelete extends ArdentCommand {
+    static args = {
+        name: Args.string({ description: 'Project name', required: true }),
+    };
+    static description = 'Delete a project by name';
+    static helpGroup = 'Projects';
+    async run() {
+        const { args } = await this.parse(ProjectDelete);
+        const name = args.name.trim();
+        if (!name)
+            this.error('Project name 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 projects = await listProjects(session.token, session.organization.id);
+        const project = projects.find((candidate) => candidate.name === name);
+        if (!project)
+            this.error(`Project ${JSON.stringify(name)} not found.`);
+        if (!this.jsonEnabled())
+            this.log(`Deleting project ${terminalText(project.name)}...`);
+        await deleteProject(session.token, session.organization.id, project.id);
+        await replaceProjectCache(this.config.configDir, session, projects.filter(({ id }) => id !== project.id));
+        if (!this.jsonEnabled())
+            this.log(`✓ Deleted project ${terminalText(project.name)}`);
+        return { id: project.id, name: project.name };
+    }
+}

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/dist/projects/client.d.ts

@@ -7,3 +7,4 @@ export interface Project {
 }
 export declare function listProjects(token: string, organizationID: string): Promise<Project[]>;
 export declare function createProject(token: string, organizationID: string, name: string): Promise<Project>;
+export declare function deleteProject(token: string, organizationID: string, projectID: string): Promise<void>;

package/dist/projects/client.js

@@ -17,6 +17,12 @@ export async function createProject(token, organizationID, name) {
         throw new Error('Ardent API returned an invalid project response.');
     return project;
 }
+export async function deleteProject(token, organizationID, projectID) {
+    const response = await request(token, `/projects/${encodeURIComponent(projectID)}?organization_id=${encodeURIComponent(organizationID)}`, { method: 'DELETE' });
+    if (response !== undefined) {
+        throw new Error('Ardent API did not confirm project deletion. Run ardent project list before retrying.');
+    }
+}
 function isProject(value, organizationID) {
     if (typeof value !== 'object' || value === null)
         return false;

package/oclif.manifest.json

@@ -95,6 +95,122 @@
         "status.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": {
@@ -131,6 +247,42 @@
         "create.js"
       ]
     },
+    "project:delete": {
+      "aliases": [],
+      "args": {
+        "name": {
+          "description": "Project name",
+          "name": "name",
+          "required": true
+        }
+      },
+      "description": "Delete a project by name",
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "project:delete",
+      "pluginAlias": "ardent-cli-beta",
+      "pluginName": "ardent-cli-beta",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "helpGroup": "Projects",
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "project",
+        "delete.js"
+      ]
+    },
     "project:list": {
       "aliases": [],
       "args": {},
@@ -198,5 +350,5 @@
       ]
     }
   },
-  "version": "0.0.8"
+  "version": "0.0.10"
 }

package/package.json

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