@sendbird/cli 0.0.0-stage → 0.3.0-alpha.1

package/dist/local.js

@@ -0,0 +1,707 @@
+import { setupContextSummary } from "./human-output.js";
+import { skillCommand } from "./skills.js";
+import { diagnose } from "./diagnostics.js";
+import { input, password, select } from "@inquirer/prompts";
+import { z } from "zod";
+import { readFileSync } from "node:fs";
+import { CliError, encodeSegment, config, saveConfig, profile, updateProfile, getSecret, request, parse, } from "./core.js";
+import { transport, verify, checkAppOrg, context, execute, definition, } from "./runner.js";
+import { loginOAuth, logoutOAuth } from "./oauth.js";
+import { createProject, readProject } from "./project.js";
+export const localCommands = [
+    ...[
+        {
+            name: "skills install",
+            description: "Register the bundled CLI Skill for Claude Code or Codex, offline",
+            fields: ["agent", "scope"],
+            example: "sendbird skills install --agent claude --scope project --dry-run",
+        },
+        {
+            name: "skills status",
+            description: "Inspect local Skill registrations and versions; host loading is unverified",
+            fields: ["agent", "scope"],
+            example: "sendbird skills status",
+        },
+        {
+            name: "skills show",
+            description: "Read the bundled CLI Skill and its reference paths without installing",
+            fields: [],
+            example: "sendbird --json skills show",
+        },
+        {
+            name: "skills remove",
+            description: "Remove only an unchanged Skill registered by this CLI",
+            fields: ["agent", "scope"],
+            example: "sendbird skills remove --agent claude --scope project --yes",
+        },
+    ],
+    {
+        name: "project status",
+        description: "Read the local non-secret Sendbird project marker",
+        fields: [],
+        example: "sendbird project status",
+    },
+    {
+        name: "project init",
+        description: "Create sendbird.json from the selected app context for project and Agent discovery",
+        fields: [],
+        example: "sendbird --app-id APP_ID project init --yes",
+    },
+    {
+        name: "app sdk-config",
+        description: "Discover app-bound SDK API/WebSocket endpoints without returning credentials",
+        fields: [],
+        example: "sendbird --profile staging --app-id APP_ID app sdk-config --raw > sdk-config.json",
+    },
+    {
+        name: "auth login",
+        description: "Log in through environment-bound browser OAuth",
+        fields: ["method"],
+        example: "sendbird --profile staging auth login --method oauth",
+    },
+    {
+        name: "auth signup",
+        description: "Sign up in Dashboard, then return to CLI via browser OAuth",
+        fields: [],
+        example: "sendbird --profile staging auth signup",
+    },
+    {
+        name: "auth verify-email",
+        description: "Verify the signed-in account using a private email link or token file",
+        fields: ["token-file"],
+        example: "sendbird auth verify-email --token-file ./verification-link.txt",
+    },
+    {
+        name: "auth resend-verification",
+        description: "Resend the signed-in account's email verification message",
+        fields: [],
+        example: "sendbird auth resend-verification",
+    },
+    {
+        name: "auth status",
+        description: "Validate current session and show granted permissions",
+        fields: [],
+        example: "sendbird auth status",
+    },
+    {
+        name: "auth logout",
+        description: "Revoke saved OAuth tokens",
+        fields: [],
+        example: "sendbird auth logout",
+    },
+    {
+        name: "profile",
+        description: "Show the selected profile and saved active profile",
+        fields: [],
+        example: "sendbird profile",
+    },
+    {
+        name: "profile list",
+        description: "List saved environment profiles",
+        fields: [],
+        example: "sendbird profile list",
+    },
+    {
+        name: "profile create",
+        description: "Create a prod/staging profile",
+        fields: ["name", "env"],
+        example: "sendbird profile create --name staging --env staging",
+    },
+    {
+        name: "profile use",
+        description: "Select a profile",
+        fields: ["name"],
+        example: "sendbird profile use --name staging",
+    },
+    {
+        name: "profile delete",
+        description: "Revoke saved credentials and delete a profile",
+        fields: ["name"],
+        example: "sendbird profile delete --name demo --yes",
+    },
+    {
+        name: "org use",
+        description: "Verify organization access and select it; clears selected app",
+        fields: ["id"],
+        example: "sendbird org use --id ORG_UID",
+    },
+    {
+        name: "org clear",
+        description: "Clear the saved organization, app and region selection",
+        fields: [],
+        example: "sendbird org clear",
+    },
+    {
+        name: "org region list",
+        description: "List Chat regions available to the selected organization",
+        fields: [],
+        example: "sendbird org region list",
+    },
+    {
+        name: "org region use",
+        description: "Select a Chat region for future app creation",
+        fields: ["id"],
+        example: "sendbird org region use --id us-1",
+    },
+    {
+        name: "app use",
+        description: "Verify application access and select it",
+        fields: ["id"],
+        example: "sendbird app use --id APP_ID",
+    },
+    {
+        name: "app clear",
+        description: "Clear the saved application selection",
+        fields: [],
+        example: "sendbird app clear",
+    },
+    {
+        name: "doctor",
+        description: "Inspect account, Pro plan, feature evidence and optional command prerequisites without mutations",
+        fields: ["command", "type", "id", "as-user", "region"],
+        example: "sendbird doctor",
+    },
+    {
+        name: "setup",
+        description: "Guided login, org/app selection and optional default context saving",
+        fields: [],
+        example: "sendbird setup",
+    },
+];
+export const setupSchema = z.object({
+    profile: z.string(),
+    environment: z.enum(["prod", "staging"]),
+    org_id: z.string(),
+    app_id: z.string(),
+    app_region: z.string().nullable(),
+    region: z.string().nullable(),
+    defaults_saved: z.boolean(),
+    active_profile: z.string(),
+    next_argv: z.array(z.string()).min(1),
+    agent_setup_next: z.array(z.string()),
+});
+function required(value, key) {
+    return parse(z.string().min(1), value ?? undefined);
+}
+function needTTY() {
+    if (!process.stdin.isTTY || !process.stderr.isTTY)
+        throw new CliError("E_INPUT", "Interactive input requires a terminal. Use explicit file options for headless login.", 2);
+}
+const promptConfig = { output: process.stderr };
+export async function login(fields, opts) {
+    const p = profile(opts.profile);
+    if (fields.method && fields.method !== "oauth")
+        throw new CliError("E_INPUT", "Only --method oauth is supported", 2);
+    if (Object.keys(fields).some((key) => key !== "method"))
+        throw new CliError("E_INPUT", "Password and cookie login options are no longer supported", 2);
+    const who = await loginOAuth(p.name, p.env, {
+        onUrl: (url) => process.stderr.write(`Open this URL to authorize Sendbird CLI: ${url}\n`),
+    });
+    // A different account must never inherit the previous account's defaults.
+    updateProfile(p.name, {
+        orgId: undefined,
+        appId: undefined,
+        region: undefined,
+    });
+    return {
+        authenticated: true,
+        profile: p.name,
+        user: who.user,
+        method: "oauth",
+    };
+}
+export async function signup(_fields, opts) {
+    const p = profile(opts.profile);
+    if (getSecret(p.name))
+        throw new CliError("E_AUTH", "This profile is already authenticated; use another profile or log out first", 4);
+    const who = await loginOAuth(p.name, p.env, {
+        entry: "signup",
+        // A new account needs time to complete the web form and consent screen.
+        timeoutMs: 10 * 60_000,
+        onUrl: (url) => process.stderr.write(`Open this URL to sign up: ${url}\n`),
+    });
+    updateProfile(p.name, {
+        orgId: undefined,
+        appId: undefined,
+        region: undefined,
+    });
+    return {
+        registered: true,
+        authenticated: true,
+        method: "oauth",
+        profile: p.name,
+        user: who.user,
+        next: ["sendbird setup"],
+    };
+}
+function verificationToken(value, env) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new CliError("E_INPUT", "Verification token is empty", 2);
+    if (!/^https?:\/\//i.test(trimmed))
+        return trimmed;
+    let url;
+    try {
+        url = new URL(trimmed);
+    }
+    catch {
+        throw new CliError("E_INPUT", "Invalid verification link", 2);
+    }
+    const dashboardOrigins = env === "prod"
+        ? ["https://dashboard.sendbird.com"]
+        : [
+            "https://dashboard-dev.sendbird.com",
+            "https://dashboard.stg.sendbirdtest.com",
+        ];
+    if (!dashboardOrigins.includes(url.origin) ||
+        url.pathname !== "/auth/verify_email")
+        throw new CliError("E_INPUT", "Verification link is not for this Dashboard environment", 2);
+    const token = url.searchParams.get("email_verification_token");
+    if (!token)
+        throw new CliError("E_INPUT", "Verification link has no token", 2);
+    return token;
+}
+async function verifyEmail(fields, opts) {
+    const p = profile(opts.profile);
+    if (opts.dryRun)
+        return {
+            method: "GET",
+            path: "/dashboard_api/profiles/verify_user_email/",
+            token: "[REDACTED]",
+            sent: false,
+        };
+    const source = fields.tokenFile
+        ? readFileSync(fields.tokenFile, "utf8")
+        : (needTTY(),
+            await password({ message: "Email verification link or token:", mask: true }, promptConfig));
+    const token = verificationToken(source, p.env);
+    try {
+        await request(transport(opts), {
+            method: "GET",
+            path: "/dashboard_api/profiles/verify_user_email/",
+            query: { token },
+        });
+    }
+    catch (error) {
+        // Gate's verification URL is a one-use mutation despite its GET method.
+        // A lost response or already-used token requires a status read before retry.
+        if (!(error instanceof CliError) ||
+            !["E_NETWORK", "E_VALIDATION"].includes(error.code))
+            throw error;
+        try {
+            const current = await verify(transport(opts));
+            if (current.user
+                ?.email_verified === true)
+                return { email_verified: true, profile: p.name };
+        }
+        catch {
+            /* Preserve the original uncertain verification outcome. */
+        }
+        if (error.code === "E_NETWORK")
+            throw new CliError("E_NETWORK", "Email verification outcome is unknown; check auth status before retrying", 7);
+        throw error;
+    }
+    const who = await verify(transport(opts));
+    if (who.user?.email_verified !==
+        true)
+        throw new CliError("E_SCHEMA", "Email verification was not reflected in account status", 8);
+    return { email_verified: true, profile: p.name };
+}
+async function availableRegions(opts, t) {
+    const p = profile(opts.profile);
+    const orgId = opts.orgId ?? p.orgId;
+    if (!orgId)
+        throw new CliError("E_CONTEXT", "Select an organization first", 2);
+    const org = (await request(t ?? transport(opts), {
+        method: "GET",
+        path: `/dashboard_api/organizations/${encodeSegment(orgId)}/`,
+    }));
+    if (org.uid !== orgId)
+        throw new CliError("E_SCHEMA", "Organization region response has a different ID", 8);
+    const regions = Object.entries(org.regions ?? {}).map(([id, region]) => ({
+        id,
+        name: region.name ?? id,
+        available: region.allowed === true && region.allow_app_creation === true,
+    }));
+    return { orgId, regions };
+}
+export async function local(name, f, opts) {
+    if (name.startsWith("skills "))
+        return skillCommand(name.slice(7), f, opts);
+    // Local handlers can revoke credentials or persist context. Never label an
+    // executed side effect as a preview: unsupported previews fail before I/O.
+    if (opts.dryRun &&
+        ![
+            "profile",
+            "profile list",
+            "project status",
+            "auth verify-email",
+            "auth resend-verification",
+        ].includes(name))
+        throw new CliError("E_INPUT", "This command does not support --dry-run; no action was performed. Use --help or --example to inspect it", 2);
+    if (name === "project status") {
+        const project = readProject();
+        return project
+            ? { linked: true, path: "./sendbird.json", project }
+            : {
+                linked: false,
+                path: "./sendbird.json",
+                next: ["sendbird --app-id APP_ID project init --yes"],
+            };
+    }
+    if (name === "project init") {
+        if (!opts.yes)
+            throw new CliError("E_CONFIRMATION", "Creating sendbird.json requires --yes; it stores no credentials", 2);
+        const resolved = context(opts);
+        if (!resolved.appId)
+            throw new CliError("E_CONTEXT", "Select an application or pass --app-id before creating sendbird.json", 2);
+        const selected = profile(opts.profile);
+        return createProject({
+            app_id: resolved.appId,
+            ...(resolved.orgId ? { org_id: resolved.orgId } : {}),
+            ...(resolved.region ? { region: resolved.region } : {}),
+            profile: selected.name,
+        });
+    }
+    if (name === "profile") {
+        const c = config();
+        const selected = profile(opts.profile);
+        return {
+            current: selected.name,
+            active: c.active,
+            source: opts.profile
+                ? "--profile"
+                : process.env.SENDBIRD_PROFILE
+                    ? "SENDBIRD_PROFILE"
+                    : "saved active",
+            environment: selected.env,
+            org_id: selected.orgId ?? null,
+            app_id: selected.appId ?? null,
+            region: selected.region ?? null,
+        };
+    }
+    if (name === "profile list")
+        return config();
+    if (name === "profile create") {
+        const name = parse(z
+            .string()
+            .min(1)
+            .max(64)
+            .regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/)
+            .refine((name) => !/[\r\n\0]/.test(name)), f.name);
+        const env = parse(z.enum(["prod", "staging"]), f.env);
+        const c = config();
+        if (c.profiles[name])
+            throw new CliError("E_CONFLICT", "Profile already exists", 5);
+        c.profiles[name] = { env };
+        saveConfig(c);
+        return { name, env };
+    }
+    if (name === "profile use") {
+        const p = profile(required(f.name, "name"));
+        const c = config();
+        c.active = p.name;
+        saveConfig(c);
+        return { active: p.name };
+    }
+    if (name === "profile delete") {
+        const selected = profile(required(f.name, "name"));
+        const c = config();
+        if (Object.keys(c.profiles).length === 1)
+            throw new CliError("E_CONFLICT", "Cannot delete the last profile", 5);
+        if (!opts.yes)
+            throw new CliError("E_CONFIRM", "Deleting a profile revokes its saved login; rerun with --yes", 2);
+        const revocation = await logoutOAuth(selected.name);
+        delete c.profiles[selected.name];
+        if (c.active === selected.name)
+            c.active = c.profiles.prod ? "prod" : Object.keys(c.profiles).sort()[0];
+        saveConfig(c);
+        return { deleted: selected.name, active: c.active, ...revocation };
+    }
+    if (name === "auth login")
+        return login(f, opts);
+    if (name === "auth signup")
+        return signup(f, opts);
+    const p = profile(opts.profile);
+    opts = { ...opts, profile: p.name };
+    if (name === "app clear" || name === "org clear") {
+        if (opts.orgId || opts.appId)
+            throw new CliError("E_INPUT", "Clear changes saved context; omit one-command --org-id and --app-id overrides", 2);
+        updateProfile(p.name, name === "app clear"
+            ? { appId: undefined }
+            : { orgId: undefined, appId: undefined, region: undefined });
+        return {
+            profile: p.name,
+            cleared: name === "app clear" ? ["app"] : ["organization", "app", "region"],
+        };
+    }
+    if (name === "auth verify-email")
+        return verifyEmail(f, opts);
+    if (name === "auth resend-verification") {
+        if (opts.dryRun)
+            return {
+                method: "POST",
+                path: "/dashboard_api/profiles/resend_email_verification_mail/",
+                sent: false,
+            };
+        await request(transport(opts), {
+            method: "POST",
+            path: "/dashboard_api/profiles/resend_email_verification_mail/",
+            body: {},
+        });
+        return { verification_email_sent: true };
+    }
+    if (name === "auth logout") {
+        const revoked = await logoutOAuth(p.name);
+        updateProfile(p.name, {
+            orgId: undefined,
+            appId: undefined,
+            region: undefined,
+        });
+        return { logged_out: true, ...revoked };
+    }
+    if (name === "app sdk-config") {
+        const { discoverSdkConfig } = await import("./sdk-config.js");
+        return discoverSdkConfig(opts);
+    }
+    if (name === "auth status") {
+        const who = await verify(transport(opts));
+        const method = "oauth";
+        if (f.summary)
+            return {
+                authenticated: true,
+                profile: p.name,
+                environment: p.env,
+                method,
+                user: { id: who.user?.user_id, email: who.user?.email },
+                organizations: (who.organizations ?? (who.organization ? [who.organization] : [])).map((o) => ({ uid: o.uid, name: o.name })),
+                role: {
+                    name: who.role?.name,
+                    is_predefined: who.role?.is_predefined,
+                    permissions: who.role?.permissions,
+                },
+            };
+        return {
+            authenticated: true,
+            profile: p.name,
+            method,
+            ...who,
+        };
+    }
+    if (name === "org use") {
+        const id = required(f.id, "id");
+        await request(transport(opts), {
+            method: "GET",
+            path: `/dashboard_api/organizations/${encodeSegment(id)}/`,
+        });
+        updateProfile(p.name, { orgId: id, appId: undefined, region: undefined });
+        return { org_id: id, app_id: null, region: null };
+    }
+    if (name === "org region list") {
+        const { orgId, regions } = await availableRegions(opts);
+        return {
+            org_id: orgId,
+            selected_region: orgId === p.orgId ? (p.region ?? null) : null,
+            regions,
+        };
+    }
+    if (name === "org region use") {
+        const id = required(f.id, "id");
+        const { orgId, regions } = await availableRegions(opts);
+        if (orgId !== p.orgId)
+            throw new CliError("E_CONTEXT", "Select the organization with org use before saving its region", 2);
+        if (!regions.some((region) => region.id === id && region.available))
+            throw new CliError("E_REGION", "Region is unavailable for Chat app creation", 5);
+        updateProfile(p.name, { region: id });
+        return { org_id: orgId, region: id };
+    }
+    if (name === "app use") {
+        const id = required(f.id, "id");
+        const t = transport(opts);
+        const app = await checkAppOrg(t, id, opts.orgId ?? p.orgId);
+        const uid = app.organization?.uid;
+        let selectedOrg = uid ?? opts.orgId ?? p.orgId;
+        if (!selectedOrg) {
+            const who = await verify(t);
+            const organizations = who.organizations ?? (who.organization ? [who.organization] : []);
+            if (organizations.length !== 1 ||
+                typeof organizations[0]?.uid !== "string")
+                throw new CliError("E_CONTEXT", "Select an organization before selecting the app", 2);
+            selectedOrg = organizations[0].uid;
+            await checkAppOrg(t, id, selectedOrg);
+        }
+        updateProfile(p.name, {
+            appId: id,
+            orgId: selectedOrg,
+            ...(p.orgId && selectedOrg !== p.orgId ? { region: undefined } : {}),
+        });
+        return { app_id: id, org_id: selectedOrg };
+    }
+    if (name === "doctor")
+        return diagnose(opts, f);
+    if (name === "setup") {
+        needTTY();
+        process.stderr.write(`Sendbird setup: profile ${p.name} (${p.env})\n`);
+        try {
+            await verify(transport(opts));
+        }
+        catch (e) {
+            if (!(e instanceof CliError) || e.code !== "E_AUTH")
+                throw e;
+            const entry = await select({
+                message: "Account",
+                choices: [
+                    { name: "Sign in", value: "login" },
+                    { name: "Create a Sendbird account", value: "signup" },
+                ],
+            }, promptConfig);
+            if (entry === "signup")
+                await signup({}, opts);
+            else
+                await login({}, opts);
+        }
+        const setupTransport = transport(opts);
+        if (setupTransport.env !== p.env)
+            throw new CliError("E_CONTEXT", "Profile environment changed during setup; rerun setup", 2);
+        const list = (await execute(definition("org list"), {}, opts, setupTransport));
+        const orgId = await select({
+            message: "Organization",
+            choices: [
+                ...list.organizations.map((o) => ({
+                    name: o.name ?? o.organization_name ?? o.uid,
+                    value: o.uid,
+                })),
+                ...(list.organizations.length === 0
+                    ? [{ name: "Create organization", value: "__new" }]
+                    : []),
+            ],
+        }, promptConfig);
+        let selectedOrg = orgId;
+        if (orgId === "__new") {
+            const name = await input({ message: "Organization name:" }, promptConfig);
+            const result = (await execute(definition("org create"), { body: { organization_name: name } }, opts, setupTransport));
+            selectedOrg = result.organizations[0]?.uid;
+            if (!selectedOrg)
+                throw new CliError("E_SCHEMA", "Created organization; select its ID with org use", 8);
+        }
+        // Resolve selections in memory. Do not partially replace saved defaults
+        // while the user is still choosing or can cancel the wizard.
+        const scoped = { ...opts, project: false, orgId: selectedOrg };
+        const { regions } = await availableRegions(scoped, setupTransport);
+        let selectedRegion;
+        let appId;
+        let offset = 0;
+        let createNew = false;
+        while (!appId && !createNew) {
+            const page = (await execute(definition("app list"), { query: { offset, limit: 20 } }, scoped, setupTransport));
+            const choice = await select({
+                message: "Application",
+                choices: [
+                    ...page.results.map((a) => ({
+                        name: `${a.app_name ?? a.app_id} (${a.app_id})`,
+                        value: `app:${a.app_id}`,
+                    })),
+                    ...(page.next ? [{ name: "Next page", value: "__more" }] : []),
+                    { name: "Enter an existing application ID", value: "__manual" },
+                    { name: "Create Chat application", value: "__new" },
+                ],
+            }, promptConfig);
+            if (choice === "__more") {
+                offset += 20;
+                continue;
+            }
+            if (choice === "__manual")
+                appId = await input({ message: "Application ID:" }, promptConfig);
+            else if (choice === "__new")
+                createNew = true;
+            else
+                appId = choice.slice(4);
+        }
+        if (createNew) {
+            const appName = await input({ message: "Application name:" }, promptConfig);
+            const choices = regions
+                .filter((r) => r.available)
+                .map((r) => ({ name: `${r.name} (${r.id})`, value: r.id }));
+            if (!choices.length)
+                throw new CliError("E_REGION", "No Chat region available for app creation; inspect org get or contact support", 5);
+            selectedRegion = await select({ message: "Chat region", choices }, promptConfig);
+            const result = (await execute(definition("app create"), { body: { app_name: appName, region: selectedRegion } }, scoped, setupTransport));
+            appId = result.application.app_id;
+        }
+        const selectedApp = required(appId, "appId");
+        const app = await checkAppOrg(setupTransport, selectedApp, selectedOrg);
+        const appRegion = typeof app.region === "string" ? app.region : null;
+        if (!createNew) {
+            const choices = regions
+                .filter((r) => r.available)
+                .map((r) => ({ name: `${r.name} (${r.id})`, value: r.id }));
+            if (choices.length) {
+                const chosen = await select({
+                    message: "Default region for future Chat apps (does not move this app)",
+                    choices: [
+                        ...choices,
+                        { name: "Do not set a default region", value: "__none" },
+                    ],
+                    default: choices.some((r) => r.value === appRegion)
+                        ? appRegion
+                        : "__none",
+                }, promptConfig);
+                selectedRegion = chosen === "__none" ? undefined : chosen;
+            }
+        }
+        const selection = {
+            profile: p.name,
+            environment: p.env,
+            org_id: selectedOrg,
+            app_id: selectedApp,
+            app_region: appRegion,
+            region: selectedRegion ?? null,
+        };
+        process.stderr.write(setupContextSummary(selection) + "\n");
+        const decision = await select({
+            message: "Save these as your defaults?",
+            choices: [
+                {
+                    name: "Save organization, app and region, and make this profile active",
+                    value: "save",
+                },
+                { name: "Finish without changing selection defaults", value: "skip" },
+            ],
+            default: "save",
+        }, promptConfig);
+        const saved = decision === "save";
+        if (saved) {
+            // Read again so unrelated profiles changed during setup are retained.
+            const latest = config();
+            if (latest.profiles[p.name]?.env !== p.env)
+                throw new CliError("E_CONTEXT", "Profile changed during setup; rerun setup before saving defaults", 2);
+            latest.profiles[p.name] = {
+                ...latest.profiles[p.name],
+                orgId: selectedOrg,
+                appId: selectedApp,
+                region: selectedRegion,
+            };
+            latest.active = p.name;
+            saveConfig(latest);
+        }
+        const nextArgv = [
+            "sendbird",
+            "--profile",
+            p.name,
+            "--org-id",
+            selectedOrg,
+            "--app-id",
+            selectedApp,
+            "doctor",
+        ];
+        return setupSchema.parse({
+            ...selection,
+            defaults_saved: saved,
+            active_profile: config().active,
+            next_argv: nextArgv,
+            agent_setup_next: ["sendbird", "skills", "status"],
+        });
+    }
+    throw new CliError("E_COMMAND", "Unknown command", 2);
+}
+//# sourceMappingURL=local.js.map