shopstack 0.2.5 → 0.2.6

package/README.md

@@ -16,30 +16,27 @@ The CLI and client default to Shopstack's production API at
 `https://api.shopstack.ai/v1`. Set
 `SHOPSTACK_API_URL` only when targeting a different Shopstack environment.
 
-## Verified signup
+## Verified login
 
 ```bash
-shopstack signup
+shopstack login [--email EMAIL] [--profile NAME] [--account-type personal|developer]
 ```
 
-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
+The command asks for an email when `--email` is absent. It uses the `default`
+profile and Personal account preference unless flags select other values. An
+existing account keeps its current account type. A new email creates the
+requested account type. The command waits for up to 15 minutes while you open
+the verification email. It does not issue a new API key until the link is
+consumed. The CLI privately persists all retry and polling capabilities before
+the first request, then retrieves a new key after verification and stores it in
 `~/.config/shopstack/config.json` with file mode `0600`; it never prints the
 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_...
-```
+rerun `shopstack login`; the matching pending attempt resumes automatically.
 
 ## Developer account and users
 
 ```bash
-shopstack signup
+shopstack login
 shopstack users create --external-id customer-123 --profile customer-123
 ```
 
@@ -61,7 +58,7 @@ Configure any stdio MCP client to run:
 }
 ```
 
-The MCP server can start and poll verified signup, manage local profiles,
+The MCP server has one verified login tool, manages local profiles,
 create developer-owned users, list/connect Link, and create/poll/message/cancel
 checkouts. Checkout creation returns the exact live-view URL as a clickable MCP
 resource; `get_live_view` replaces a lost one-time link for an active checkout.
@@ -147,11 +144,11 @@ Card values are never accepted as command-line flags.
 import { ShopstackClient } from "shopstack";
 
 const onboarding = new ShopstackClient();
-const account = await onboarding.signup({
+const account = await onboarding.login({
   accountType: "developer",
   email: "developer@example.com",
   onProgress: ({ state }) => console.log(state),
-  persistence: secureSignupPersistence,
+  persistence: secureLoginPersistence,
 });
 
 const shopstack = new ShopstackClient({
@@ -165,8 +162,8 @@ 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
+`login` generates retry state internally and returns the authenticated account
+identity only after the new 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.
 

package/SKILL.md

@@ -38,21 +38,22 @@ Never ask the model to print or relay a Shopstack API key. The CLI and MCP serve
 - A developer management key creates and manages users but cannot run a user's checkout.
 - Every developer-owned user receives an independent user API key and profile.
 
-Start verified CLI signup:
+Start verified CLI login:
 
 ```bash
-shopstack signup
+shopstack login [--email EMAIL] [--profile NAME] [--account-type personal|developer]
 ```
 
-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.
+The command prompts only for a missing email. Personal and `default` are the
+default account preference and profile. An existing account keeps its current
+type. A new email creates the requested account type. The user must open the
+time-limited verification link. The CLI generates and privately stores its
+retry and polling capabilities before the request, polls login, saves the new
+key with mode `0600`, and prints none of those credentials. Rerunning
+`shopstack login` automatically resumes the matching pending attempt after an
+interruption.
 
-After developer signup, create an end user:
+After developer login, create an end user:
 
 ```bash
 shopstack users create --external-id customer-123 --profile customer-123

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shopstack",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "Production Shopstack SDK and CLI for agentic checkout.",
   "type": "module",
   "exports": {

package/src/cli.js

@@ -17,14 +17,8 @@ Usage:
   shopstack <command> [options]
 
 Account setup:
-  shopstack signup
-    # Create or resume an email-verified Personal or Developer profile.
-  shopstack signup user --email EMAIL
-    # Create a Personal profile without interactive account-type prompts.
-  shopstack signup developer --email EMAIL
-    # Create a Developer management profile without interactive prompts.
-  shopstack signup resume SIGNUP_ID
-    # Resume a known pending email-verification flow.
+  shopstack login [--email EMAIL] [--profile NAME] [--account-type personal|developer]
+    # Log in, or create the requested account type when the email is new.
   shopstack users create --external-id ID [--profile NAME]
     # Create an independently scoped user from a Developer profile.
   shopstack profiles list
@@ -86,11 +80,6 @@ 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`);
 }
@@ -240,7 +229,7 @@ function sanitizedUserResult(result, profile) {
   return { api_key_saved: true, profile, user };
 }
 
-async function saveVerifiedSignup(result, profileName, configStore) {
+async function saveVerifiedLogin(result, profileName, configStore) {
   await configStore.saveProfile(
     profileName,
     {
@@ -253,34 +242,34 @@ async function saveVerifiedSignup(result, profileName, configStore) {
   );
 }
 
-function signupPersistence(configStore, profileName) {
+function loginPersistence(configStore, profileName) {
   return {
     async loadPending(input) {
-      return typeof configStore.findPendingSignup === "function"
-        ? configStore.findPendingSignup(input)
+      return typeof configStore.findPendingLogin === "function"
+        ? configStore.findPendingLogin(input)
         : undefined;
     },
     async savePending(state) {
-      await configStore.savePendingSignup({ ...state, profile: profileName });
+      await configStore.savePendingLogin({ ...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);
+      const pendingId = state.attemptId ?? state.loginId ?? state.id;
+      if (typeof configStore.completePendingLogin === "function") {
+        await configStore.completePendingLogin(pendingId, profileName, result);
         return;
       }
-      await saveVerifiedSignup(result, profileName, configStore);
-      await configStore.deletePendingSignup(pendingId);
+      await saveVerifiedLogin(result, profileName, configStore);
+      await configStore.deletePendingLogin(pendingId);
     },
     async deletePending(state) {
-      await configStore.deletePendingSignup(
-        state.attemptId ?? state.signupId ?? state.id,
+      await configStore.deletePendingLogin(
+        state.attemptId ?? state.loginId ?? state.id,
       );
     },
   };
 }
 
-async function reportSignupProgress(progress, stream) {
+async function reportLoginProgress(progress, stream) {
   switch (progress.state) {
     case "email_sent":
       stream.write("Verification email sent.\n");
@@ -292,23 +281,21 @@ async function reportSignupProgress(progress, stream) {
       stream.write("✓ Email verified\n");
       return;
     case "complete":
-      stream.write("✓ Shopstack account created\n");
+      stream.write("✓ Shopstack login complete\n");
       stream.write("✓ Credentials saved securely\n");
       return;
     case "expired":
-      stream.write("Signup expired. Start again to receive a new email.\n");
+      stream.write("Login 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",
-      );
+      stream.write("Login is rate-limited. Retry after the indicated delay.\n");
       return;
     case "conflict":
-      stream.write("Signup retry state conflicted and was cleared.\n");
+      stream.write("Login 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",
+        "Login paused after a retryable failure. Run login again to resume.\n",
       );
       return;
     default:
@@ -321,8 +308,7 @@ async function activeClient(dependencies, requiredKind = "user") {
   const environmentKey = dependencies.env.SHOPSTACK_API_KEY;
   const apiKey = environmentKey || profile?.apiKey;
   const keyType = environmentKey ? requiredKind : profile?.keyType;
-  if (!apiKey)
-    throw new Error("No active Shopstack API key. Run signup first.");
+  if (!apiKey) throw new Error("No active Shopstack API key. Run login first.");
   if (requiredKind && keyType !== requiredKind) {
     throw new Error(`This command requires an active ${requiredKind} profile.`);
   }
@@ -368,136 +354,62 @@ export async function runCli(args, supplied = {}) {
     return;
   }
 
-  if (group === "signup") {
-    if (action === "resume") {
-      if (rest.length !== 1) {
-        throw new Error("Use `shopstack signup resume SIGNUP_ID`.");
-      }
-      const pending = await dependencies.configStore.pendingSignup(rest[0]);
-      if (pending === undefined) {
-        throw new Error(
-          "That signup is not present in the local profile store.",
-        );
-      }
-      const client = dependencies.clientFactory({
-        baseUrl: dependencies.env.SHOPSTACK_API_URL,
-      });
-      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 !== undefined && action !== "user" && action !== "developer") {
-      throw new Error(
-        "Use `shopstack signup user` or `shopstack signup developer`.",
-      );
-    }
-    const signupArgs = action === undefined ? [] : rest;
+  if (group === "login") {
     const { options, positional } = parseOptions(
-      signupArgs,
-      new Set(["email", "profile"]),
+      args.slice(1),
+      new Set(["account-type", "email", "profile"]),
     );
-    if (positional.length > 0) throw new Error("Unexpected signup argument.");
+    if (positional.length > 0) throw new Error("Unexpected login argument.");
+    const profileName = options.profile ?? "default";
+    const requestedAccountType = options["account-type"] ?? "personal";
+    if (
+      requestedAccountType !== "personal" &&
+      requestedAccountType !== "developer"
+    ) {
+      throw new Error("Account type must be personal or developer.");
+    }
     const pendingCandidates =
-      action === undefined &&
-      typeof dependencies.configStore.pendingSignups === "function"
-        ? await dependencies.configStore.pendingSignups()
+      typeof dependencies.configStore.pendingLogins === "function"
+        ? await dependencies.configStore.pendingLogins()
         : [];
+    const matchingPending = pendingCandidates.filter(
+      (pending) =>
+        pending.profile === profileName &&
+        (options.email === undefined ||
+          pending.email.trim().toLowerCase() ===
+            options.email.trim().toLowerCase()) &&
+        (options["account-type"] === undefined ||
+          pending.accountType === requestedAccountType),
+    );
     const resumable =
-      pendingCandidates.length === 1 ? pendingCandidates[0] : undefined;
-    let accountType;
-    let email;
+      matchingPending.length === 1 ? matchingPending[0] : undefined;
+    const accountType = resumable?.accountType ?? requestedAccountType;
+    let email = resumable?.email ?? options.email;
     if (resumable !== undefined) {
-      accountType = resumable.accountType;
-      email = resumable.email;
-      dependencies.stderr.write("Resuming pending signup.\n");
-    } else if (action === undefined) {
+      dependencies.stderr.write("Resuming pending login.\n");
+    }
+    if (email === 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");
     }
+    if (email.length === 0) throw new Error("Email is required.");
     const client = dependencies.clientFactory({
       baseUrl: dependencies.env.SHOPSTACK_API_URL,
     });
-    const profileName =
-      options.profile ??
-      resumable?.profile ??
-      (accountType === "developer" ? "developer" : "default");
-    const result = await client.signup({
+    const result = await client.login({
       accountType,
       email,
       onProgress: (progress) =>
-        reportSignupProgress(progress, dependencies.stderr),
-      persistence: signupPersistence(dependencies.configStore, profileName),
+        reportLoginProgress(progress, dependencies.stderr),
+      persistence: loginPersistence(dependencies.configStore, profileName),
     });
     writeJson(dependencies.stdout, {
       ...sanitizedAccountResult(result),
       profile: profileName,
     });
-    if (accountType === "developer") {
+    if (result.key_type === "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

@@ -82,7 +82,7 @@ export interface LiveViewCapability {
   live_view_url: string;
 }
 
-export interface AccountSignupStarted {
+export interface AccountLoginStarted {
   id: string;
   account_type: "personal" | "developer";
   email: string;
@@ -92,7 +92,7 @@ export interface AccountSignupStarted {
   poll_token: string;
 }
 
-export interface VerifiedAccountSignup {
+export interface VerifiedAccountLogin {
   id: string;
   status: "verified";
   verified_at: string;
@@ -102,19 +102,19 @@ export interface VerifiedAccountSignup {
   user?: Record<string, unknown>;
 }
 
-export interface SignupOptions {
+export interface LoginOptions {
   accountType: "personal" | "developer";
   email: string;
   pollIntervalMs?: number;
   timeoutMs?: number;
-  persistence?: SignupPersistence;
-  onProgress?(progress: SignupProgress): void | Promise<void>;
+  persistence?: LoginPersistence;
+  onProgress?(progress: LoginProgress): void | Promise<void>;
   onVerificationRequired?(
-    signup: Omit<AccountSignupStarted, "poll_token">,
+    login: Omit<AccountLoginStarted, "poll_token">,
   ): void | Promise<void>;
 }
 
-export interface PendingSignupState {
+export interface PendingLoginState {
   accountType: "personal" | "developer";
   attemptId: string;
   email: string;
@@ -122,23 +122,23 @@ export interface PendingSignupState {
   idempotencyKey: string;
   pollToken?: string;
   recoveryKey: string;
-  signupId?: string;
+  loginId?: string;
 }
 
-export interface SignupPersistence {
+export interface LoginPersistence {
   loadPending(input: {
     accountType: "personal" | "developer";
     email: string;
-  }): Promise<PendingSignupState | undefined>;
-  savePending(state: PendingSignupState): Promise<void>;
+  }): Promise<PendingLoginState | undefined>;
+  savePending(state: PendingLoginState): Promise<void>;
   completePending(
-    state: PendingSignupState,
-    result: VerifiedAccountSignup,
+    state: PendingLoginState,
+    result: VerifiedAccountLogin,
   ): Promise<void>;
-  deletePending(state: PendingSignupState): Promise<void>;
+  deletePending(state: PendingLoginState): Promise<void>;
 }
 
-export interface SignupProgress {
+export interface LoginProgress {
   state:
     | "pending"
     | "email_sent"
@@ -155,7 +155,7 @@ export interface SignupProgress {
   key_type?: "user" | "developer";
 }
 
-export type CompletedAccountSignup = Omit<VerifiedAccountSignup, "api_key">;
+export type CompletedAccountLogin = Omit<VerifiedAccountLogin, "api_key">;
 
 export class ShopstackApiError extends Error {
   code: string;
@@ -165,20 +165,20 @@ export class ShopstackApiError extends Error {
 
 export class ShopstackClient {
   constructor(options?: ShopstackClientOptions);
-  startAccountSignup(input: {
+  startAccountLogin(input: {
     accountType: "personal" | "developer";
     email: string;
-  }): Promise<AccountSignupStarted>;
-  pollAccountSignup(
-    signupId: string,
+  }): Promise<AccountLoginStarted>;
+  pollAccountLogin(
+    loginId: string,
     pollToken: string,
-  ): Promise<Omit<AccountSignupStarted, "poll_token"> | VerifiedAccountSignup>;
-  waitForAccountSignup(
-    signupId: string,
+  ): Promise<Omit<AccountLoginStarted, "poll_token"> | VerifiedAccountLogin>;
+  waitForAccountLogin(
+    loginId: string,
     pollToken: string,
     options?: { pollIntervalMs?: number; timeoutMs?: number },
-  ): Promise<VerifiedAccountSignup>;
-  signup(input: SignupOptions): Promise<CompletedAccountSignup>;
+  ): Promise<VerifiedAccountLogin>;
+  login(input: LoginOptions): Promise<CompletedAccountLogin>;
   createUser(input: {
     externalId: string;
     idempotencyKey?: string;

package/src/client.js

@@ -17,11 +17,11 @@ function idempotencyKey(prefix) {
   return `${prefix}-${randomUUID()}`;
 }
 
-function signupRecoveryKey() {
-  return `signup_recovery_${randomBytes(32).toString("base64url")}`;
+function loginRecoveryKey() {
+  return `login_recovery_${randomBytes(32).toString("base64url")}`;
 }
 
-function signupAttemptKey(accountType, email) {
+function loginAttemptKey(accountType, email) {
   return `${accountType}\u0000${email.trim().toLowerCase()}`;
 }
 
@@ -164,7 +164,7 @@ export class ShopstackClient {
       body,
       idempotencyKey: mutationKey,
       method = "GET",
-      signupRecoveryKey: recoveryKey,
+      loginRecoveryKey: recoveryKey,
     } = {},
   ) {
     const headers = new Headers({ Accept: "application/json" });
@@ -174,7 +174,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);
+    if (recoveryKey) headers.set("Login-Recovery-Key", recoveryKey);
     const response = await this.fetch(`${this.baseUrl}${path}`, {
       body: body === undefined ? undefined : JSON.stringify(body),
       headers,
@@ -208,37 +208,32 @@ export class ShopstackClient {
     return payload;
   }
 
-  _startAccountSignup({
-    accountType,
-    email,
-    idempotencyKey: key,
-    recoveryKey,
-  }) {
-    return this.request("/accounts", {
+  _startAccountLogin({ accountType, email, idempotencyKey: key, recoveryKey }) {
+    return this.request("/login", {
       body: { account_type: accountType, email },
       idempotencyKey: key,
       method: "POST",
-      signupRecoveryKey: recoveryKey,
+      loginRecoveryKey: recoveryKey,
     });
   }
 
-  startAccountSignup({ accountType, email } = {}) {
-    return this._startAccountSignup({
+  startAccountLogin({ accountType, email } = {}) {
+    return this._startAccountLogin({
       accountType,
       email,
       idempotencyKey: idempotencyKey("account"),
-      recoveryKey: signupRecoveryKey(),
+      recoveryKey: loginRecoveryKey(),
     });
   }
 
-  pollAccountSignup(signupId, pollToken) {
-    return this.request(`/accounts/${encodeURIComponent(signupId)}`, {
+  pollAccountLogin(loginId, pollToken) {
+    return this.request(`/login/${encodeURIComponent(loginId)}`, {
       bearerToken: pollToken,
     });
   }
 
-  async waitForAccountSignup(
-    signupId,
+  async waitForAccountLogin(
+    loginId,
     pollToken,
     { pollIntervalMs = 2_000, timeoutMs = 15 * 60 * 1_000 } = {},
   ) {
@@ -246,16 +241,16 @@ export class ShopstackClient {
     while (true) {
       if (Date.now() - startedAt >= timeoutMs) {
         throw new ShopstackApiError("Email verification timed out.", {
-          code: "signup_timeout",
+          code: "login_timeout",
         });
       }
-      const current = await this.pollAccountSignup(signupId, pollToken);
+      const current = await this.pollAccountLogin(loginId, pollToken);
       if (current.status === "verified") return current;
       await delay(pollIntervalMs);
     }
   }
 
-  async signup({
+  async login({
     accountType,
     email,
     onProgress,
@@ -265,17 +260,17 @@ export class ShopstackClient {
     timeoutMs = 15 * 60 * 1_000,
   } = {}) {
     const normalizedEmail = email.trim().toLowerCase();
-    const memoryKey = signupAttemptKey(accountType, normalizedEmail);
-    this._pendingSignups ??= new Map();
+    const memoryKey = loginAttemptKey(accountType, normalizedEmail);
+    this._pendingLogins ??= new Map();
     const storage = persistence ?? {
       completePending: async (state, result) => {
         this.apiKey = result.api_key;
-        this._pendingSignups.delete(memoryKey);
+        this._pendingLogins.delete(memoryKey);
       },
-      deletePending: async () => this._pendingSignups.delete(memoryKey),
-      loadPending: async () => this._pendingSignups.get(memoryKey),
+      deletePending: async () => this._pendingLogins.delete(memoryKey),
+      loadPending: async () => this._pendingLogins.get(memoryKey),
       savePending: async (state) => {
-        this._pendingSignups.set(memoryKey, structuredClone(state));
+        this._pendingLogins.set(memoryKey, structuredClone(state));
       },
     };
     const publish = async (state, details = {}) => {
@@ -299,7 +294,7 @@ export class ShopstackClient {
       attemptId: `attempt-${randomUUID()}`,
       email: normalizedEmail,
       idempotencyKey: idempotencyKey("account"),
-      recoveryKey: signupRecoveryKey(),
+      recoveryKey: loginRecoveryKey(),
     };
     await storage.savePending(pending);
     await publish("pending", {
@@ -307,8 +302,8 @@ export class ShopstackClient {
       email: normalizedEmail,
     });
     try {
-      if (!pending.signupId || !pending.pollToken) {
-        const started = await this._startAccountSignup({
+      if (!pending.loginId || !pending.pollToken) {
+        const started = await this._startAccountLogin({
           accountType,
           email: normalizedEmail,
           idempotencyKey: pending.idempotencyKey,
@@ -318,7 +313,7 @@ export class ShopstackClient {
           ...pending,
           expiresAt: started.expires_at,
           pollToken: started.poll_token,
-          signupId: started.id,
+          loginId: started.id,
         };
         await storage.savePending(pending);
         if (typeof onVerificationRequired === "function") {
@@ -341,8 +336,8 @@ export class ShopstackClient {
         email: normalizedEmail,
         expires_at: pending.expiresAt,
       });
-      const result = await this.waitForAccountSignup(
-        pending.signupId,
+      const result = await this.waitForAccountLogin(
+        pending.loginId,
         pending.pollToken,
         { pollIntervalMs, timeoutMs },
       );
@@ -359,7 +354,7 @@ export class ShopstackClient {
       const { api_key: _credential, ...completed } = result;
       return completed;
     } catch (error) {
-      if (error?.code === "signup_expired") {
+      if (error?.code === "login_expired") {
         await storage.deletePending(pending);
         await publish("expired", {
           account_type: accountType,
@@ -372,7 +367,7 @@ export class ShopstackClient {
         });
       } else if (
         error?.code === "idempotency_conflict" ||
-        error?.code === "invalid_signup_recovery"
+        error?.code === "invalid_login_recovery"
       ) {
         await storage.deletePending(pending);
         await publish("conflict", {

package/src/config.d.ts

@@ -5,7 +5,7 @@ export interface ShopstackProfile {
   userId?: string;
 }
 
-export interface PendingSignup {
+export interface PendingLogin {
   accountType: "developer" | "personal";
   attemptId?: string;
   email: string;
@@ -15,7 +15,7 @@ export interface PendingSignup {
   pollToken?: string;
   profile: string;
   recoveryKey?: string;
-  signupId?: string;
+  loginId?: string;
 }
 
 export class ConfigStore {
@@ -27,14 +27,14 @@ export class ConfigStore {
     options?: { activate?: boolean },
   ): Promise<ShopstackProfile>;
   useProfile(name: string): Promise<ShopstackProfile>;
-  savePendingSignup(signup: PendingSignup): Promise<PendingSignup>;
-  pendingSignup(signupId: string): Promise<PendingSignup | undefined>;
-  pendingSignups(): Promise<PendingSignup[]>;
-  findPendingSignup(input: {
+  savePendingLogin(login: PendingLogin): Promise<PendingLogin>;
+  pendingLogin(loginId: string): Promise<PendingLogin | undefined>;
+  pendingLogins(): Promise<PendingLogin[]>;
+  findPendingLogin(input: {
     accountType: "developer" | "personal";
     email: string;
-  }): Promise<PendingSignup | undefined>;
-  completePendingSignup(
+  }): Promise<PendingLogin | undefined>;
+  completePendingLogin(
     attemptId: string,
     profileName: string,
     result: {
@@ -44,10 +44,10 @@ export class ConfigStore {
       user?: { id?: string };
     },
   ): Promise<ShopstackProfile>;
-  deletePendingSignup(signupId: string): Promise<void>;
+  deletePendingLogin(loginId: string): Promise<void>;
   load(): Promise<{
     active: string | null;
-    pendingSignups: Record<string, PendingSignup>;
+    pendingLogins: Record<string, PendingLogin>;
     profiles: Record<string, ShopstackProfile>;
   }>;
 }

package/src/config.js

@@ -26,18 +26,21 @@ export class ConfigStore {
         throw new Error("Shopstack configuration is invalid.");
       }
       if (
-        parsed.pendingSignups !== undefined &&
-        (typeof parsed.pendingSignups !== "object" ||
-          parsed.pendingSignups === null ||
-          Array.isArray(parsed.pendingSignups))
+        parsed.pendingLogins !== undefined &&
+        (typeof parsed.pendingLogins !== "object" ||
+          parsed.pendingLogins === null ||
+          Array.isArray(parsed.pendingLogins))
       ) {
         throw new Error("Shopstack configuration is invalid.");
       }
-      parsed.pendingSignups ??= {};
-      return parsed;
+      return {
+        active: parsed.active ?? null,
+        pendingLogins: parsed.pendingLogins ?? {},
+        profiles: parsed.profiles,
+      };
     } catch (error) {
       if (error?.code === "ENOENT") {
-        return { active: null, pendingSignups: {}, profiles: {} };
+        return { active: null, pendingLogins: {}, profiles: {} };
       }
       throw error;
     }
@@ -82,50 +85,50 @@ export class ConfigStore {
     return typeof name === "string" ? config.profiles[name] : undefined;
   }
 
-  async savePendingSignup(signup) {
+  async savePendingLogin(login) {
     const config = await this.load();
-    const key = signup.attemptId ?? signup.id;
+    const key = login.attemptId ?? login.id;
     if (typeof key !== "string" || key.length === 0) {
-      throw new Error("Pending signup identity is invalid.");
+      throw new Error("Pending login identity is invalid.");
     }
-    config.pendingSignups[key] = { ...signup };
+    config.pendingLogins[key] = { ...login };
     await this.write(config);
-    return config.pendingSignups[key];
+    return config.pendingLogins[key];
   }
 
-  async pendingSignup(signupId) {
+  async pendingLogin(loginId) {
     const config = await this.load();
     return (
-      config.pendingSignups[signupId] ??
-      Object.values(config.pendingSignups).find(
-        (pending) => pending.id === signupId || pending.signupId === signupId,
+      config.pendingLogins[loginId] ??
+      Object.values(config.pendingLogins).find(
+        (pending) => pending.id === loginId || pending.loginId === loginId,
       )
     );
   }
 
-  async pendingSignups() {
-    return Object.values((await this.load()).pendingSignups);
+  async pendingLogins() {
+    return Object.values((await this.load()).pendingLogins);
   }
 
-  async findPendingSignup({ accountType, email }) {
+  async findPendingLogin({ accountType, email }) {
     const normalizedEmail = email.trim().toLowerCase();
-    return Object.values((await this.load()).pendingSignups).find(
+    return Object.values((await this.load()).pendingLogins).find(
       (pending) =>
         pending.accountType === accountType &&
         pending.email.trim().toLowerCase() === normalizedEmail,
     );
   }
 
-  async completePendingSignup(attemptId, profileName, result) {
+  async completePendingLogin(attemptId, profileName, result) {
     const config = await this.load();
-    const entry = Object.entries(config.pendingSignups).find(
+    const entry = Object.entries(config.pendingLogins).find(
       ([key, pending]) =>
         key === attemptId ||
         pending.id === attemptId ||
-        pending.signupId === attemptId,
+        pending.loginId === attemptId,
     );
     if (entry === undefined) {
-      throw new Error("Pending signup is unavailable.");
+      throw new Error("Pending login is unavailable.");
     }
     config.profiles[profileName] = {
       accountId: result.account.id,
@@ -134,20 +137,20 @@ export class ConfigStore {
       ...(result.user?.id === undefined ? {} : { userId: result.user.id }),
     };
     config.active = profileName;
-    delete config.pendingSignups[entry[0]];
+    delete config.pendingLogins[entry[0]];
     await this.write(config);
     return config.profiles[profileName];
   }
 
-  async deletePendingSignup(signupId) {
+  async deletePendingLogin(loginId) {
     const config = await this.load();
-    const entry = Object.entries(config.pendingSignups).find(
+    const entry = Object.entries(config.pendingLogins).find(
       ([key, pending]) =>
-        key === signupId ||
-        pending.id === signupId ||
-        pending.signupId === signupId,
+        key === loginId ||
+        pending.id === loginId ||
+        pending.loginId === loginId,
     );
-    if (entry !== undefined) delete config.pendingSignups[entry[0]];
+    if (entry !== undefined) delete config.pendingLogins[entry[0]];
     await this.write(config);
   }
 }