shopstack 0.2.6 → 0.3.0

package/src/config.d.ts

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

package/src/config.js

@@ -2,6 +2,17 @@ import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 
+export function resolveProfileBaseUrl(profile, selectedBaseUrl) {
+  const saved = profile?.baseUrl?.replace(/\/+$/u, "");
+  const selected = selectedBaseUrl?.replace(/\/+$/u, "");
+  if (saved !== undefined && selected !== undefined && saved !== selected) {
+    throw new Error(
+      "This profile belongs to a different Shopstack API. Select its endpoint or use a separate profile store.",
+    );
+  }
+  return saved ?? selected;
+}
+
 export function defaultConfigPath() {
   return (
     process.env.SHOPSTACK_CONFIG_FILE ??
@@ -26,21 +37,18 @@ export class ConfigStore {
         throw new Error("Shopstack configuration is invalid.");
       }
       if (
-        parsed.pendingLogins !== undefined &&
-        (typeof parsed.pendingLogins !== "object" ||
-          parsed.pendingLogins === null ||
-          Array.isArray(parsed.pendingLogins))
+        parsed.pendingSignups !== undefined &&
+        (typeof parsed.pendingSignups !== "object" ||
+          parsed.pendingSignups === null ||
+          Array.isArray(parsed.pendingSignups))
       ) {
         throw new Error("Shopstack configuration is invalid.");
       }
-      return {
-        active: parsed.active ?? null,
-        pendingLogins: parsed.pendingLogins ?? {},
-        profiles: parsed.profiles,
-      };
+      parsed.pendingSignups ??= {};
+      return parsed;
     } catch (error) {
       if (error?.code === "ENOENT") {
-        return { active: null, pendingLogins: {}, profiles: {} };
+        return { active: null, pendingSignups: {}, profiles: {} };
       }
       throw error;
     }
@@ -85,72 +93,73 @@ export class ConfigStore {
     return typeof name === "string" ? config.profiles[name] : undefined;
   }
 
-  async savePendingLogin(login) {
+  async savePendingSignup(signup) {
     const config = await this.load();
-    const key = login.attemptId ?? login.id;
+    const key = signup.attemptId ?? signup.id;
     if (typeof key !== "string" || key.length === 0) {
-      throw new Error("Pending login identity is invalid.");
+      throw new Error("Pending signup identity is invalid.");
     }
-    config.pendingLogins[key] = { ...login };
+    config.pendingSignups[key] = { ...signup };
     await this.write(config);
-    return config.pendingLogins[key];
+    return config.pendingSignups[key];
   }
 
-  async pendingLogin(loginId) {
+  async pendingSignup(signupId) {
     const config = await this.load();
     return (
-      config.pendingLogins[loginId] ??
-      Object.values(config.pendingLogins).find(
-        (pending) => pending.id === loginId || pending.loginId === loginId,
+      config.pendingSignups[signupId] ??
+      Object.values(config.pendingSignups).find(
+        (pending) => pending.id === signupId || pending.signupId === signupId,
       )
     );
   }
 
-  async pendingLogins() {
-    return Object.values((await this.load()).pendingLogins);
+  async pendingSignups() {
+    return Object.values((await this.load()).pendingSignups);
   }
 
-  async findPendingLogin({ accountType, email }) {
+  async findPendingSignup({ accountType, email }) {
     const normalizedEmail = email.trim().toLowerCase();
-    return Object.values((await this.load()).pendingLogins).find(
+    return Object.values((await this.load()).pendingSignups).find(
       (pending) =>
         pending.accountType === accountType &&
         pending.email.trim().toLowerCase() === normalizedEmail,
     );
   }
 
-  async completePendingLogin(attemptId, profileName, result) {
+  async completePendingSignup(attemptId, profileName, result) {
     const config = await this.load();
-    const entry = Object.entries(config.pendingLogins).find(
+    const entry = Object.entries(config.pendingSignups).find(
       ([key, pending]) =>
         key === attemptId ||
         pending.id === attemptId ||
-        pending.loginId === attemptId,
+        pending.signupId === attemptId,
     );
     if (entry === undefined) {
-      throw new Error("Pending login is unavailable.");
+      throw new Error("Pending signup is unavailable.");
     }
     config.profiles[profileName] = {
       accountId: result.account.id,
       apiKey: result.api_key,
       keyType: result.key_type,
+      ...(entry[1].baseUrl === undefined ? {} : { baseUrl: entry[1].baseUrl }),
       ...(result.user?.id === undefined ? {} : { userId: result.user.id }),
     };
     config.active = profileName;
-    delete config.pendingLogins[entry[0]];
+    delete config.pendingSignups[entry[0]];
     await this.write(config);
     return config.profiles[profileName];
   }
 
-  async deletePendingLogin(loginId) {
+  async deletePendingSignup(signupId) {
     const config = await this.load();
-    const entry = Object.entries(config.pendingLogins).find(
+    const entry = Object.entries(config.pendingSignups).find(
       ([key, pending]) =>
-        key === loginId ||
-        pending.id === loginId ||
-        pending.loginId === loginId,
+        key === signupId ||
+        pending.id === signupId ||
+        pending.signupId === signupId,
     );
-    if (entry !== undefined) delete config.pendingLogins[entry[0]];
+    if (entry !== undefined) delete config.pendingSignups[entry[0]];
     await this.write(config);
   }
 }

package/src/reservation-progress.js

@@ -0,0 +1,132 @@
+const operations = new Set([
+  "resolve_location",
+  "get_search_filters",
+  "search_restaurants",
+  "prepare_booking",
+  "confirm_booking",
+  "decline_booking",
+  "ask_user",
+  "reply",
+  "request",
+  "model_decision",
+  "model_request",
+  "model_retry_wait",
+  "restaurant_request",
+  "provider_session",
+  "location_lookup",
+  "availability_recheck",
+  "slot_lock",
+  "slot_unlock",
+  "guest_profile",
+  "booking_submit",
+  "booking_status",
+  "booking_cancel",
+  "guest_inbox",
+]);
+const phases = new Set(["started", "completed", "failed", "selected"]);
+const failures = new Set([
+  "ETIMEDOUT",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_BODY_TIMEOUT",
+  "UND_ERR_SOCKET",
+  "TimeoutError",
+  "AbortError",
+  "model_invalid_response",
+  "operation_failed",
+]);
+const nonnegative = (value) => Number.isSafeInteger(value) && value >= 0;
+
+// Reconstruct the closed display shape. Provider bodies and arbitrary fields never pass through.
+function publicProgress(frame, previous, requestId) {
+  if (
+    frame.request_id !== requestId ||
+    !nonnegative(frame.sequence) ||
+    frame.sequence <= previous ||
+    frame.sequence > 512 ||
+    !nonnegative(frame.call_id) ||
+    !nonnegative(frame.elapsed_ms) ||
+    !operations.has(frame.operation) ||
+    !phases.has(frame.phase)
+  )
+    throw new Error("Invalid progress frame.");
+  const event = Object.fromEntries(
+    [
+      "type",
+      "request_id",
+      "sequence",
+      "call_id",
+      "operation",
+      "phase",
+      "elapsed_ms",
+    ].map((key) => [key, frame[key]]),
+  );
+  if (nonnegative(frame.duration_ms)) event.duration_ms = frame.duration_ms;
+  if (
+    Number.isInteger(frame.http_status) &&
+    frame.http_status >= 100 &&
+    frame.http_status <= 599
+  )
+    event.http_status = frame.http_status;
+  if (failures.has(frame.failure)) event.failure = frame.failure;
+  return event;
+}
+
+export async function readReservationProgress(response, onProgress) {
+  const requestId = response.headers.get("x-request-id");
+  if (!/^req_[a-f0-9]{32}$/u.test(requestId ?? "") || !response.body)
+    throw new Error("Invalid progress stream.");
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let text = "";
+  let bytes = 0;
+  let sequence = 0;
+  let result;
+  try {
+    for (;;) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      bytes += chunk.value.byteLength;
+      if (bytes > 17 * 1024 * 1024)
+        throw new Error("Progress stream limit exceeded.");
+      text += decoder.decode(chunk.value, { stream: true });
+      for (;;) {
+        const end = text.indexOf("\n");
+        if (end < 0) break;
+        const frame = JSON.parse(text.slice(0, end));
+        text = text.slice(end + 1);
+        if (result || !frame || typeof frame !== "object")
+          throw new Error("Invalid stream order.");
+        if (frame.type === "progress") {
+          const event = publicProgress(frame, sequence, requestId);
+          sequence = event.sequence;
+          try {
+            Promise.resolve(onProgress?.(event)).catch(() => {});
+          } catch {
+            /* Display failure cannot retry a mutation. */
+          }
+        } else if (
+          frame.type === "result" &&
+          frame.request_id === requestId &&
+          Number.isInteger(frame.status) &&
+          frame.status >= 200 &&
+          frame.status <= 599 &&
+          Object.hasOwn(frame, "body")
+        ) {
+          result = { status: frame.status, payload: frame.body };
+        } else throw new Error("Invalid result frame.");
+      }
+    }
+    text += decoder.decode();
+    if (!result || text.length) throw new Error("Incomplete progress stream.");
+    return result;
+  } finally {
+    // Also release failed/truncated streams. No automatic request retry.
+    await reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Shopstack
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.