oneclient 0.1.0

package/dist/index.js

@@ -0,0 +1,624 @@
+#!/usr/bin/env node
+import { createHash, createHmac } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
+import process from "node:process";
+import { createInterface } from "node:readline/promises";
+import { Command } from "commander";
+import { createClient } from "@oneclient/sdk";
+import { deploymentWaitTimeout, waitForDeployment } from "./deployment-wait.js";
+import { createArtifact } from "./artifact-create.js";
+import { clearDeveloperCredentials, readDeveloperCredentials, writeDeveloperCredentials, } from "./credentials.js";
+import { revokeDeveloperSession, sendDeveloperOtp, verifyDeveloperOtp } from "./platform-auth.js";
+import { deployTokenFromEnvironment, parseServerKeyScopes, serverKeyFromEnvironment, } from "./credential-routing.js";
+import { secretValueFromOptions } from "./secret-input.js";
+import { brand, formatOutput, statusLine } from "./presenter.js";
+import { slugify } from "./slug.js";
+const program = new Command();
+program
+    .name("oneclient")
+    .description("Deploy and manage OneClient projects")
+    .version("0.1.0")
+    .option("--api-url <url>", "Control or environment API URL", process.env.ONECLIENT_API_URL)
+    .option("--organization <id>", "Organization ID", process.env.ONECLIENT_ORGANIZATION_ID)
+    .option("--json", "Print stable JSON for scripts and agents", false)
+    .option("--no-color", "Disable ANSI color in human-readable output");
+program.addHelpText("beforeAll", () => process.stdout.isTTY ? `${brand(colorEnabled())}\n\n` : "");
+program
+    .command("login")
+    .description("Sign in as a platform developer with an email OTP")
+    .requiredOption("--email <email>")
+    .action(async (options) => {
+    const apiUrl = await resolveApiUrl();
+    await runStep(`Sending a private sign-in code to ${options.email.trim()}`, () => sendDeveloperOtp(apiUrl, options.email));
+    const otp = process.env.ONECLIENT_OTP ?? (await promptForOtp());
+    const sessionToken = await runStep("Verifying your code", () => verifyDeveloperOtp(apiUrl, options.email, otp));
+    await writeDeveloperCredentials({ apiUrl, sessionToken });
+    print(await sessionClient().then((api) => api.account.me()), "Signed in");
+});
+program
+    .command("logout")
+    .description("Revoke the current developer session and remove local credentials")
+    .action(async () => {
+    const credentials = await resolvedDeveloperCredentials();
+    if (!credentials) {
+        print({ signedOut: true, credentialRemoved: false });
+        return;
+    }
+    let credentialRemoved = false;
+    try {
+        await revokeDeveloperSession(credentials.apiUrl, credentials.sessionToken);
+    }
+    finally {
+        credentialRemoved = await clearDeveloperCredentials();
+    }
+    print({ signedOut: true, credentialRemoved });
+});
+program
+    .command("whoami")
+    .description("Show the signed-in platform developer")
+    .action(async () => print(await sessionClient().then((api) => api.account.me()), "Account"));
+program
+    .command("organizations")
+    .description("List organizations available to the signed-in developer")
+    .action(async () => print(await sessionClient().then((api) => api.organizations.list()), "Organizations"));
+program
+    .command("init")
+    .description("Create or select an organization, then provision your first project")
+    .option("--organization <id>", "Use an existing organization")
+    .option("--organization-name <name>", "Create an organization with this name")
+    .option("--project-name <name>", "Project name")
+    .option("--placement <placement>", "eu, us, or apac", "eu")
+    .action(async (options) => {
+    if (!new Set(["eu", "us", "apac"]).has(options.placement))
+        throw new Error("placement must be eu, us, or apac");
+    const api = await sessionClient();
+    const organizations = await api.organizations.list();
+    let organization = options.organization
+        ? organizations.find((item) => item.id === options.organization)
+        : organizations.length === 1
+            ? organizations[0]
+            : undefined;
+    if (!organization && options.organization)
+        throw new Error(`Organization ${options.organization} is not available to this account`);
+    if (!organization) {
+        const name = options.organizationName ?? (await promptForText("Organization name", "My organization"));
+        organization = await runStep("Creating your organization", () => api.organizations.create({ name, slug: slugify(name) }));
+    }
+    const projectName = options.projectName ?? (await promptForText("Project name", "My first project"));
+    const project = await runStep("Provisioning development and production", () => sessionClient(organization.id).then((client) => client.projects.create({
+        organizationId: organization.id,
+        name: projectName,
+        slug: slugify(projectName),
+        placement: options.placement,
+    })));
+    print({
+        organization: { id: organization.id, name: organization.name },
+        project,
+        next: [
+            "Open https://console.one-client.com/projects",
+            "Create an sk_* server key for your development environment",
+            "Run `oneclient docs` for the five-minute quickstart",
+        ],
+    }, "Your OneClient workspace is ready");
+});
+program
+    .command("organization:create")
+    .description("Create an organization")
+    .requiredOption("--name <name>")
+    .option("--slug <slug>", "Defaults to a slug generated from the name")
+    .action(async (options) => print(await sessionClient().then((api) => api.organizations.create({
+    name: options.name,
+    slug: options.slug ?? slugify(options.name),
+})), "Organization created"));
+program
+    .command("projects")
+    .description("List projects")
+    .action(async () => print(await sessionClient().then((api) => api.projects.list()), "Projects"));
+program
+    .command("project:create")
+    .description("Create a project and its development and production environments")
+    .requiredOption("--organization <id>")
+    .requiredOption("--name <name>")
+    .option("--slug <slug>", "Defaults to a slug generated from the name")
+    .option("--placement <placement>", "eu, us, or apac", "eu")
+    .action(async (options) => {
+    print(await sessionClient(options.organization).then((api) => api.projects.create({
+        organizationId: options.organization,
+        name: options.name,
+        slug: options.slug ?? slugify(options.name),
+        placement: options.placement,
+    })), "Project created");
+});
+program
+    .command("project:get")
+    .description("Show a project and all of its environments")
+    .requiredOption("--project <id>")
+    .action(async (options) => print(await sessionClient().then((api) => api.projects.get(options.project))));
+program
+    .command("preview:create")
+    .description("Create an isolated, prepaid preview environment with a TTL")
+    .requiredOption("--project <id>")
+    .requiredOption("--ttl-minutes <minutes>", "60 to 10080 minutes")
+    .action(async (options) => {
+    const ttlMinutes = Number(options.ttlMinutes);
+    if (!Number.isInteger(ttlMinutes) || ttlMinutes < 60 || ttlMinutes > 7 * 24 * 60)
+        throw new Error("ttl-minutes must be an integer from 60 through 10080");
+    print(await sessionClient().then((api) => api.projects.createPreview(options.project, { ttlMinutes })));
+});
+program
+    .command("preview:delete")
+    .description("Delete an isolated preview environment")
+    .requiredOption("--environment <id>")
+    .action(async (options) => print(await sessionClient().then((api) => api.projects.deletePreview(options.environment))));
+program
+    .command("usage")
+    .description("Show the prepaid wallet and retention reserve")
+    .action(async () => print(await sessionClient().then((api) => api.usage.summary()), "Usage & balance"));
+program
+    .command("status")
+    .description("Show account, organization, project, and spend status in one view")
+    .action(async () => {
+    const base = await sessionClient();
+    const [account, organizations] = await Promise.all([
+        base.account.me(),
+        base.organizations.list(),
+    ]);
+    const requestedOrganization = program.opts().organization;
+    const organization = requestedOrganization
+        ? organizations.find((item) => item.id === requestedOrganization)
+        : organizations.length === 1
+            ? organizations[0]
+            : undefined;
+    const [projects, usage] = organization
+        ? await Promise.all([
+            sessionClient(organization.id).then((api) => api.projects.list()),
+            sessionClient(organization.id).then((api) => api.usage.summary()),
+        ])
+        : [[], null];
+    print({
+        developer: account.user.email,
+        organization: organization
+            ? { id: organization.id, name: organization.name, slug: organization.slug }
+            : null,
+        projects: projects.length,
+        availableBalanceMicros: usage?.availableBalanceMicros ?? null,
+        reservedMicros: usage?.reservedMicros ?? null,
+        hardStop: true,
+        next: organization
+            ? "Run `oneclient projects` or `oneclient usage` for details."
+            : "Pass --organization <id> to include projects and spend.",
+    }, "Workspace status");
+});
+program
+    .command("activity")
+    .description("Show recent organization activity")
+    .option("--limit <count>", "Number of entries", "20")
+    .action(async (options) => {
+    const limit = Number(options.limit);
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+        throw new Error("limit must be an integer from 1 through 100");
+    print(await sessionClient().then((api) => api.usage.activity(limit)), "Recent activity");
+});
+program
+    .command("deployments")
+    .description("List immutable deployments for an environment")
+    .requiredOption("--environment <id>")
+    .action(async (options) => print(await deployClient().then((api) => api.deployments.list(options.environment)), "Deployments"));
+program
+    .command("models")
+    .description("List currently available managed AI models")
+    .action(async () => print(await serverClient().then((api) => api.ai.models()), "AI model catalog"));
+program
+    .command("doctor")
+    .description("Check local credentials and live OneClient connectivity")
+    .action(async () => {
+    const credentials = await resolvedDeveloperCredentials();
+    let account = null;
+    let controlReachable = false;
+    if (credentials) {
+        const response = await sessionClient().then((api) => api.account.me());
+        account = response.user.email;
+        controlReachable = true;
+    }
+    print({
+        node: process.version,
+        controlApi: credentials?.apiUrl ?? null,
+        signedIn: Boolean(credentials),
+        account,
+        controlReachable,
+        deployToken: deployTokenFromEnvironment()?.startsWith("dp_") ?? false,
+        serverKey: serverKeyFromEnvironment()?.startsWith("sk_") ?? false,
+    }, "Doctor");
+});
+program
+    .command("docs")
+    .description("Show the human, API, and AI documentation entry points")
+    .action(() => print({
+    quickstart: "https://one-client.com/docs/quickstart",
+    guides: "https://one-client.com/docs",
+    apiReference: "https://console.one-client.com/api-reference",
+    aiGuide: "https://one-client.com/docs/ai",
+    llms: "https://one-client.com/llms.txt",
+    mcp: "https://control.one-client.com/mcp",
+}, "Documentation"));
+program
+    .command("mcp")
+    .description("Show the remote MCP endpoint and safe credential setup")
+    .action(() => print({
+    endpoint: "https://control.one-client.com/mcp",
+    transport: "Streamable HTTP",
+    authorization: "Bearer sk_* or dp_*",
+    guidance: "Use an environment-scoped key and store it in your AI client's secret store.",
+    skill: "npm install @oneclient/skill",
+}, "AI connection"));
+program
+    .command("billing:portal")
+    .description("Create a secure Stripe billing-portal session")
+    .action(async () => print(await sessionClient().then((api) => api.billing.portal()), "Billing portal"));
+program
+    .command("billing:subscribe")
+    .description("Create a subscription Checkout session")
+    .action(async () => print(await sessionClient().then((api) => api.billing.subscriptionCheckout()), "Subscription checkout"));
+program
+    .command("billing:topup")
+    .description("Create a prepaid credit Checkout session")
+    .requiredOption("--usd <amount>", "USD amount; minimum $25")
+    .action(async (options) => {
+    const dollars = Number(options.usd);
+    if (!Number.isFinite(dollars) || dollars < 25 || Math.round(dollars * 100) !== dollars * 100)
+        throw new Error("usd must be at least 25 with no more than two decimal places");
+    const amountMicros = String(Math.round(dollars * 1_000_000));
+    print(await sessionClient().then((api) => api.billing.topupCheckout(amountMicros)), "Credit checkout");
+});
+program
+    .command("domain:list")
+    .description("List application, API, and sending domains")
+    .action(async () => print(await sessionClient().then((api) => api.domains.list()), "Domains"));
+program
+    .command("domain:add")
+    .description("Attach a custom hostname")
+    .requiredOption("--environment <id>")
+    .requiredOption("--hostname <hostname>")
+    .option("--purpose <purpose>", "app, api, or sending", "app")
+    .action(async (options) => {
+    print(await sessionClient().then((api) => api.domains.add({
+        environmentId: options.environment,
+        hostname: options.hostname,
+        purpose: options.purpose,
+    })));
+});
+program
+    .command("deploy-token:create")
+    .description("Create an environment-scoped dp_* token (shown once)")
+    .requiredOption("--environment <id>")
+    .requiredOption("--name <name>")
+    .option("--expires-at <timestamp>", "ISO-8601 expiration time")
+    .action(async (options) => {
+    const result = await sessionClient().then((api) => api.deployTokens.create({
+        environmentId: options.environment,
+        name: options.name,
+        ...(options.expiresAt ? { expiresAt: options.expiresAt } : {}),
+    }));
+    process.stderr.write("Store this deploy token now; OneClient will not show it again.\n");
+    print(result);
+});
+program
+    .command("keys")
+    .description("List publishable and server keys for an environment")
+    .requiredOption("--environment <id>")
+    .action(async (options) => print(await sessionClient().then((api) => api.credentials.list(options.environment))));
+program
+    .command("key:create")
+    .description("Create an environment publishable or scoped server key")
+    .requiredOption("--environment <id>")
+    .requiredOption("--prefix <prefix>", "pk or sk")
+    .requiredOption("--name <name>")
+    .option("--scopes <scopes>", "Comma-separated scopes required for sk keys")
+    .option("--expires-at <timestamp>", "ISO-8601 expiration time")
+    .action(async (options) => {
+    const prefix = options.prefix;
+    if (prefix !== "pk" && prefix !== "sk")
+        throw new Error("prefix must be pk or sk");
+    const scopes = parseServerKeyScopes(prefix, options.scopes);
+    const result = await sessionClient().then((api) => api.credentials.create(options.environment, {
+        prefix,
+        name: options.name,
+        ...(scopes ? { scopes } : {}),
+        ...(options.expiresAt ? { expiresAt: options.expiresAt } : {}),
+    }));
+    if (result.token)
+        process.stderr.write("Store this key now; OneClient will not show it again.\n");
+    print(result);
+});
+program
+    .command("key:revoke")
+    .description("Revoke an environment key")
+    .requiredOption("--environment <id>")
+    .requiredOption("--key <id>")
+    .action(async (options) => print(await sessionClient().then((api) => api.credentials.revoke(options.environment, options.key))));
+program
+    .command("secrets")
+    .description("List secret names and versions for an environment")
+    .requiredOption("--environment <id>")
+    .action(async (options) => print(await sessionClient().then((api) => api.secrets.list(options.environment))));
+program
+    .command("secret:put")
+    .description("Create a versioned deployment secret without exposing its value in arguments")
+    .requiredOption("--environment <id>")
+    .requiredOption("--name <name>")
+    .option("--from-env <variable>", "Read the value from a named environment variable")
+    .option("--stdin", "Read exact secret bytes from piped standard input")
+    .action(async (options) => {
+    const value = await secretValueFromOptions(options);
+    print(await sessionClient().then((api) => api.secrets.put(options.environment, options.name, value)));
+});
+program
+    .command("secret:delete")
+    .description("Retire a deployment secret on the next version")
+    .requiredOption("--environment <id>")
+    .requiredOption("--name <name>")
+    .action(async (options) => print(await sessionClient().then((api) => api.secrets.delete(options.environment, options.name))));
+program
+    .command("query")
+    .description("Run a policy-controlled data query")
+    .requiredOption("--table <table>")
+    .requiredOption("--select <fields>", "Comma-separated field names")
+    .option("--limit <limit>", "Maximum rows", "100")
+    .action(async (options) => {
+    print(await serverClient().then((api) => api
+        .from(options.table)
+        .select(...options.select.split(",").map((field) => field.trim()))
+        .limit(Number(options.limit))
+        .execute()));
+});
+program
+    .command("artifact:create")
+    .description("Create a validated manifest and tar archive from a project directory")
+    .requiredOption("--directory <path>")
+    .requiredOption("--manifest <path>")
+    .requiredOption("--archive <path>")
+    .requiredOption("--framework <framework>", "static, vite, next-opennext, or worker")
+    .option("--root-directory <path>")
+    .option("--entrypoint <path>")
+    .option("--build-command <command>")
+    .option("--output-directory <path>")
+    .option("--lockfile <manager>", "pnpm, npm, yarn, or bun")
+    .action(async (options) => {
+    if (!["static", "vite", "next-opennext", "worker"].includes(options.framework))
+        throw new Error("framework must be static, vite, next-opennext, or worker");
+    if (options.lockfile && !["pnpm", "npm", "yarn", "bun"].includes(options.lockfile))
+        throw new Error("lockfile must be pnpm, npm, yarn, or bun");
+    const manifest = await createArtifact({
+        directory: options.directory,
+        archivePath: options.archive,
+        manifestPath: options.manifest,
+        framework: options.framework,
+        ...(options.rootDirectory ? { rootDirectory: options.rootDirectory } : {}),
+        ...(options.entrypoint ? { entrypoint: options.entrypoint } : {}),
+        ...(options.buildCommand ? { buildCommand: options.buildCommand } : {}),
+        ...(options.outputDirectory ? { outputDirectory: options.outputDirectory } : {}),
+        ...(options.lockfile
+            ? { lockfile: options.lockfile }
+            : {}),
+    });
+    print({
+        archive: options.archive,
+        manifest: options.manifest,
+        files: manifest.files.length,
+        totalBytes: manifest.totalBytes,
+    });
+});
+program
+    .command("deploy")
+    .description("Upload a signed artifact and create an immutable deployment")
+    .requiredOption("--manifest <path>")
+    .requiredOption("--archive <path>", "Tar archive whose files exactly match the manifest")
+    .requiredOption("--project <id>")
+    .requiredOption("--environment <id>")
+    .option("--production", "Promote after upload", false)
+    .option("--wait", "Wait until the deployment is ready without promoting", false)
+    .option("--wait-timeout <seconds>", "Maximum build wait", "600")
+    .action(async (options) => {
+    const deployToken = deployTokenFromEnvironment();
+    if (!deployToken?.startsWith("dp_"))
+        throw new Error("Deploy requires ONECLIENT_DEPLOY_TOKEN with a dp_* token");
+    const parsed = JSON.parse(await readFile(options.manifest, "utf8"));
+    const { signature: _, ...unsigned } = parsed;
+    const manifest = {
+        ...unsigned,
+        signature: createHmac("sha256", deployToken)
+            .update(stableStringify(unsigned))
+            .digest("hex"),
+    };
+    const artifactDigest = await hashFile(options.archive);
+    const api = await deployClient();
+    const deployment = await api.request("/v1/deployments", {
+        method: "POST",
+        body: {
+            projectId: options.project,
+            environmentId: options.environment,
+            artifactDigest,
+            manifest,
+        },
+        idempotent: true,
+    });
+    const archive = await readFile(options.archive);
+    const result = await api.deployments.upload(deployment.deploymentId, archive, {
+        artifactDigest,
+        contentLength: (await stat(options.archive)).size,
+    });
+    if (options.production || options.wait) {
+        const ready = await waitForDeployment(deployment.deploymentId, {
+            getStatus: () => api.deployments.get(deployment.deploymentId),
+            timeoutMs: deploymentWaitTimeout(options.waitTimeout),
+        });
+        if (options.production) {
+            const promotion = ready.status === "promoted"
+                ? ready
+                : await api.deployments.promote(deployment.deploymentId);
+            print({
+                ...result,
+                deployment: ready,
+                promotion,
+            });
+        }
+        else {
+            print({
+                ...result,
+                deployment: ready,
+            });
+        }
+    }
+    else
+        print(result);
+});
+program
+    .command("deployment:promote")
+    .description("Atomically promote or roll back to an immutable deployment")
+    .requiredOption("--deployment <id>")
+    .action(async (options) => {
+    print(await deployClient().then((api) => api.request(`/v1/deployments/${encodeURIComponent(options.deployment)}/promote`, {
+        method: "POST",
+        idempotent: true,
+    })));
+});
+program
+    .command("deployment:logs")
+    .description("Print redacted build logs for a deployment")
+    .requiredOption("--deployment <id>")
+    .action(async (options) => {
+    const logs = await deployClient().then((api) => api.deployments.logs(options.deployment));
+    process.stdout.write(logs.endsWith("\n") ? logs : `${logs}\n`);
+});
+program.parseAsync().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${statusLine("error", message, colorEnabled())}\n`);
+    process.exitCode = 1;
+});
+async function sessionClient(organizationId) {
+    const options = program.opts();
+    const credentials = await resolvedDeveloperCredentials();
+    if (!credentials) {
+        throw new Error("Sign in with `oneclient login --email you@example.com`");
+    }
+    return createClient({
+        baseUrl: options.apiUrl ?? credentials.apiUrl,
+        session: true,
+        headers: { Authorization: `Bearer ${credentials.sessionToken}` },
+        ...((organizationId ?? options.organization)
+            ? { organizationId: organizationId ?? options.organization }
+            : {}),
+    });
+}
+async function deployClient() {
+    const options = program.opts();
+    const deployToken = deployTokenFromEnvironment();
+    if (!deployToken?.startsWith("dp_"))
+        throw new Error("This command requires ONECLIENT_DEPLOY_TOKEN with a dp_* token");
+    return createClient({
+        baseUrl: await resolveApiUrl(),
+        deployToken,
+        ...(options.organization ? { organizationId: options.organization } : {}),
+    });
+}
+async function serverClient() {
+    const options = program.opts();
+    const serverKey = serverKeyFromEnvironment();
+    if (!serverKey?.startsWith("sk_"))
+        throw new Error("This command requires ONECLIENT_SERVER_KEY with an sk_* key");
+    return createClient({
+        baseUrl: await resolveApiUrl(),
+        serverKey,
+        ...(options.organization ? { organizationId: options.organization } : {}),
+    });
+}
+async function resolvedDeveloperCredentials() {
+    const options = program.opts();
+    const stored = await readDeveloperCredentials();
+    const sessionToken = process.env.ONECLIENT_SESSION_TOKEN ?? stored?.sessionToken;
+    if (!sessionToken)
+        return null;
+    const apiUrl = options.apiUrl ?? stored?.apiUrl;
+    if (!apiUrl)
+        throw new Error("Set ONECLIENT_API_URL or pass --api-url");
+    return { apiUrl, sessionToken };
+}
+async function resolveApiUrl() {
+    const options = program.opts();
+    const apiUrl = options.apiUrl ?? (await readDeveloperCredentials())?.apiUrl;
+    if (!apiUrl)
+        throw new Error("Set ONECLIENT_API_URL or pass --api-url");
+    return apiUrl;
+}
+async function promptForOtp() {
+    if (!process.stdin.isTTY)
+        throw new Error("Set ONECLIENT_OTP for a non-interactive login");
+    const prompt = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        return await prompt.question("Email OTP: ");
+    }
+    finally {
+        prompt.close();
+    }
+}
+async function promptForText(question, fallback) {
+    if (!process.stdin.isTTY)
+        throw new Error(`Pass --${slugify(question)} in non-interactive mode`);
+    const prompt = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        const answer = (await prompt.question(`${question} (${fallback}): `)).trim();
+        return answer || fallback;
+    }
+    finally {
+        prompt.close();
+    }
+}
+async function runStep(message, action) {
+    const human = humanOutput();
+    if (human)
+        process.stderr.write(`${statusLine("working", message, colorEnabled())}\n`);
+    try {
+        const result = await action();
+        if (human)
+            process.stderr.write(`${statusLine("done", message, colorEnabled())}\n`);
+        return result;
+    }
+    catch (error) {
+        if (human)
+            process.stderr.write(`${statusLine("error", message, colorEnabled())}\n`);
+        throw error;
+    }
+}
+function humanOutput() {
+    return Boolean(process.stdout.isTTY && !program.opts().json);
+}
+function colorEnabled() {
+    return Boolean(process.stdout.isTTY &&
+        process.env.NO_COLOR === undefined &&
+        program.opts().color !== false);
+}
+function print(value, title) {
+    process.stdout.write(formatOutput(value, {
+        color: colorEnabled(),
+        json: !humanOutput(),
+        ...(title ? { title } : {}),
+    }));
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(",")}]`;
+    const object = value;
+    return `{${Object.keys(object)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${stableStringify(object[key])}`)
+        .join(",")}}`;
+}
+async function hashFile(path) {
+    const hash = createHash("sha256");
+    for await (const chunk of createReadStream(path))
+        hash.update(chunk);
+    return hash.digest("hex");
+}

package/dist/platform-auth.d.ts

@@ -0,0 +1,4 @@
+export declare function sendDeveloperOtp(apiUrl: string, email: string, fetcher?: typeof globalThis.fetch): Promise<void>;
+export declare function verifyDeveloperOtp(apiUrl: string, email: string, otp: string, fetcher?: typeof globalThis.fetch): Promise<string>;
+export declare function revokeDeveloperSession(apiUrl: string, sessionToken: string, fetcher?: typeof globalThis.fetch): Promise<void>;
+//# sourceMappingURL=platform-auth.d.ts.map

package/dist/platform-auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-auth.d.ts","sourceRoot":"","sources":["../src/platform-auth.ts"],"names":[],"mappings":"AAOA,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,OAAO,UAAU,CAAC,KAAwB,GAClD,OAAO,CAAC,IAAI,CAAC,CAKf;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,OAAO,UAAU,CAAC,KAAwB,GAClD,OAAO,CAAC,MAAM,CAAC,CAQjB;AAED,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,OAAO,UAAU,CAAC,KAAwB,GAClD,OAAO,CAAC,IAAI,CAAC,CAEf"}