shopstack 0.2.0 → 0.2.1

package/README.md

@@ -12,22 +12,25 @@ npm install -g shopstack
 
 Node.js 18 or newer is required.
 
-Version 0.2.0 defaults to Shopstack's currently deployed public staging API at
+The 0.2.1 source candidate defaults to Shopstack's currently deployed public staging API at
 `https://shopstack-staging.shopstack.workers.dev/v1`. Set
 `SHOPSTACK_API_URL` only when targeting a different Shopstack environment.
 
-## Personal account
+## Verified signup
 
 ```bash
-shopstack signup user --email you@example.com
+shopstack signup
 ```
 
-This starts a 15-minute signup and waits while you open the verification email.
-No account or API key exists until the link is consumed. The CLI then retrieves
-the first key with its private polling capability and stores it in
+The command asks for email and Personal or Developer account type. It starts a
+15-minute signup and waits while you open the verification email. No account or
+API key exists until the link is consumed. The CLI generates and privately
+persists all retry and polling capabilities before the first request, then
+retrieves the first key after verification and stores it in
 `~/.config/shopstack/config.json` with file mode `0600`; it never prints the
-key or polling capability. It checkpoints the pending signup before polling. If
-the command is interrupted, resume it with:
+key, recovery capability, or polling capability. If the command is interrupted,
+rerun `shopstack signup`; the matching pending attempt resumes automatically.
+The explicit helper also remains available:
 
 ```bash
 shopstack signup resume sup_...
@@ -36,7 +39,7 @@ shopstack signup resume sup_...
 ## Developer account and users
 
 ```bash
-shopstack signup developer --email developer@example.com
+shopstack signup
 shopstack users create --external-id customer-123 --profile customer-123
 ```
 
@@ -65,7 +68,7 @@ phase. It deliberately has no card-input or payment-approval tool.
 
 The canonical agent skill ships as `SKILL.md` in this package. After
 publication it is available at
-`https://unpkg.com/shopstack@0.2.0/SKILL.md` with the release-pinned package.
+`https://unpkg.com/shopstack@0.2.1/SKILL.md` with the release-pinned package.
 
 ## Connections
 
@@ -125,6 +128,14 @@ Card values are never accepted as command-line flags.
 ```js
 import { ShopstackClient } from "shopstack";
 
+const onboarding = new ShopstackClient();
+const account = await onboarding.signup({
+  accountType: "developer",
+  email: "developer@example.com",
+  onProgress: ({ state }) => console.log(state),
+  persistence: secureSignupPersistence,
+});
+
 const shopstack = new ShopstackClient({
   apiKey: process.env.SHOPSTACK_API_KEY,
 });
@@ -136,6 +147,11 @@ const result = await shopstack.runCheckout(checkoutRequest, {
 });
 ```
 
+`signup` generates retry state internally and returns the completed account
+identity only after the one-time credential is stored. It never returns the API
+key, recovery key, or polling token. Pass a secure persistence adapter for
+restart recovery and durable credential storage; never use browser storage.
+
 `runCheckout` returns at a required input if its corresponding callback is
 omitted. Final payment approval is never inferred from a message or from
 supplying a card.

package/SKILL.md

@@ -41,14 +41,16 @@ Never ask the model to print or relay a Shopstack API key. The CLI and MCP serve
 Start verified CLI signup:
 
 ```bash
-shopstack signup user --email user@example.com
-shopstack signup developer --email developer@example.com
+shopstack signup
 ```
 
-The user must open the time-limited verification link. No account or API key exists before verification. The CLI polls the signup, saves the verified key with mode `0600`, and does not print it.
-It checkpoints the pending polling capability before waiting. If the process is
-interrupted, use `shopstack signup resume SIGNUP_ID`; the capability remains
-private in the same local profile store.
+The command prompts for email and Personal or Developer account type. The user
+must open the time-limited verification link. No account or API key exists
+before verification. The CLI generates and privately stores its retry and
+polling capabilities before the request, polls signup, saves the verified key
+with mode `0600`, and prints none of those credentials. Rerunning
+`shopstack signup` automatically resumes the matching pending attempt after an
+interruption; `shopstack signup resume SIGNUP_ID` remains an explicit helper.
 
 After developer signup, create an end user:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shopstack",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Shopstack API client and command-line checkout tools.",
   "type": "module",
   "exports": {
@@ -29,6 +29,10 @@
   "engines": {
     "node": ">=18"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jimbo132/shopstack-cli.git"
+  },
   "license": "MIT",
   "keywords": [
     "shopstack",

package/src/cli.js

@@ -7,6 +7,7 @@ import { ConfigStore } from "./config.js";
 const HELP = `Shopstack
 
 Account setup:
+  shopstack signup
   shopstack signup user --email EMAIL
   shopstack signup developer --email EMAIL
   shopstack signup resume SIGNUP_ID
@@ -54,6 +55,11 @@ function required(options, name) {
   return value;
 }
 
+function isAffirmative(value) {
+  const answer = String(value).trim().toLowerCase();
+  return answer === "y" || answer === "yes";
+}
+
 function writeJson(stream, value) {
   stream.write(`${JSON.stringify(value, null, 2)}\n`);
 }
@@ -145,6 +151,69 @@ async function saveVerifiedSignup(result, profileName, configStore) {
   );
 }
 
+function signupPersistence(configStore, profileName) {
+  return {
+    async loadPending(input) {
+      return typeof configStore.findPendingSignup === "function"
+        ? configStore.findPendingSignup(input)
+        : undefined;
+    },
+    async savePending(state) {
+      await configStore.savePendingSignup({ ...state, profile: profileName });
+    },
+    async completePending(state, result) {
+      const pendingId = state.attemptId ?? state.signupId ?? state.id;
+      if (typeof configStore.completePendingSignup === "function") {
+        await configStore.completePendingSignup(
+          pendingId,
+          profileName,
+          result,
+        );
+        return;
+      }
+      await saveVerifiedSignup(result, profileName, configStore);
+      await configStore.deletePendingSignup(pendingId);
+    },
+    async deletePending(state) {
+      await configStore.deletePendingSignup(
+        state.attemptId ?? state.signupId ?? state.id,
+      );
+    },
+  };
+}
+
+async function reportSignupProgress(progress, stream) {
+  switch (progress.state) {
+    case "email_sent":
+      stream.write("Verification email sent.\n");
+      return;
+    case "waiting":
+      stream.write("Waiting for verification...\n");
+      return;
+    case "verified":
+      stream.write("✓ Email verified\n");
+      return;
+    case "complete":
+      stream.write("✓ Shopstack account created\n");
+      stream.write("✓ Credentials saved securely\n");
+      return;
+    case "expired":
+      stream.write("Signup expired. Start again to receive a new email.\n");
+      return;
+    case "rate_limited":
+      stream.write("Signup is rate-limited. Retry after the indicated delay.\n");
+      return;
+    case "conflict":
+      stream.write("Signup retry state conflicted and was cleared.\n");
+      return;
+    case "retryable_failure":
+      stream.write("Signup paused after a retryable failure. Run signup again to resume.\n");
+      return;
+    default:
+      return;
+  }
+}
+
 async function activeClient(dependencies, requiredKind = "user") {
   const profile = await dependencies.configStore.activeProfile();
   const environmentKey = process.env.SHOPSTACK_API_KEY;
@@ -195,60 +264,121 @@ export async function runCli(args, supplied = {}) {
       const client = dependencies.clientFactory({
         baseUrl: process.env.SHOPSTACK_API_URL,
       });
-      const result = await client.waitForAccountSignup(
-        pending.id,
-        pending.pollToken,
-      );
-      await saveVerifiedSignup(result, pending.profile, dependencies.configStore);
-      await dependencies.configStore.deletePendingSignup(pending.id);
+      const result = await client.signup({
+        accountType: pending.accountType,
+        email: pending.email,
+        onProgress: (progress) =>
+          reportSignupProgress(progress, dependencies.stderr),
+        persistence: signupPersistence(
+          dependencies.configStore,
+          pending.profile,
+        ),
+      });
       writeJson(dependencies.stdout, {
         ...sanitizedAccountResult(result),
         profile: pending.profile,
       });
       return;
     }
-    if (action !== "user" && action !== "developer") {
+    if (action !== undefined && action !== "user" && action !== "developer") {
       throw new Error(
         "Use `shopstack signup user` or `shopstack signup developer`.",
       );
     }
-    const { options, positional } = parseOptions(
-      rest,
-      new Set(["email", "profile"]),
-    );
+    const signupArgs = action === undefined ? [] : rest;
+    const { options, positional } = parseOptions(signupArgs, new Set(["email", "profile"]));
     if (positional.length > 0) throw new Error("Unexpected signup argument.");
-    const email = required(options, "email");
+    const pendingCandidates =
+      action === undefined &&
+      typeof dependencies.configStore.pendingSignups === "function"
+        ? await dependencies.configStore.pendingSignups()
+        : [];
+    const resumable = pendingCandidates.length === 1 ? pendingCandidates[0] : undefined;
+    let accountType;
+    let email;
+    if (resumable !== undefined) {
+      accountType = resumable.accountType;
+      email = resumable.email;
+      dependencies.stderr.write("Resuming pending signup.\n");
+    } else if (action === undefined) {
+      email = String(
+        await visiblePrompt("Email: ", dependencies),
+      ).trim();
+      if (email.length === 0) throw new Error("Email is required.");
+      const selected = String(
+        await visiblePrompt("Account type (Personal / Developer): ", dependencies),
+      )
+        .trim()
+        .toLowerCase();
+      if (selected === "personal" || selected === "user") {
+        accountType = "personal";
+      } else if (selected === "developer") {
+        accountType = "developer";
+      } else {
+        throw new Error("Account type must be Personal or Developer.");
+      }
+    } else {
+      accountType = action === "user" ? "personal" : "developer";
+      email = required(options, "email");
+    }
     const client = dependencies.clientFactory({
       baseUrl: process.env.SHOPSTACK_API_URL,
     });
-    const accountType = action === "user" ? "personal" : "developer";
     const profileName =
-      options.profile ?? (action === "developer" ? "developer" : "default");
-    const signup = await client.startAccountSignup({
+      options.profile ??
+      resumable?.profile ??
+      (accountType === "developer" ? "developer" : "default");
+    const result = await client.signup({
       accountType,
       email,
+      onProgress: (progress) =>
+        reportSignupProgress(progress, dependencies.stderr),
+      persistence: signupPersistence(dependencies.configStore, profileName),
     });
-    await dependencies.configStore.savePendingSignup({
-      accountType: signup.account_type,
-      email: signup.email,
-      expiresAt: signup.expires_at,
-      id: signup.id,
-      pollToken: signup.poll_token,
-      profile: profileName,
-    });
-    dependencies.stderr.write(
-      `Verification email sent to ${signup.email}. Open the link before ${signup.expires_at}. If interrupted, resume signup ${signup.id}.\n`,
-    );
-    const result = await client.waitForAccountSignup(
-      signup.id,
-      signup.poll_token,
-    );
-    await saveVerifiedSignup(result, profileName, dependencies.configStore);
-    await dependencies.configStore.deletePendingSignup(signup.id);
     writeJson(dependencies.stdout, {
       ...sanitizedAccountResult(result),
       profile: profileName,
     });
+    if (accountType === "developer") {
+      dependencies.stderr.write(
+        "The developer management credential cannot run user checkouts. Create a user profile with `shopstack users create --external-id ID`.\n",
+      );
+      if (
+        action === undefined &&
+        isAffirmative(
+          await visiblePrompt(
+            "Create the first developer-owned user now? (y/N): ",
+            dependencies,
+          ),
+        )
+      ) {
+        const externalId = String(
+          await visiblePrompt("User external ID: ", dependencies),
+        ).trim();
+        if (externalId.length === 0) {
+          throw new Error("User external ID is required.");
+        }
+        const { client: developerClient, profile } = await activeClient(
+          dependencies,
+          "developer",
+        );
+        const user = await developerClient.createUser({ externalId });
+        await dependencies.configStore.saveProfile(
+          externalId,
+          {
+            accountId: profile.accountId,
+            apiKey: user.api_key,
+            keyType: "user",
+            userId: user.id,
+          },
+          { activate: true },
+        );
+        writeJson(
+          dependencies.stdout,
+          sanitizedUserResult(user, externalId),
+        );
+      }
+    }
     return;
   }
 

package/src/client.d.ts

@@ -89,14 +89,58 @@ export interface VerifiedAccountSignup {
 export interface SignupOptions {
   accountType: "personal" | "developer";
   email: string;
-  idempotencyKey?: string;
   pollIntervalMs?: number;
   timeoutMs?: number;
+  persistence?: SignupPersistence;
+  onProgress?(progress: SignupProgress): void | Promise<void>;
   onVerificationRequired?(signup: Omit<AccountSignupStarted, "poll_token">):
     | void
     | Promise<void>;
 }
 
+export interface PendingSignupState {
+  accountType: "personal" | "developer";
+  attemptId: string;
+  email: string;
+  expiresAt?: string;
+  idempotencyKey: string;
+  pollToken?: string;
+  recoveryKey: string;
+  signupId?: string;
+}
+
+export interface SignupPersistence {
+  loadPending(input: {
+    accountType: "personal" | "developer";
+    email: string;
+  }): Promise<PendingSignupState | undefined>;
+  savePending(state: PendingSignupState): Promise<void>;
+  completePending(
+    state: PendingSignupState,
+    result: VerifiedAccountSignup,
+  ): Promise<void>;
+  deletePending(state: PendingSignupState): Promise<void>;
+}
+
+export interface SignupProgress {
+  state:
+    | "pending"
+    | "email_sent"
+    | "waiting"
+    | "verified"
+    | "expired"
+    | "rate_limited"
+    | "conflict"
+    | "retryable_failure"
+    | "complete";
+  account_type?: "personal" | "developer";
+  email?: string;
+  expires_at?: string;
+  key_type?: "user" | "developer";
+}
+
+export type CompletedAccountSignup = Omit<VerifiedAccountSignup, "api_key">;
+
 export class ShopstackApiError extends Error {
   code: string;
   requestId?: string;
@@ -108,7 +152,6 @@ export class ShopstackClient {
   startAccountSignup(input: {
     accountType: "personal" | "developer";
     email: string;
-    idempotencyKey?: string;
   }): Promise<AccountSignupStarted>;
   pollAccountSignup(
     signupId: string,
@@ -121,7 +164,7 @@ export class ShopstackClient {
     pollToken: string,
     options?: { pollIntervalMs?: number; timeoutMs?: number },
   ): Promise<VerifiedAccountSignup>;
-  signup(input: SignupOptions): Promise<VerifiedAccountSignup>;
+  signup(input: SignupOptions): Promise<CompletedAccountSignup>;
   createUser(input: {
     externalId: string;
     idempotencyKey?: string;

package/src/client.js

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto";
+import { randomBytes, randomUUID } from "node:crypto";
 
 const TERMINAL_STATUSES = new Set(["complete", "failed", "cancelled"]);
 
@@ -16,6 +16,14 @@ function idempotencyKey(prefix) {
   return `${prefix}-${randomUUID()}`;
 }
 
+function signupRecoveryKey() {
+  return `signup_recovery_${randomBytes(32).toString("base64url")}`;
+}
+
+function signupAttemptKey(accountType, email) {
+  return `${accountType}\u0000${email.trim().toLowerCase()}`;
+}
+
 function delay(milliseconds) {
   return milliseconds <= 0
     ? Promise.resolve()
@@ -46,6 +54,7 @@ export class ShopstackClient {
       body,
       idempotencyKey: mutationKey,
       method = "GET",
+      signupRecoveryKey: recoveryKey,
     } = {},
   ) {
     const headers = new Headers({ Accept: "application/json" });
@@ -55,6 +64,7 @@ export class ShopstackClient {
     }
     if (body !== undefined) headers.set("Content-Type", "application/json");
     if (mutationKey) headers.set("Idempotency-Key", mutationKey);
+    if (recoveryKey) headers.set("Signup-Recovery-Key", recoveryKey);
     const response = await this.fetch(`${this.baseUrl}${path}`, {
       body: body === undefined ? undefined : JSON.stringify(body),
       headers,
@@ -88,11 +98,21 @@ export class ShopstackClient {
     return payload;
   }
 
-  startAccountSignup({ accountType, email, idempotencyKey: key } = {}) {
+  _startAccountSignup({ accountType, email, idempotencyKey: key, recoveryKey }) {
     return this.request("/accounts", {
       body: { account_type: accountType, email },
-      idempotencyKey: key ?? idempotencyKey("account"),
+      idempotencyKey: key,
       method: "POST",
+      signupRecoveryKey: recoveryKey,
+    });
+  }
+
+  startAccountSignup({ accountType, email } = {}) {
+    return this._startAccountSignup({
+      accountType,
+      email,
+      idempotencyKey: idempotencyKey("account"),
+      recoveryKey: signupRecoveryKey(),
     });
   }
 
@@ -123,29 +143,137 @@ export class ShopstackClient {
   async signup({
     accountType,
     email,
-    idempotencyKey: key,
+    onProgress,
     onVerificationRequired,
+    persistence,
     pollIntervalMs = 2_000,
     timeoutMs = 15 * 60 * 1_000,
   } = {}) {
-    const signup = await this.startAccountSignup({
+    const normalizedEmail = email.trim().toLowerCase();
+    const memoryKey = signupAttemptKey(accountType, normalizedEmail);
+    this._pendingSignups ??= new Map();
+    const storage = persistence ?? {
+      completePending: async (state, result) => {
+        this.apiKey = result.api_key;
+        this._pendingSignups.delete(memoryKey);
+      },
+      deletePending: async () => this._pendingSignups.delete(memoryKey),
+      loadPending: async () => this._pendingSignups.get(memoryKey),
+      savePending: async (state) => {
+        this._pendingSignups.set(memoryKey, structuredClone(state));
+      },
+    };
+    const publish = async (state, details = {}) => {
+      if (typeof onProgress === "function") await onProgress({ state, ...details });
+    };
+    let pending = await storage.loadPending({
       accountType,
-      email,
-      idempotencyKey: key,
+      email: normalizedEmail,
     });
-    if (typeof onVerificationRequired === "function") {
-      await onVerificationRequired({
-        account_type: signup.account_type,
-        email: signup.email,
-        expires_at: signup.expires_at,
-        id: signup.id,
-        status: signup.status,
+    if (
+      pending?.expiresAt &&
+      Date.parse(pending.expiresAt) <= Date.now()
+    ) {
+      await storage.deletePending(pending);
+      await publish("expired", {
+        account_type: accountType,
+        email: normalizedEmail,
       });
+      pending = undefined;
     }
-    return this.waitForAccountSignup(signup.id, signup.poll_token, {
-      pollIntervalMs,
-      timeoutMs,
+    pending ??= {
+      accountType,
+      attemptId: `attempt-${randomUUID()}`,
+      email: normalizedEmail,
+      idempotencyKey: idempotencyKey("account"),
+      recoveryKey: signupRecoveryKey(),
+    };
+    await storage.savePending(pending);
+    await publish("pending", {
+      account_type: accountType,
+      email: normalizedEmail,
     });
+    try {
+      if (!pending.signupId || !pending.pollToken) {
+        const started = await this._startAccountSignup({
+          accountType,
+          email: normalizedEmail,
+          idempotencyKey: pending.idempotencyKey,
+          recoveryKey: pending.recoveryKey,
+        });
+        pending = {
+          ...pending,
+          expiresAt: started.expires_at,
+          pollToken: started.poll_token,
+          signupId: started.id,
+        };
+        await storage.savePending(pending);
+        if (typeof onVerificationRequired === "function") {
+          await onVerificationRequired({
+            account_type: started.account_type,
+            email: started.email,
+            expires_at: started.expires_at,
+            id: started.id,
+            status: started.status,
+          });
+        }
+        await publish("email_sent", {
+          account_type: accountType,
+          email: normalizedEmail,
+          expires_at: started.expires_at,
+        });
+      }
+      await publish("waiting", {
+        account_type: accountType,
+        email: normalizedEmail,
+        expires_at: pending.expiresAt,
+      });
+      const result = await this.waitForAccountSignup(
+        pending.signupId,
+        pending.pollToken,
+        { pollIntervalMs, timeoutMs },
+      );
+      await storage.completePending(pending, result);
+      await publish("verified", {
+        account_type: accountType,
+        email: normalizedEmail,
+      });
+      await publish("complete", {
+        account_type: accountType,
+        email: normalizedEmail,
+        key_type: result.key_type,
+      });
+      const { api_key: _credential, ...completed } = result;
+      return completed;
+    } catch (error) {
+      if (error?.code === "signup_expired") {
+        await storage.deletePending(pending);
+        await publish("expired", {
+          account_type: accountType,
+          email: normalizedEmail,
+        });
+      } else if (error?.code === "rate_limited") {
+        await publish("rate_limited", {
+          account_type: accountType,
+          email: normalizedEmail,
+        });
+      } else if (
+        error?.code === "idempotency_conflict" ||
+        error?.code === "invalid_signup_recovery"
+      ) {
+        await storage.deletePending(pending);
+        await publish("conflict", {
+          account_type: accountType,
+          email: normalizedEmail,
+        });
+      } else {
+        await publish("retryable_failure", {
+          account_type: accountType,
+          email: normalizedEmail,
+        });
+      }
+      throw error;
+    }
   }
 
   createUser({ externalId, idempotencyKey: key } = {}) {

package/src/config.d.ts

@@ -7,11 +7,15 @@ export interface ShopstackProfile {
 
 export interface PendingSignup {
   accountType: "developer" | "personal";
+  attemptId?: string;
   email: string;
-  expiresAt: string;
-  id: string;
-  pollToken: string;
+  expiresAt?: string;
+  id?: string;
+  idempotencyKey?: string;
+  pollToken?: string;
   profile: string;
+  recoveryKey?: string;
+  signupId?: string;
 }
 
 export class ConfigStore {
@@ -25,6 +29,21 @@ export class ConfigStore {
   useProfile(name: string): Promise<ShopstackProfile>;
   savePendingSignup(signup: PendingSignup): Promise<PendingSignup>;
   pendingSignup(signupId: string): Promise<PendingSignup | undefined>;
+  pendingSignups(): Promise<PendingSignup[]>;
+  findPendingSignup(input: {
+    accountType: "developer" | "personal";
+    email: string;
+  }): Promise<PendingSignup | undefined>;
+  completePendingSignup(
+    attemptId: string,
+    profileName: string,
+    result: {
+      account: { id: string };
+      api_key: string;
+      key_type: "developer" | "user";
+      user?: { id?: string };
+    },
+  ): Promise<ShopstackProfile>;
   deletePendingSignup(signupId: string): Promise<void>;
   load(): Promise<{
     active: string | null;

package/src/config.js

@@ -46,6 +46,7 @@ export class ConfigStore {
   async write(config) {
     const directory = dirname(this.path);
     await mkdir(directory, { mode: 0o700, recursive: true });
+    await chmod(directory, 0o700);
     const temporary = `${this.path}.${process.pid}.tmp`;
     await writeFile(temporary, `${JSON.stringify(config, null, 2)}\n`, {
       mode: 0o600,
@@ -83,19 +84,70 @@ export class ConfigStore {
 
   async savePendingSignup(signup) {
     const config = await this.load();
-    config.pendingSignups[signup.id] = { ...signup };
+    const key = signup.attemptId ?? signup.id;
+    if (typeof key !== "string" || key.length === 0) {
+      throw new Error("Pending signup identity is invalid.");
+    }
+    config.pendingSignups[key] = { ...signup };
     await this.write(config);
-    return config.pendingSignups[signup.id];
+    return config.pendingSignups[key];
   }
 
   async pendingSignup(signupId) {
     const config = await this.load();
-    return config.pendingSignups[signupId];
+    return (
+      config.pendingSignups[signupId] ??
+      Object.values(config.pendingSignups).find(
+        (pending) => pending.id === signupId || pending.signupId === signupId,
+      )
+    );
+  }
+
+  async pendingSignups() {
+    return Object.values((await this.load()).pendingSignups);
+  }
+
+  async findPendingSignup({ accountType, email }) {
+    const normalizedEmail = email.trim().toLowerCase();
+    return Object.values((await this.load()).pendingSignups).find(
+      (pending) =>
+        pending.accountType === accountType &&
+        pending.email.trim().toLowerCase() === normalizedEmail,
+    );
+  }
+
+  async completePendingSignup(attemptId, profileName, result) {
+    const config = await this.load();
+    const entry = Object.entries(config.pendingSignups).find(
+      ([key, pending]) =>
+        key === attemptId ||
+        pending.id === attemptId ||
+        pending.signupId === attemptId,
+    );
+    if (entry === undefined) {
+      throw new Error("Pending signup is unavailable.");
+    }
+    config.profiles[profileName] = {
+      accountId: result.account.id,
+      apiKey: result.api_key,
+      keyType: result.key_type,
+      ...(result.user?.id === undefined ? {} : { userId: result.user.id }),
+    };
+    config.active = profileName;
+    delete config.pendingSignups[entry[0]];
+    await this.write(config);
+    return config.profiles[profileName];
   }
 
   async deletePendingSignup(signupId) {
     const config = await this.load();
-    delete config.pendingSignups[signupId];
+    const entry = Object.entries(config.pendingSignups).find(
+      ([key, pending]) =>
+        key === signupId ||
+        pending.id === signupId ||
+        pending.signupId === signupId,
+    );
+    if (entry !== undefined) delete config.pendingSignups[entry[0]];
     await this.write(config);
   }
 }