@fulldivevr/workcord-cli 1.0.0

package/dist/commands/users.js

@@ -0,0 +1,126 @@
+import { call } from "../client.js";
+import { getOrCreateGroup } from "./_group.js";
+const DEFAULT_LIMIT = 20;
+const MAX_LIMIT = 100;
+const MAX_PUBLIC_PLAN = "teams";
+const PLAN_TIERS = new Set(["free", "creator", "pro", "teams"]);
+const PLAN_PLATFORMS = new Set(["stripe", "apple", "google", "internal"]);
+const ACCOUNT_TYPES = new Set(["all", "authenticated", "anonymous"]);
+function parseLimit(v) {
+    const limit = Number(v);
+    if (!Number.isInteger(limit) || limit < 1 || limit > MAX_LIMIT) {
+        throw new Error(`--limit must be an integer from 1 to ${MAX_LIMIT}`);
+    }
+    return limit;
+}
+function parsePlanTier(v) {
+    if (!PLAN_TIERS.has(v)) {
+        throw new Error(`--tier must be one of: ${Array.from(PLAN_TIERS).join(", ")}`);
+    }
+    return v;
+}
+function parsePlanPlatform(v) {
+    if (!PLAN_PLATFORMS.has(v)) {
+        throw new Error(`--platform must be one of: ${Array.from(PLAN_PLATFORMS).join(", ")}`);
+    }
+    return v;
+}
+function parseAccountType(v) {
+    if (!ACCOUNT_TYPES.has(v)) {
+        throw new Error(`--account-type must be one of: ${Array.from(ACCOUNT_TYPES).join(", ")}`);
+    }
+    return v;
+}
+function internalApiKey() {
+    const key = process.env.WORKCORD_INTERNAL_API_KEY;
+    if (!key) {
+        throw new Error("WORKCORD_INTERNAL_API_KEY must be set");
+    }
+    return key;
+}
+async function setPlanOverride(opts) {
+    return call({
+        method: "POST",
+        path: `/api/v1/internal/users/${encodeURIComponent(opts.user)}/tier`,
+        asUserId: opts.as,
+        headers: { "x-internal-key": internalApiKey() },
+        body: { tier: opts.tier, platform: opts.platform },
+    });
+}
+export function registerUsers(program) {
+    const group = getOrCreateGroup(program, "users", "Users operations");
+    group
+        .command("list")
+        .description("List/search one page of public users. Output: { users, count, nextCursor }.")
+        .option("--q <query>", "search query; empty string lists users", "")
+        .option("--limit <n>", `page size, 1-${MAX_LIMIT}`, String(DEFAULT_LIMIT))
+        .option("--cursor <cursor>", "pagination cursor from the previous page's nextCursor")
+        .option("--account-type <type>", "internal filter: all, authenticated, anonymous")
+        .option("--authenticated", "shortcut for --account-type authenticated")
+        .action(async (opts) => {
+        const { as } = program.opts();
+        if (!as)
+            throw new Error("--as <userId> is required");
+        const limit = parseLimit(opts.limit);
+        if (opts.authenticated && opts.accountType) {
+            throw new Error("Use either --authenticated or --account-type, not both");
+        }
+        const accountType = opts.authenticated ? "authenticated" : opts.accountType;
+        if (accountType !== undefined) {
+            const data = (await call({
+                method: "GET",
+                path: "/api/v1/internal/users",
+                query: { q: opts.q, limit, cursor: opts.cursor, accountType: parseAccountType(accountType) },
+                asUserId: as,
+                headers: { "x-internal-key": internalApiKey() },
+            }));
+            const users = data.users ?? [];
+            process.stdout.write(JSON.stringify({ ...data, users, count: users.length, nextCursor: data.cursor ?? null }) + "\n");
+            return;
+        }
+        const data = (await call({
+            method: "GET",
+            path: "/api/v1/search",
+            query: { type: "users", q: opts.q, limit, cursor: opts.cursor },
+            asUserId: as,
+        }));
+        const users = data.users ?? [];
+        process.stdout.write(JSON.stringify({ ...data, users, count: users.length, nextCursor: data.cursor ?? null }) + "\n");
+    });
+    group
+        .command("set-plan")
+        .description("Set a user's plan override through the internal API. Requires WORKCORD_INTERNAL_API_KEY.")
+        .requiredOption("--user <userId>", "target user id")
+        .requiredOption("--tier <tier>", `plan tier: ${Array.from(PLAN_TIERS).join(", ")}`)
+        .option("--platform <platform>", `subscription platform: ${Array.from(PLAN_PLATFORMS).join(", ")}`)
+        .action(async (opts) => {
+        const { as } = program.opts();
+        if (!as)
+            throw new Error("--as <userId> is required");
+        const data = await setPlanOverride({
+            as,
+            user: opts.user,
+            tier: parsePlanTier(opts.tier),
+            platform: opts.platform === undefined ? undefined : parsePlanPlatform(opts.platform),
+        });
+        process.stdout.write(JSON.stringify(data) + "\n");
+    });
+    group
+        .command("set-max-plan")
+        .description(`Set a user to the max public plan (${MAX_PUBLIC_PLAN}) through the internal API.`)
+        .requiredOption("--user <userId>", "target user id")
+        .option("--platform <platform>", `subscription platform: ${Array.from(PLAN_PLATFORMS).join(", ")}`)
+        .action(async (opts) => {
+        const { as } = program.opts();
+        if (!as)
+            throw new Error("--as <userId> is required");
+        const data = await setPlanOverride({
+            as,
+            user: opts.user,
+            tier: MAX_PUBLIC_PLAN,
+            platform: opts.platform === undefined ? undefined : parsePlanPlatform(opts.platform),
+        });
+        process.stdout.write(JSON.stringify(data) + "\n");
+    });
+}
+//# sourceMappingURL=users.js.map

package/dist/commands/whoami.js

@@ -0,0 +1,15 @@
+import { mintToken } from "../auth.js";
+export function registerWhoami(program) {
+    program
+        .command("whoami")
+        .description("print the acting userId and a freshly minted JWT")
+        .action(() => {
+        const { as } = program.opts();
+        if (!as) {
+            throw new Error("--as <userId> is required");
+        }
+        const token = mintToken(as);
+        process.stdout.write(JSON.stringify({ userId: as, token }) + "\n");
+    });
+}
+//# sourceMappingURL=whoami.js.map

package/dist/generated/_helpers.js

@@ -0,0 +1,8 @@
+export function getOrCreateGroup(program, name, description) {
+    const existing = program.commands.find((c) => c.name() === name);
+    return existing ?? program.command(name).description(description);
+}
+export function hasSubcommand(group, name) {
+    return group.commands.some((c) => c.name() === name);
+}
+//# sourceMappingURL=_helpers.js.map

package/dist/generated/commands/activity.js

@@ -0,0 +1,46 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "activity", "Activity operations");
+    if (!hasSubcommand(group, "daily")) {
+        group
+            .command("daily")
+            .description("GET /api/v1/users/me/activity/daily")
+            .option("--period <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/users/me/activity/daily`;
+            const query = {};
+            {
+                const v = opts.period;
+                if (v !== undefined)
+                    query["period"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "by-room")) {
+        group
+            .command("by-room")
+            .description("GET /api/v1/users/me/activity/by-room")
+            .option("--period <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/users/me/activity/by-room`;
+            const query = {};
+            {
+                const v = opts.period;
+                if (v !== undefined)
+                    query["period"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=activity.js.map

package/dist/generated/commands/ai.js

@@ -0,0 +1,40 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "ai", "AI operations");
+    if (!hasSubcommand(group, "ask")) {
+        group
+            .command("ask")
+            .description("POST /api/v1/rooms/{roomId}/ai/ask")
+            .requiredOption("--room-id <value>", "roomId (path param)")
+            .requiredOption("--query <value>", "string, ≤500 chars")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/rooms/${encodeURIComponent(opts.roomId)}/ai/ask`;
+            const body = {};
+            {
+                const v = opts.query;
+                if (v !== undefined)
+                    body["query"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "marketplace")) {
+        group
+            .command("marketplace")
+            .description("GET /api/v1/ai/agents/marketplace")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/ai/agents/marketplace`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=ai.js.map

package/dist/generated/commands/ambassador.js

@@ -0,0 +1,34 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "ambassador", "Ambassador operations");
+    if (!hasSubcommand(group, "get")) {
+        group
+            .command("get")
+            .description("GET /api/v1/users/me/ambassador")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/users/me/ambassador`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "apply")) {
+        group
+            .command("apply")
+            .description("POST /api/v1/users/me/ambassador")
+            .option("--body <json>", "request body as JSON (no schema available)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/users/me/ambassador`;
+            const body = opts.body ? JSON.parse(opts.body) : undefined;
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=ambassador.js.map

package/dist/generated/commands/apple-iap.js

@@ -0,0 +1,61 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "apple-iap", "AppleIap operations");
+    if (!hasSubcommand(group, "verify")) {
+        group
+            .command("verify")
+            .description("POST /api/v1/subscriptions/apple/verify")
+            .requiredOption("--signed-transaction-jws <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/subscriptions/apple/verify`;
+            const body = {};
+            {
+                const v = opts.signedTransactionJws;
+                if (v !== undefined)
+                    body["signedTransactionJws"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "restore")) {
+        group
+            .command("restore")
+            .description("POST /api/v1/subscriptions/apple/restore")
+            .requiredOption("--signed-transaction-jws <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/subscriptions/apple/restore`;
+            const body = {};
+            {
+                const v = opts.signedTransactionJws;
+                if (v !== undefined)
+                    body["signedTransactionJws"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "webhook")) {
+        group
+            .command("webhook")
+            .description("POST /api/v1/webhooks/apple")
+            .option("--body <json>", "request body as JSON (no schema available)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/webhooks/apple`;
+            const body = opts.body ? JSON.parse(opts.body) : undefined;
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=apple-iap.js.map

package/dist/generated/commands/attribution.js

@@ -0,0 +1,130 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "attribution", "Attribution operations");
+    if (!hasSubcommand(group, "rooms-install")) {
+        group
+            .command("rooms-install")
+            .description("POST /api/v1/attribution/rooms-install")
+            .requiredOption("--invite-code <value>", "string")
+            .requiredOption("--device-id <value>", "string")
+            .requiredOption("--platform <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/attribution/rooms-install`;
+            const body = {};
+            {
+                const v = opts.inviteCode;
+                if (v !== undefined)
+                    body["inviteCode"] = v;
+            }
+            {
+                const v = opts.deviceId;
+                if (v !== undefined)
+                    body["deviceId"] = v;
+            }
+            {
+                const v = opts.platform;
+                if (v !== undefined)
+                    body["platform"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "generic-install")) {
+        group
+            .command("generic-install")
+            .description("POST /api/v1/attribution/install")
+            .requiredOption("--ref <value>", "string")
+            .requiredOption("--challenge-id <value>", "string")
+            .requiredOption("--platform <value>", "string")
+            .requiredOption("--device-id <value>", "string")
+            .requiredOption("--hmac <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/attribution/install`;
+            const body = {};
+            {
+                const v = opts.ref;
+                if (v !== undefined)
+                    body["ref"] = v;
+            }
+            {
+                const v = opts.challengeId;
+                if (v !== undefined)
+                    body["challengeId"] = v;
+            }
+            {
+                const v = opts.platform;
+                if (v !== undefined)
+                    body["platform"] = v;
+            }
+            {
+                const v = opts.deviceId;
+                if (v !== undefined)
+                    body["deviceId"] = v;
+            }
+            {
+                const v = opts.hmac;
+                if (v !== undefined)
+                    body["hmac"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "pending-attribution")) {
+        group
+            .command("pending-attribution")
+            .description("GET /api/v1/attribution/pending")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/attribution/pending`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "ios-pending")) {
+        group
+            .command("ios-pending")
+            .description("GET /api/v1/attribution/ios-pending")
+            .requiredOption("--bundle_id <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/attribution/ios-pending`;
+            const query = {};
+            {
+                const v = opts.bundle_id;
+                if (v !== undefined)
+                    query["bundle_id"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "branch-webhook")) {
+        group
+            .command("branch-webhook")
+            .description("POST /api/v1/attribution/branch-webhook")
+            .option("--body <json>", "request body as JSON (no schema available)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/attribution/branch-webhook`;
+            const body = opts.body ? JSON.parse(opts.body) : undefined;
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=attribution.js.map

package/dist/generated/commands/auth.js

@@ -0,0 +1,205 @@
+// Auto-generated. Do not edit by hand. Regenerate via `npm run generate`.
+import { Option } from "commander";
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "auth", "Auth operations");
+    if (!hasSubcommand(group, "send-otp")) {
+        group
+            .command("send-otp")
+            .description("POST /api/v1/auth/send-otp")
+            .requiredOption("--phone <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/auth/send-otp`;
+            const body = {};
+            {
+                const v = opts.phone;
+                if (v !== undefined)
+                    body["phone"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "verify-otp")) {
+        group
+            .command("verify-otp")
+            .description("POST /api/v1/auth/verify-otp")
+            .requiredOption("--phone <value>", "string")
+            .requiredOption("--code <value>", "string, ≤6 chars, ≥6 chars")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/auth/verify-otp`;
+            const body = {};
+            {
+                const v = opts.phone;
+                if (v !== undefined)
+                    body["phone"] = v;
+            }
+            {
+                const v = opts.code;
+                if (v !== undefined)
+                    body["code"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "refresh")) {
+        group
+            .command("refresh")
+            .description("POST /api/v1/auth/refresh")
+            .requiredOption("--refresh-token <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/auth/refresh`;
+            const body = {};
+            {
+                const v = opts.refreshToken;
+                if (v !== undefined)
+                    body["refreshToken"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "phone-login")) {
+        group
+            .command("phone-login")
+            .description("POST /api/v1/auth/phone/login")
+            .requiredOption("--id-token <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/auth/phone/login`;
+            const body = {};
+            {
+                const v = opts.idToken;
+                if (v !== undefined)
+                    body["idToken"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "convert-guest")) {
+        group
+            .command("convert-guest")
+            .description("POST /api/v1/auth/convert-guest")
+            .requiredOption("--phone <value>", "string")
+            .requiredOption("--code <value>", "string, ≤6 chars, ≥6 chars")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/auth/convert-guest`;
+            const body = {};
+            {
+                const v = opts.phone;
+                if (v !== undefined)
+                    body["phone"] = v;
+            }
+            {
+                const v = opts.code;
+                if (v !== undefined)
+                    body["code"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "guest-join")) {
+        group
+            .command("guest-join")
+            .description("POST /api/v1/auth/guest")
+            .option("--body <json>", "request body as JSON (no schema available)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/auth/guest`;
+            const body = opts.body ? JSON.parse(opts.body) : undefined;
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "social-login")) {
+        group
+            .command("social-login")
+            .description("POST /api/v1/auth/social")
+            .addOption(new Option("--provider <value>", "string, enum").choices(["apple", "google", "facebook", "twitter"]).makeOptionMandatory())
+            .requiredOption("--token <value>", "string")
+            .option("--nonce <value>", "string")
+            .option("--first-name <value>", "string")
+            .option("--last-name <value>", "string")
+            .option("--authorization-code <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/auth/social`;
+            const body = {};
+            {
+                const v = opts.provider;
+                if (v !== undefined)
+                    body["provider"] = v;
+            }
+            {
+                const v = opts.token;
+                if (v !== undefined)
+                    body["token"] = v;
+            }
+            {
+                const v = opts.nonce;
+                if (v !== undefined)
+                    body["nonce"] = v;
+            }
+            {
+                const v = opts.firstName;
+                if (v !== undefined)
+                    body["firstName"] = v;
+            }
+            {
+                const v = opts.lastName;
+                if (v !== undefined)
+                    body["lastName"] = v;
+            }
+            {
+                const v = opts.authorizationCode;
+                if (v !== undefined)
+                    body["authorizationCode"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "dev-otp")) {
+        group
+            .command("dev-otp")
+            .description("GET /api/v1/auth/dev-otp")
+            .requiredOption("--phone <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/auth/dev-otp`;
+            const query = {};
+            {
+                const v = opts.phone;
+                if (v !== undefined)
+                    query["phone"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=auth.js.map