@sendly/cli 3.13.1 → 3.15.0

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

@@ -0,0 +1,12 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class TeamsCreate extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/teams/create.js

@@ -0,0 +1,58 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, colors, isJsonMode, } from "../../lib/output.js";
+import { setCurrentOrg } from "../../lib/config.js";
+import { isCI } from "../../lib/config.js";
+export default class TeamsCreate extends AuthenticatedCommand {
+    static description = "Create a new team";
+    static examples = [
+        '<%= config.bin %> teams create --name "Acme Corp"',
+        '<%= config.bin %> teams create --name "Acme Corp" --description "Our main team"',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "Team name",
+            required: true,
+        }),
+        description: Flags.string({
+            char: "d",
+            description: "Team description",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(TeamsCreate);
+        const body = { name: flags.name };
+        if (flags.description)
+            body.description = flags.description;
+        const response = await apiClient.post("/api/organizations", body);
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        success("Team created", {
+            Name: response.name,
+            ID: colors.dim(response.id),
+            Slug: colors.dim(response.slug),
+        });
+        if (!isCI()) {
+            const { default: inquirer } = await import("inquirer");
+            const { switchNow } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "switchNow",
+                    message: "Switch to this team now?",
+                    default: true,
+                },
+            ]);
+            if (switchNow) {
+                setCurrentOrg(response.id, response.name, response.slug);
+                console.log();
+                success(`Switched to ${colors.primary(response.name)}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,10 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class TeamsCurrent extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/teams/current.js

@@ -0,0 +1,33 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { json, info, keyValue, colors, isJsonMode } from "../../lib/output.js";
+import { getCurrentOrg } from "../../lib/config.js";
+export default class TeamsCurrent extends AuthenticatedCommand {
+    static description = "Show the currently active team";
+    static examples = [
+        "<%= config.bin %> teams current",
+        "<%= config.bin %> teams current --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const org = getCurrentOrg();
+        if (isJsonMode()) {
+            json(org || { message: "No active team" });
+            return;
+        }
+        if (!org) {
+            info("No active team set");
+            console.log();
+            console.log(`  Run ${colors.code("sendly teams switch")} to select a team`);
+            return;
+        }
+        console.log();
+        keyValue({
+            Team: colors.primary(org.name),
+            ID: colors.dim(org.id),
+            ...(org.slug ? { Slug: colors.dim(org.slug) } : {}),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,14 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class TeamsInvite extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        email: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        role: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/teams/invite.js

@@ -0,0 +1,48 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, colors, isJsonMode } from "../../lib/output.js";
+import { getCurrentOrg } from "../../lib/config.js";
+export default class TeamsInvite extends AuthenticatedCommand {
+    static description = "Invite a member to the current team";
+    static examples = [
+        "<%= config.bin %> teams invite user@example.com",
+        "<%= config.bin %> teams invite user@example.com --role admin",
+    ];
+    static args = {
+        email: Args.string({
+            description: "Email address to invite",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        role: Flags.string({
+            char: "r",
+            description: "Role to assign (admin, member, viewer)",
+            options: ["admin", "member", "viewer"],
+            default: "member",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TeamsInvite);
+        const org = getCurrentOrg();
+        if (!org) {
+            this.error("No active team. Run 'sendly teams switch' to select one.");
+        }
+        const response = await apiClient.post(`/api/organizations/${org.id}/invitations`, {
+            email: args.email,
+            role: flags.role,
+        });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        success(`Invitation sent to ${colors.primary(args.email)}`, {
+            Team: org.name,
+            Role: flags.role,
+            Expires: new Date(response.expiresAt).toLocaleDateString(),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,10 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class TeamsList extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/teams/list.js

@@ -0,0 +1,71 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { table, json, info, colors, isJsonMode, formatRelativeTime, } from "../../lib/output.js";
+import { getCurrentOrg } from "../../lib/config.js";
+export default class TeamsList extends AuthenticatedCommand {
+    static description = "List your teams";
+    static examples = [
+        "<%= config.bin %> teams list",
+        "<%= config.bin %> teams list --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const orgs = await apiClient.get("/api/organizations");
+        if (isJsonMode()) {
+            json(orgs);
+            return;
+        }
+        if (orgs.length === 0) {
+            info("No teams found");
+            console.log();
+            console.log(`  Create one with ${colors.code("sendly teams create --name \"My Team\"")}`);
+            return;
+        }
+        const currentOrg = getCurrentOrg();
+        console.log();
+        table(orgs.map((org) => ({
+            ...org,
+            isCurrent: currentOrg?.id === org.id,
+        })), [
+            {
+                header: "",
+                key: "isCurrent",
+                width: 3,
+                formatter: (v) => (v ? colors.primary("→") : " "),
+            },
+            {
+                header: "Name",
+                key: "name",
+                width: 24,
+            },
+            {
+                header: "Role",
+                key: "role",
+                width: 10,
+                formatter: (v) => {
+                    const role = String(v);
+                    if (role === "owner")
+                        return colors.warning(role);
+                    if (role === "admin")
+                        return colors.info(role);
+                    return role;
+                },
+            },
+            {
+                header: "Members",
+                key: "memberCount",
+                width: 10,
+                formatter: (v) => (v != null ? String(v) : colors.dim("-")),
+            },
+            {
+                header: "Created",
+                key: "createdAt",
+                width: 14,
+                formatter: (v) => (v ? formatRelativeTime(String(v)) : colors.dim("-")),
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,10 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class TeamsMembers extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/teams/members.js

@@ -0,0 +1,66 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { table, json, info, colors, isJsonMode, formatRelativeTime, } from "../../lib/output.js";
+import { getCurrentOrg } from "../../lib/config.js";
+export default class TeamsMembers extends AuthenticatedCommand {
+    static description = "List members of the current team";
+    static examples = [
+        "<%= config.bin %> teams members",
+        "<%= config.bin %> teams members --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const org = getCurrentOrg();
+        if (!org) {
+            this.error("No active team. Run 'sendly teams switch' to select one.");
+        }
+        const members = await apiClient.get(`/api/organizations/${org.id}/members`);
+        if (isJsonMode()) {
+            json(members);
+            return;
+        }
+        if (members.length === 0) {
+            info("No members found");
+            return;
+        }
+        console.log();
+        info(`${colors.primary(org.name)} — ${members.length} member${members.length === 1 ? "" : "s"}`);
+        console.log();
+        table(members, [
+            {
+                header: "Name",
+                key: "userName",
+                width: 22,
+                formatter: (v) => String(v || "Unknown"),
+            },
+            {
+                header: "Email",
+                key: "userEmail",
+                width: 28,
+                formatter: (v) => (v ? colors.dim(String(v)) : colors.dim("-")),
+            },
+            {
+                header: "Role",
+                key: "role",
+                width: 10,
+                formatter: (v) => {
+                    const role = String(v);
+                    if (role === "owner")
+                        return colors.warning(role);
+                    if (role === "admin")
+                        return colors.info(role);
+                    return role;
+                },
+            },
+            {
+                header: "Joined",
+                key: "joinedAt",
+                width: 14,
+                formatter: (v) => (v ? formatRelativeTime(String(v)) : colors.dim("-")),
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class TeamsSwitch extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        org: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/teams/switch.js

@@ -0,0 +1,86 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, colors, isJsonMode, } from "../../lib/output.js";
+import { setCurrentOrg, clearCurrentOrg, getCurrentOrg } from "../../lib/config.js";
+import { isCI } from "../../lib/config.js";
+export default class TeamsSwitch extends AuthenticatedCommand {
+    static description = "Switch the active team";
+    static examples = [
+        "<%= config.bin %> teams switch",
+        "<%= config.bin %> teams switch <org-id-or-slug>",
+        "<%= config.bin %> teams switch --clear",
+    ];
+    static args = {
+        org: Args.string({
+            description: "Organization ID or slug to switch to",
+            required: false,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(TeamsSwitch);
+        if (args.org === "clear" || args.org === "none" || args.org === "personal") {
+            clearCurrentOrg();
+            if (isJsonMode()) {
+                json({ cleared: true });
+                return;
+            }
+            success("Switched to personal account");
+            return;
+        }
+        const orgs = await apiClient.get("/api/organizations");
+        if (args.org) {
+            const match = orgs.find((o) => o.id === args.org ||
+                o.slug === args.org ||
+                o.name.toLowerCase() === args.org.toLowerCase());
+            if (!match) {
+                this.error(`Team not found: ${args.org}`);
+            }
+            setCurrentOrg(match.id, match.name, match.slug);
+            if (isJsonMode()) {
+                json({ id: match.id, name: match.name, slug: match.slug });
+                return;
+            }
+            success(`Switched to ${colors.primary(match.name)}`);
+            return;
+        }
+        if (isCI()) {
+            this.error("Interactive mode not available in CI. Pass an org ID or slug as argument.");
+        }
+        const { default: inquirer } = await import("inquirer");
+        const currentOrg = getCurrentOrg();
+        const choices = orgs.map((o) => ({
+            name: `${o.name}${o.role ? ` (${o.role})` : ""}${o.isPersonal ? " — personal" : ""}`,
+            value: o.id,
+        }));
+        const { orgId } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "orgId",
+                message: "Select a team:",
+                choices,
+                default: currentOrg?.id,
+            },
+        ]);
+        const selected = orgs.find((o) => o.id === orgId);
+        if (selected.isPersonal) {
+            clearCurrentOrg();
+            if (isJsonMode()) {
+                json({ cleared: true });
+                return;
+            }
+            success("Switched to personal account");
+            return;
+        }
+        setCurrentOrg(selected.id, selected.name, selected.slug);
+        if (isJsonMode()) {
+            json({ id: selected.id, name: selected.name, slug: selected.slug });
+            return;
+        }
+        success(`Switched to ${colors.primary(selected.name)}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"switch.js","sourceRoot":"","sources":["../../../src/commands/teams/switch.ts"],"names":[],"mappings":"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","sourcesContent":["import { Args } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport {\n  success,\n  json,\n  info,\n  colors,\n  isJsonMode,\n} from \"../../lib/output.js\";\nimport { setCurrentOrg, clearCurrentOrg, getCurrentOrg } from \"../../lib/config.js\";\nimport { isCI } from \"../../lib/config.js\";\n\ninterface Organization {\n  id: string;\n  name: string;\n  slug: string;\n  role: string;\n  isPersonal: boolean;\n}\n\nexport default class TeamsSwitch extends AuthenticatedCommand {\n  static description = \"Switch the active team\";\n\n  static examples = [\n    \"<%= config.bin %> teams switch\",\n    \"<%= config.bin %> teams switch <org-id-or-slug>\",\n    \"<%= config.bin %> teams switch --clear\",\n  ];\n\n  static args = {\n    org: Args.string({\n      description: \"Organization ID or slug to switch to\",\n      required: false,\n    }),\n  };\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n  };\n\n  async run(): Promise<void> {\n    const { args } = await this.parse(TeamsSwitch);\n\n    if (args.org === \"clear\" || args.org === \"none\" || args.org === \"personal\") {\n      clearCurrentOrg();\n      if (isJsonMode()) {\n        json({ cleared: true });\n        return;\n      }\n      success(\"Switched to personal account\");\n      return;\n    }\n\n    const orgs = await apiClient.get<Organization[]>(\"/api/organizations\");\n\n    if (args.org) {\n      const match = orgs.find(\n        (o) =>\n          o.id === args.org ||\n          o.slug === args.org ||\n          o.name.toLowerCase() === args.org!.toLowerCase(),\n      );\n      if (!match) {\n        this.error(`Team not found: ${args.org}`);\n      }\n      setCurrentOrg(match.id, match.name, match.slug);\n      if (isJsonMode()) {\n        json({ id: match.id, name: match.name, slug: match.slug });\n        return;\n      }\n      success(`Switched to ${colors.primary(match.name)}`);\n      return;\n    }\n\n    if (isCI()) {\n      this.error(\"Interactive mode not available in CI. Pass an org ID or slug as argument.\");\n    }\n\n    const { default: inquirer } = await import(\"inquirer\");\n\n    const currentOrg = getCurrentOrg();\n    const choices = orgs.map((o) => ({\n      name: `${o.name}${o.role ? ` (${o.role})` : \"\"}${o.isPersonal ? \" — personal\" : \"\"}`,\n      value: o.id,\n    }));\n\n    const { orgId } = await inquirer.prompt([\n      {\n        type: \"list\",\n        name: \"orgId\",\n        message: \"Select a team:\",\n        choices,\n        default: currentOrg?.id,\n      },\n    ]);\n\n    const selected = orgs.find((o) => o.id === orgId)!;\n\n    if (selected.isPersonal) {\n      clearCurrentOrg();\n      if (isJsonMode()) {\n        json({ cleared: true });\n        return;\n      }\n      success(\"Switched to personal account\");\n      return;\n    }\n\n    setCurrentOrg(selected.id, selected.name, selected.slug);\n\n    if (isJsonMode()) {\n      json({ id: selected.id, name: selected.name, slug: selected.slug });\n      return;\n    }\n\n    success(`Switched to ${colors.primary(selected.name)}`);\n  }\n}\n"]}

package/dist/commands/whoami.js

@@ -1,7 +1,7 @@
 import { BaseCommand } from "../lib/base-command.js";
 import { getAuthInfo } from "../lib/auth.js";
 import { success, info, keyValue, colors, json } from "../lib/output.js";
-import { getConfigValue, getConfigPath } from "../lib/config.js";
+import { getConfigValue, getConfigPath, getCurrentOrg } from "../lib/config.js";
 export default class Whoami extends BaseCommand {
     static description = "Show current authentication status";
     static examples = ["<%= config.bin %> whoami"];
@@ -11,6 +11,7 @@ export default class Whoami extends BaseCommand {
     async run() {
         const { flags } = await this.parse(Whoami);
         const authInfo = await getAuthInfo();
+        const org = getCurrentOrg();
         if (flags.json) {
             json({
                 authenticated: authInfo.authenticated,
@@ -19,6 +20,7 @@ export default class Whoami extends BaseCommand {
                 environment: authInfo.environment,
                 keyType: authInfo.keyType,
                 configPath: getConfigPath(),
+                organization: org ? { id: org.id, name: org.name, slug: org.slug } : null,
             });
             return;
         }
@@ -48,8 +50,11 @@ export default class Whoami extends BaseCommand {
         if (baseUrl && baseUrl !== "https://sendly.live") {
             displayData["Server"] = colors.dim(baseUrl);
         }
+        if (org) {
+            displayData["Team"] = colors.primary(org.name) + colors.dim(` (${org.id})`);
+        }
         displayData["Config"] = colors.dim(getConfigPath());
         keyValue(displayData);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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