@jsm-mit/sultana-agent-tools-package 0.6.0 → 0.7.0

package/README.md

@@ -186,6 +186,70 @@ const tools = session
   `unavailable` instead of booking hours off (`timeZone: null` skips the guard; `hostTimeZoneProblem`
   lets a host check at start-up).
 
+## Booksy tools (experimental, since 0.7.0)
+
+"Copy my salon from Booksy": three read-only tools that take the address of a PUBLIC Booksy profile
+and return its content in the shape Sultana's write tools take, and one write tool that copies the
+whole service catalogue under ONE confirmation.
+
+```ts
+const port = new IcSalonCorePort({ … });
+const reader = new BooksyProfileReader();        // keep it for the conversation: one fetch per profile
+
+const tools = [
+    ...createSalonToolsFromPort(port, { confirmations }),
+    ...createBooksyTools(port, { confirmations, reader, photoSink }),   // no photoSink → no download tool
+];
+```
+
+`createBooksyReaderTools(…)` gives the three read tools alone — they need no salon and no `confirmed`.
+
+| tool | what it returns |
+|---|---|
+| `read_booksy_salon` | name, description, address, coordinates, weekly opening hours (day 0 = Monday, `ranges` as `set_weekly_hours` reads them), the team, counts of services and photos |
+| `read_booksy_services` | services ready for `add_service`: `name`, `pricePln`, `durationMinutes`, plus `booksyCategory`, `description`, `workerNames`, `notes`; optional `category` filter |
+| `download_booksy_photos` | fetches photos (`logo`, `cover`, `salon` by default; also `inspiration`, `service` — the per-service portfolio —, `staff`) and hands each to the host's `BooksyPhotoSink`; up to 150 a call |
+| `import_booksy_services` | **write**: copies the catalogue into this salon. Arguments: `url`, optional `category`, optional `overrides` (`{name, skip?, serviceTypeIds?}`), `confirmed` |
+| `import_booksy_workers` | **placeholder**: says that copying the team is not built yet, lists the people on Booksy and who is missing in the salon; writes nothing |
+
+`import_booksy_services`:
+
+- **The model never carries the services.** It names the profile; the tool reads it again itself
+  (from the shared reader), so sixty services cost the context nothing and cannot be retyped wrong.
+- **One confirmation.** `confirmed: false` returns the full list — name, price, time, the service
+  type and the people it found — and an echo with `expectedCount`. The confirming call is refused
+  when the plan no longer has that many services (the profile or the salon changed in between).
+- **Service types are chosen in the tool**, with the catalogue's own search: points for the whole
+  name, for each word (earlier words weigh more) and for the Booksy category; a type must be
+  pointed at by the whole name, the FIRST word or the category. No match → the service is NOT copied
+  (core refuses a service without a type); the preview lists it and asks for a type. `overrides` sets a type by hand.
+- **People by name.** A Booksy first name that matches exactly one worker of the salon is
+  assigned; the rest are listed once under the preview.
+- **Idempotent.** A service whose name the salon already has is skipped, so an import that stopped
+  half-way (quota, connection) is finished by running it again. Writes go 4 at a time and stop at
+  the first failure; the result says how many were copied and how many are left.
+
+- **One variant, one service.** Booksy nests price-and-time variants under a service; each becomes
+  `"Service — variant"`.
+- **Sultana's units.** Whole zloty, a multiple of 5 minutes, at least 5. Every adjustment, and a
+  "from" / varying price, is written into `notes` for the agent to tell the owner.
+- **Ids stay empty.** `serviceTypeIds` and `workerIds` live in Sultana; the agent resolves them with
+  `find_service_type` (hint: `booksyCategory`) and `list_workers`.
+- **The source** is the page's `__NUXT_DATA__` block (`src/booksy/nuxt-payload.ts` reads the devalue
+  format); the JSON-LD block is a degraded fallback without durations, flagged `source.degraded`.
+- **The URL is untrusted**: only `https://booksy.com/<locale>/<id>_…` is fetched; the fragment and
+  the query are dropped. One fetch per profile per tool set.
+- **The package touches no disk.** Photos go to the sink the host passes; the sandbox's sink writes
+  to the git-ignored `sandbox/booksy-out/<booksy id>/photos/`.
+- **Reviews and customer names are never read.** Reading a profile by a script may be against
+  Booksy's terms of use — this is a trial to see whether the idea is worth a proper agreement.
+
+`readBooksySalonDraft(url)` gives the whole `SultanaSalonDraft` without a model.
+
+A host that hands these tools to an agent appends `SALON_BOOKSY_PERSONA_PL` to
+`SALON_AGENT_PERSONA_PL`. One `BooksyProfileReader` may serve the whole host: profiles are public,
+it remembers a profile for ten minutes and keeps the last fifty.
+
 ## What the tools guarantee
 
 - **`execute` never throws.** Every call returns `{status: "ok" | "confirmation_required" | "error"}`
@@ -217,6 +281,8 @@ const tools = session
 | `npm run whoami` | setup check: the identity, its salons, the service-type catalogue |
 | `npm run sandbox -- --fake` | talk to the tools against an in-memory salon |
 | `npm run sandbox` | the same conversation against a real canister |
+| `npm run booksy -- <profile url>` | the Booksy reader alone: prints the draft, writes `sandbox/booksy-out/<id>/draft.json` and the photos (`--no-photos`, `--all-photos`) — no model, no canister |
+| `npm run booksy -- <profile url> --import` | `import_booksy_services` against the in-memory salon: the preview, then the confirmed import |
 | `npm run test-tools` | the round trip against a live canister (creates its own salon) |
 | `npm run test-customer-tools` | the customer's round trip against a live, seeded canister: search, book, list, cancel (a fresh identity per run) |
 | `npm run publish-public` | publishes to npm from master — see below |

package/dist/booksy/fetch-page.d.ts

@@ -0,0 +1,25 @@
+import type { ToolErrorCode } from "../types.js";
+/** `fetch`, injectable — tests and hosts with their own HTTP stack pass a replacement. */
+export type FetchFn = (url: string, init?: {
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}) => Promise<Response>;
+/** A failure with the tool error code and an owner-readable sentence already chosen. */
+export declare class BooksyReadError extends Error {
+    readonly code: ToolErrorCode;
+    readonly summary: string;
+    constructor(code: ToolErrorCode, summary: string);
+}
+/**
+ * The model passes the URL, so it is untrusted: only an https Booksy profile goes through. The
+ * fragment (`#ba_s=…`, a tracking tag) and the query are dropped.
+ */
+export declare function normalizeBooksyUrl(raw: string): string;
+export declare function fetchBooksyPage(url: string, fetchFn?: FetchFn): Promise<string>;
+export interface FetchedPhoto {
+    bytes: Uint8Array;
+    contentType: string;
+}
+/** Photo URLs come out of the Booksy page, not from the model — still https only, and capped. */
+export declare function fetchPhoto(url: string, fetchFn?: FetchFn): Promise<FetchedPhoto>;
+//# sourceMappingURL=fetch-page.d.ts.map

package/dist/booksy/fetch-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-page.d.ts","sourceRoot":"","sources":["../../src/booksy/fetch-page.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,0FAA0F;AAC1F,MAAM,MAAM,OAAO,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAE5H,wFAAwF;AACxF,qBAAa,eAAgB,SAAQ,KAAK;IAElC,QAAQ,CAAC,IAAI,EAAE,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM;gBADf,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,MAAM;CAI/B;AAcD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAqBtD;AAED,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,OAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAiB5F;AAED,MAAM,WAAW,YAAY;IACzB,KAAK,EAAE,UAAU,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACvB;AAED,iGAAiG;AACjG,wBAAsB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,OAAe,GAAG,OAAO,CAAC,YAAY,CAAC,CAe7F"}

package/dist/booksy/fetch-page.js

@@ -0,0 +1,93 @@
+/** A failure with the tool error code and an owner-readable sentence already chosen. */
+export class BooksyReadError extends Error {
+    code;
+    summary;
+    constructor(code, summary) {
+        super(summary);
+        this.code = code;
+        this.summary = summary;
+    }
+}
+const BOOKSY_HOSTS = new Set(["booksy.com", "www.booksy.com"]);
+const FETCH_TIMEOUT_MS = 15_000;
+const MAX_PAGE_BYTES = 5 * 1024 * 1024;
+const MAX_PHOTO_BYTES = 15 * 1024 * 1024;
+// Booksy answers a bare client with a challenge page; it answers a browser with the profile.
+const BROWSER_HEADERS = {
+    "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0 Safari/537.36",
+    "accept-language": "pl-PL,pl;q=0.9",
+};
+/**
+ * The model passes the URL, so it is untrusted: only an https Booksy profile goes through. The
+ * fragment (`#ba_s=…`, a tracking tag) and the query are dropped.
+ */
+export function normalizeBooksyUrl(raw) {
+    let url;
+    try {
+        url = new URL(raw.trim());
+    }
+    catch {
+        throw new BooksyReadError("invalid_arguments", "To nie jest poprawny adres URL.");
+    }
+    if (url.protocol !== "https:" || !BOOKSY_HOSTS.has(url.hostname)) {
+        throw new BooksyReadError("invalid_arguments", "Adres musi być profilem salonu na https://booksy.com/.");
+    }
+    // A profile path is "/<locale>/<id>_<slug>…"; a listing or the home page has no salon in it.
+    if (!/^\/[a-z]{2}-[a-z]{2}\/\d+_/.test(url.pathname)) {
+        throw new BooksyReadError("invalid_arguments", "To nie wygląda na profil salonu. Adres profilu ma postać https://booksy.com/pl-pl/<numer>_<nazwa>….");
+    }
+    return `https://booksy.com${url.pathname}`;
+}
+export async function fetchBooksyPage(url, fetchFn = fetch) {
+    const response = await request(url, fetchFn, "Nie udało się połączyć z Booksy. Spróbuj ponownie za chwilę.");
+    if (response.status === 404)
+        throw new BooksyReadError("not_found", "Booksy nie ma profilu pod tym adresem.");
+    if (!response.ok) {
+        throw new BooksyReadError("unavailable", `Booksy odpowiedziało kodem ${response.status}. Spróbuj ponownie za chwilę.`);
+    }
+    // A redirect off Booksy means the page we would parse is not the page the owner named.
+    if (response.url && !BOOKSY_HOSTS.has(new URL(response.url).hostname)) {
+        throw new BooksyReadError("unavailable", "Booksy przekierowało poza swoją domenę — nie czytam tej strony.");
+    }
+    const html = await response.text();
+    if (html.length > MAX_PAGE_BYTES)
+        throw new BooksyReadError("unavailable", "Strona profilu jest zbyt duża.");
+    return html;
+}
+/** Photo URLs come out of the Booksy page, not from the model — still https only, and capped. */
+export async function fetchPhoto(url, fetchFn = fetch) {
+    if (!url.startsWith("https://"))
+        throw new BooksyReadError("invalid_arguments", "Adres zdjęcia nie jest https.");
+    const response = await request(url, fetchFn, "Nie udało się pobrać zdjęcia.");
+    if (!response.ok)
+        throw new BooksyReadError("unavailable", `Serwer zdjęć odpowiedział kodem ${response.status}.`);
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    if (bytes.length > MAX_PHOTO_BYTES)
+        throw new BooksyReadError("unavailable", "Zdjęcie jest zbyt duże.");
+    // Booksy's photo server labels everything a bare "image", so the header says nothing — the
+    // first bytes do.
+    const contentType = sniffImageType(bytes);
+    if (contentType === null)
+        throw new BooksyReadError("unavailable", "Pod adresem zdjęcia nie ma obrazu.");
+    return { bytes, contentType };
+}
+function sniffImageType(bytes) {
+    const startsWith = (signature, offset = 0) => signature.every((byte, at) => bytes[offset + at] === byte);
+    if (startsWith([0xff, 0xd8, 0xff]))
+        return "image/jpeg";
+    if (startsWith([0x89, 0x50, 0x4e, 0x47]))
+        return "image/png";
+    if (startsWith([0x47, 0x49, 0x46, 0x38]))
+        return "image/gif";
+    if (startsWith([0x52, 0x49, 0x46, 0x46]) && startsWith([0x57, 0x45, 0x42, 0x50], 8))
+        return "image/webp";
+    return null;
+}
+async function request(url, fetchFn, failure) {
+    try {
+        return await fetchFn(url, { headers: BROWSER_HEADERS, signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+    }
+    catch {
+        throw new BooksyReadError("unavailable", failure);
+    }
+}

package/dist/booksy/import-tools.d.ts

@@ -0,0 +1,22 @@
+import type { TurnConfirmations } from "../confirmations.js";
+import type { SalonCorePort } from "../salon-core-port.js";
+import { type AgentTool } from "../types.js";
+import { BooksyProfileReader, type CreateBooksyReaderToolsOptions } from "./tools.js";
+export interface CreateBooksyImportToolsOptions {
+    /** The reader the read tools use — shared, so a preview and its import read one page once. */
+    reader?: BooksyProfileReader;
+    confirmations?: TurnConfirmations;
+}
+/**
+ * The write half of "copy my salon from Booksy": the whole service catalogue under ONE
+ * confirmation. The model never carries sixty services through its context — it names the profile,
+ * the tool reads it again on its own, and the owner confirms the list the tool showed her.
+ */
+export declare function createBooksyImportTools(port: SalonCorePort, options?: CreateBooksyImportToolsOptions): AgentTool[];
+export interface CreateBooksyToolsOptions extends CreateBooksyReaderToolsOptions {
+    confirmations?: TurnConfirmations;
+}
+/** The whole Booksy set for ONE salon — the read tools and the import — over one shared reader.
+ * A host adds it next to `createSalonTools`; the port is the same one. */
+export declare function createBooksyTools(port: SalonCorePort, options?: CreateBooksyToolsOptions): AgentTool[];
+//# sourceMappingURL=import-tools.d.ts.map

package/dist/booksy/import-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-tools.d.ts","sourceRoot":"","sources":["../../src/booksy/import-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,KAAK,EAAE,aAAa,EAAkD,MAAM,uBAAuB,CAAC;AAG3G,OAAO,EAAW,KAAK,SAAS,EAAmB,MAAM,aAAa,CAAC;AAGvE,OAAO,EACH,mBAAmB,EAInB,KAAK,8BAA8B,EACtC,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,8BAA8B;IAC3C,8FAA8F;IAC9F,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,aAAa,CAAC,EAAE,iBAAiB,CAAC;CACrC;AAMD;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,GAAE,8BAAmC,GAAG,SAAS,EAAE,CAItH;AAED,MAAM,WAAW,wBAAyB,SAAQ,8BAA8B;IAC5E,aAAa,CAAC,EAAE,iBAAiB,CAAC;CACrC;AAED;0EAC0E;AAC1E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,GAAE,wBAA6B,GAAG,SAAS,EAAE,CAO1G"}

package/dist/booksy/import-tools.js

@@ -0,0 +1,413 @@
+import { toToolError } from "../errors.js";
+import { ArgumentError, readBoolean, readOptionalNumber, readOptionalString, readOptionalStringArray, readString } from "../tools/args.js";
+import { writeGate } from "../tools/write-gate.js";
+import { err, ok } from "../types.js";
+import { BooksyReadError, normalizeBooksyUrl } from "./fetch-page.js";
+import { BooksyProfileReader, URL_FIELD, createBooksyReaderTools, degradedSuffix, } from "./tools.js";
+/** Writes at a time. Enough to bring a 60-service catalogue down from minutes to well under one;
+ * low enough that a canister short on cycles still has room for every call in flight. */
+const WRITE_CONCURRENCY = 4;
+/**
+ * The write half of "copy my salon from Booksy": the whole service catalogue under ONE
+ * confirmation. The model never carries sixty services through its context — it names the profile,
+ * the tool reads it again on its own, and the owner confirms the list the tool showed her.
+ */
+export function createBooksyImportTools(port, options = {}) {
+    const reader = options.reader ?? new BooksyProfileReader();
+    return [importServicesTool(port, reader, options.confirmations), importWorkersTool(port, reader)];
+}
+/** The whole Booksy set for ONE salon — the read tools and the import — over one shared reader.
+ * A host adds it next to `createSalonTools`; the port is the same one. */
+export function createBooksyTools(port, options = {}) {
+    const reader = options.reader ?? new BooksyProfileReader(options.fetchFn);
+    return [
+        ...createBooksyReaderTools({ ...options, reader }),
+        ...createBooksyImportTools(port, { reader, confirmations: options.confirmations }),
+    ];
+}
+function importServicesTool(port, reader, confirmations) {
+    const gate = writeGate("import_booksy_services", confirmations);
+    return {
+        name: "import_booksy_services",
+        progress: "Kopiuję usługi z Booksy…",
+        description: "Kopiuje usługi z publicznego profilu Booksy do katalogu tego salonu — wszystkie naraz, pod JEDNYM potwierdzeniem. Narzędzie samo czyta profil, dobiera typy usług z katalogu Sultana i przypisuje pracowników po imieniu; usługi, które salon już ma pod tą samą nazwą, pomija. Usługi, której typu nie dobrało, NIE kopiuje (Sultana wymaga typu) — wypisuje ją, a Ty dobierasz typ przez find_service_type i podajesz w overrides. Przy confirmed=false niczego nie zapisuje i oddaje pełną listę do pokazania właścicielce — pokaż ją CAŁĄ. Poprawki właścicielki („pomiń X”, „X to inny typ”) podaj w overrides i pokaż nowy podgląd.",
+        parameters: gate.parameters({
+            type: "object",
+            properties: {
+                url: URL_FIELD,
+                category: { type: "string", description: "Opcjonalnie: tylko usługi z tej kategorii Booksy (fragment nazwy)." },
+                overrides: {
+                    type: "array",
+                    description: "Poprawki do planu, po nazwie usługi z podglądu.",
+                    items: {
+                        type: "object",
+                        properties: {
+                            name: { type: "string", description: "Dokładna nazwa usługi z podglądu." },
+                            skip: { type: "boolean", description: "true — nie kopiuj tej usługi." },
+                            serviceTypeIds: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Id typów usług z find_service_type — zamiast dobranych automatycznie.",
+                            },
+                        },
+                        required: ["name"],
+                        additionalProperties: false,
+                    },
+                },
+                expectedCount: {
+                    type: "number",
+                    description: "Liczba usług z podglądu. Narzędzie odmówi, gdy profil zmienił się od podglądu.",
+                },
+                confirmed: {
+                    type: "boolean",
+                    description: "false dla podglądu: narzędzie nic nie zapisze i odda listę usług do zatwierdzenia przez właścicielkę. true dopiero po tym, jak właścicielka potwierdzi.",
+                },
+            },
+            required: ["url", "confirmed"],
+            additionalProperties: false,
+        }),
+        execute: async (args) => {
+            try {
+                const url = normalizeBooksyUrl(readString(args, "url"));
+                const category = readOptionalString(args, "category");
+                const overrides = readOverrides(args);
+                const draft = await reader.read(url);
+                const plan = await buildPlan(port, draft.services, category, overrides);
+                // The count ties the confirmation to the list the owner saw: the ledger compares
+                // arguments, and a profile edited between the two calls would otherwise slip through.
+                const expectedCount = readOptionalNumber(args, "expectedCount") ?? plan.toAdd.length;
+                const echo = compact({ url, category, overrides: overrides.length > 0 ? echoOverrides(overrides) : undefined, expectedCount });
+                const refusal = gate.refusal(args, echo);
+                if (refusal)
+                    return refusal;
+                if (expectedCount !== plan.toAdd.length) {
+                    return err("invalid_arguments", `Plan ma teraz ${plan.toAdd.length} usług, a podgląd miał ${expectedCount} — profil albo katalog salonu zmienił się. Pokaż nowy podgląd (confirmed=false, bez expectedCount).`);
+                }
+                if (plan.toAdd.length === 0)
+                    return ok(`Nie ma nic do skopiowania.${describeLeftOut(plan)}`, { added: 0 });
+                if (!readBoolean(args, "confirmed")) {
+                    return gate.preview(`${describePlan(plan)}${degradedSuffix(draft)}`, echo);
+                }
+                const refused = gate.redeem(args, echo);
+                if (refused)
+                    return refused;
+                return await writePlan(port, plan);
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                if (error instanceof BooksyReadError)
+                    return err(error.code, error.summary);
+                return toToolError(error, "Nie udało się skopiować usług z Booksy.");
+            }
+        },
+    };
+}
+/**
+ * A placeholder with a purpose. Without it a model asked to "copy my team" looks for the nearest
+ * tool and makes up a reason why it cannot — with it, the owner hears the truth: the team is
+ * readable, the write is not built yet, and here is what to do meanwhile. It writes nothing, so it
+ * asks for no confirmation.
+ */
+function importWorkersTool(port, reader) {
+    return {
+        name: "import_booksy_workers",
+        progress: "Sprawdzam zespół na Booksy…",
+        description: "Kopiowanie pracowników z Booksy do salonu. TEJ FUNKCJI JESZCZE NIE MA — narzędzie niczego nie zapisuje. Wywołaj je, gdy właścicielka prosi o skopiowanie zespołu: odda listę osób z profilu Booksy, powie, kogo brakuje w Sultana, i co zrobić teraz. Przekaż właścicielce wprost, że kopiowanie pracowników nie jest jeszcze dostępne.",
+        parameters: { type: "object", properties: { url: URL_FIELD }, required: ["url"], additionalProperties: false },
+        execute: async (args) => {
+            try {
+                const draft = await reader.read(normalizeBooksyUrl(readString(args, "url")));
+                const team = await port.listWorkers();
+                const onBooksy = draft.workers.map((worker) => worker.name);
+                const missing = matchWorkers(onBooksy, team).missing;
+                const parts = ["Kopiowanie pracowników z Booksy nie jest jeszcze dostępne — niczego nie zapisałem."];
+                if (onBooksy.length === 0)
+                    parts.push("Profil Booksy nie pokazuje zespołu.");
+                else
+                    parts.push(`Na Booksy są: ${onBooksy.join(", ")}.`);
+                if (missing.length > 0) {
+                    parts.push(`W zespole Sultana brakuje: ${missing.join(", ")}. Na razie dodaj te osoby w panelu salonu (zakładka zespołu), a potem przypisz je do usług przez update_service.`);
+                }
+                else if (onBooksy.length > 0)
+                    parts.push("Wszystkie te osoby są już w zespole Sultana.");
+                return ok(parts.join(" "), { supported: false, onBooksy, missingInSultana: missing });
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                if (error instanceof BooksyReadError)
+                    return err(error.code, error.summary);
+                return toToolError(error, "Nie udało się sprawdzić zespołu.");
+            }
+        },
+    };
+}
+// --- the plan ----------------------------------------------------------------------------------
+async function buildPlan(port, drafts, category, overrides) {
+    const [current, workers, catalog] = await Promise.all([port.listServices(), port.listWorkers(), port.findServiceTypes("")]);
+    const taken = new Set(current.map((service) => fold(service.name)));
+    const labels = new Map(catalog.map((type) => [type.id, type.label]));
+    const overrideByName = new Map(overrides.map((override) => [fold(override.name), override]));
+    const matcher = new ServiceTypeMatcher(port);
+    const plan = { toAdd: [], existing: [], skipped: [], remarks: [], untyped: [], missingWorkers: [] };
+    const inCategory = category ? drafts.filter((draft) => fold(draft.booksyCategory).includes(fold(category))) : drafts;
+    const wanted = mergeRepeatedServices(inCategory, plan.remarks);
+    const unknownOverrides = overrides.filter((override) => !wanted.some((draft) => fold(draft.name) === fold(override.name)));
+    if (unknownOverrides.length > 0) {
+        throw new ArgumentError(`W overrides są nazwy, których nie ma w profilu: ${unknownOverrides.map((override) => `„${override.name}”`).join(", ")}. Użyj dokładnych nazw z podglądu.`);
+    }
+    for (const draft of wanted) {
+        const override = overrideByName.get(fold(draft.name));
+        if (override?.skip) {
+            plan.skipped.push(`„${draft.name}” — pominięta na życzenie`);
+            continue;
+        }
+        if (taken.has(fold(draft.name))) {
+            plan.existing.push(draft.name);
+            continue;
+        }
+        if (draft.durationMinutes === null) {
+            plan.skipped.push(`„${draft.name}” — Booksy nie podaje czasu trwania; dodaj ją przez add_service`);
+            continue;
+        }
+        const notes = [...draft.notes];
+        const serviceTypeIds = override?.serviceTypeIds ?? (await matcher.match(draft));
+        const unknownTypes = serviceTypeIds.filter((id) => !labels.has(id));
+        if (unknownTypes.length > 0) {
+            throw new ArgumentError(`Nieznane typy usług: ${unknownTypes.join(", ")}. Użyj find_service_type i podaj id z katalogu.`);
+        }
+        if (serviceTypeIds.length === 0) {
+            plan.untyped.push(draft.name);
+            continue;
+        }
+        // Two variants with one label would collide in the salon just as they would on a list.
+        taken.add(fold(draft.name));
+        // A missing person repeats down the whole list — said once, under it, not on every line.
+        const assigned = matchWorkers(draft.workerNames, workers);
+        for (const name of assigned.missing)
+            if (!plan.missingWorkers.includes(name))
+                plan.missingWorkers.push(name);
+        plan.toAdd.push({
+            input: {
+                name: draft.name,
+                pricePln: draft.pricePln,
+                durationMinutes: draft.durationMinutes,
+                active: true,
+                serviceTypeIds,
+                workerIds: assigned.found.map((worker) => worker.id),
+            },
+            category: draft.booksyCategory,
+            typeLabels: serviceTypeIds.map((id) => labels.get(id) ?? id),
+            workerNames: assigned.found.map((worker) => worker.name),
+            notes,
+        });
+    }
+    return plan;
+}
+/** A whole name found in the catalogue outweighs any single word. */
+const PHRASE_SCORE = 3;
+/** The Booksy category is a weaker hint than the service's own name. */
+const CATEGORY_WORD_SCORE = 0.75;
+/**
+ * Booksy has no "who does it" on a shared service, so a salon lists the same service once per
+ * person ("Zdejmowanie rzęs" under Oksana's category and again under Ilona's). Sultana's service
+ * holds its people, so the repeats fold into one — when price and time agree. When they do not,
+ * they are different services, and the later one takes its Booksy category into its name.
+ */
+function mergeRepeatedServices(drafts, remarks) {
+    const merged = [];
+    for (const draft of drafts) {
+        const twin = merged.find((earlier) => fold(earlier.name) === fold(draft.name));
+        if (!twin) {
+            merged.push({ ...draft, workerNames: [...draft.workerNames], notes: [...draft.notes] });
+        }
+        else if (twin.pricePln === draft.pricePln && twin.durationMinutes === draft.durationMinutes) {
+            for (const name of draft.workerNames)
+                if (!twin.workerNames.includes(name))
+                    twin.workerNames.push(name);
+            remarks.push(`„${draft.name}” jest na Booksy kilka razy z tą samą ceną i czasem — łączę w jedną usługę`);
+        }
+        else {
+            const renamed = `${draft.name} (${draft.booksyCategory || "wariant"})`;
+            remarks.push(`„${draft.name}” jest na Booksy kilka razy z różną ceną albo czasem — drugą nazywam „${renamed}”`);
+            merged.push({ ...draft, name: renamed, workerNames: [...draft.workerNames], notes: [...draft.notes] });
+        }
+    }
+    return merged;
+}
+/**
+ * Picks a service type with the catalogue's own search (`findServiceTypes` — the matcher both
+ * frontends use, synonyms included). Every type collects points: for the whole name, for each word
+ * of the name — the earlier the word, the more, because a Polish service name leads with what it
+ * is ("Pedicure męski" is a pedicure, not something for men) — and for the words of the Booksy
+ * category. The best score wins; a tie goes to the catalogue's order.
+ *
+ * A type is a candidate only when something that says what the service IS points at it: the whole
+ * name, the name's first word, or the Booksy category. A later word alone is an adjective — in a
+ * catalogue without pedicures, "Pedicure męski" must get no type rather than "Strzyżenie męskie".
+ * It is still a guess — the preview shows it, and `overrides` corrects it.
+ */
+class ServiceTypeMatcher {
+    port;
+    hits = new Map();
+    constructor(port) {
+        this.port = port;
+    }
+    async match(draft) {
+        const scores = new Map();
+        const anchored = new Set();
+        const credit = async (query, points, anchors) => {
+            for (const type of await this.search(query)) {
+                scores.set(type.id, (scores.get(type.id) ?? 0) + points);
+                if (anchors)
+                    anchored.add(type.id);
+            }
+        };
+        await credit(draft.booksyService, PHRASE_SCORE, true);
+        if (draft.name !== draft.booksyService)
+            await credit(draft.name, PHRASE_SCORE, true);
+        const nameWords = [...new Set(words(draft.name))];
+        for (const [position, word] of nameWords.entries())
+            await credit(word, 2 / (1 + position), position === 0);
+        for (const word of new Set(words(draft.booksyCategory)))
+            await credit(word, CATEGORY_WORD_SCORE, true);
+        let best = null;
+        let bestScore = 0;
+        // A Map keeps insertion order, and the first credited query lists types in catalogue
+        // order — so ">" alone leaves a tie with the earlier type.
+        for (const [id, score] of scores) {
+            if (anchored.has(id) && score > bestScore) {
+                best = id;
+                bestScore = score;
+            }
+        }
+        return best === null ? [] : [best];
+    }
+    search(query) {
+        const key = fold(query);
+        let hits = this.hits.get(key);
+        if (!hits) {
+            hits = this.port.findServiceTypes(query);
+            this.hits.set(key, hits);
+        }
+        return hits;
+    }
+}
+/** Booksy shows "Ciarkowska Magdalena", Sultana may hold "Magdalena" — any shared word is a match,
+ * as long as it points at exactly one person. */
+function matchWorkers(names, workers) {
+    const found = [];
+    const missing = [];
+    for (const name of names) {
+        const parts = new Set(fold(name).split(" "));
+        const candidates = workers.filter((worker) => fold(worker.name).split(" ").some((part) => parts.has(part)));
+        if (candidates.length === 1) {
+            if (!found.includes(candidates[0]))
+                found.push(candidates[0]);
+        }
+        else
+            missing.push(name);
+    }
+    return { found, missing };
+}
+// --- the write ---------------------------------------------------------------------------------
+async function writePlan(port, plan) {
+    const added = [];
+    let failure = null;
+    for (let at = 0; at < plan.toAdd.length && failure === null; at += WRITE_CONCURRENCY) {
+        const batch = plan.toAdd.slice(at, at + WRITE_CONCURRENCY);
+        const results = await Promise.allSettled(batch.map((service) => port.addService(service.input)));
+        for (const [index, result] of results.entries()) {
+            if (result.status === "fulfilled")
+                added.push(batch[index].input.name);
+            // A spent quota or a dead connection will not get better on the next batch — stop, and
+            // say how far it got. Running the import again picks up where this one ended.
+            else
+                failure ??= toToolError(result.reason, "Kanister odrzucił zapis usługi.");
+        }
+    }
+    if (failure === null)
+        return ok(`Skopiowano ${added.length} usług z Booksy.${describeLeftOut(plan)}`, { added: added.length });
+    const left = plan.toAdd.length - added.length;
+    const reason = failure.summary;
+    if (added.length === 0)
+        return { ...failure, summary: `Nie skopiowano żadnej usługi. ${reason}` };
+    return ok(`Skopiowano ${added.length} z ${plan.toAdd.length} usług, potem zapis się nie udał: ${reason} Zostało ${left}. Ponowny import (nowy podgląd i zgoda) pominie to, co już jest w salonie.`, { added: added.length, remaining: left });
+}
+// --- texts -------------------------------------------------------------------------------------
+function describePlan(plan) {
+    const lines = [`Skopiuję z Booksy ${plan.toAdd.length} usług:`];
+    let category = null;
+    for (const service of plan.toAdd) {
+        if (service.category !== category) {
+            category = service.category;
+            lines.push(`[${category || "bez kategorii"}]`);
+        }
+        const type = service.typeLabels.join(", ");
+        const people = service.workerNames.length > 0 ? `; ${service.workerNames.join(", ")}` : "";
+        const notes = service.notes.length > 0 ? ` (uwaga: ${service.notes.join("; ")})` : "";
+        lines.push(`- ${service.input.name} — ${service.input.pricePln} zł, ${service.input.durationMinutes} min; typ: ${type}${people}${notes}`);
+    }
+    return `${lines.join("\n")}${describeLeftOut(plan)}`;
+}
+function describeLeftOut(plan) {
+    const parts = [];
+    if (plan.untyped.length > 0) {
+        parts.push(`NIE skopiuję ${plan.untyped.length} usług, bo nie dobrałem im typu, a Sultana wymaga typu: ${plan.untyped.map((name) => `„${name}”`).join(", ")}. Dobierz typy przez find_service_type i podaj je w overrides (name + serviceTypeIds), potem pokaż nowy podgląd.`);
+    }
+    if (plan.missingWorkers.length > 0) {
+        parts.push(`Osoby z Booksy, których nie ma w zespole Sultana: ${plan.missingWorkers.join(", ")} — ich usługi zostaną bez przypisanej osoby.`);
+    }
+    if (plan.remarks.length > 0)
+        parts.push(`${[...new Set(plan.remarks)].join("; ")}.`);
+    if (plan.existing.length > 0)
+        parts.push(`Już są w salonie (pomijam): ${plan.existing.length}.`);
+    if (plan.skipped.length > 0)
+        parts.push(`Nie kopiuję: ${plan.skipped.join("; ")}.`);
+    return parts.length === 0 ? "" : `\n${parts.join(" ")}`;
+}
+// --- arguments ---------------------------------------------------------------------------------
+function readOverrides(args) {
+    const raw = args.overrides;
+    if (raw === undefined || raw === null)
+        return [];
+    if (!Array.isArray(raw))
+        throw new ArgumentError('Pole "overrides" musi być listą.');
+    return raw.map((entry) => {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+            throw new ArgumentError('Każda pozycja "overrides" musi być obiektem z polem name.');
+        }
+        const override = entry;
+        return {
+            name: readString(override, "name"),
+            skip: readBoolean(override, "skip"),
+            serviceTypeIds: readOptionalStringArray(override, "serviceTypeIds"),
+        };
+    });
+}
+/** Overrides in one canonical form, so resending the model's own arguments and resending the echo
+ * confirm the same change. */
+function echoOverrides(overrides) {
+    return overrides.map((override) => compact({ name: override.name, skip: override.skip || undefined, serviceTypeIds: override.serviceTypeIds }));
+}
+function compact(record) {
+    return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+/** The words worth searching for. Diacritics stay — folding them is the catalogue search's job. */
+function words(text) {
+    return text
+        .toLowerCase()
+        .split(/[^\p{L}\p{N}]+/u)
+        .filter((word) => word.length >= 4);
+}
+/** Case, diacritics and spacing do not make two names different. */
+function fold(text) {
+    return text
+        .toLowerCase()
+        .replace(/ł/g, "l")
+        .normalize("NFD")
+        .replace(/[̀-ͯ]/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}

package/dist/booksy/nuxt-payload.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A Booksy profile is a Nuxt page, and Nuxt ships its state as a `devalue` payload: one flat JSON
+ * array in which every object value and every array element is an INDEX into that same array.
+ * Only the entries themselves hold literal values.
+ *
+ * This is the reader for that format — small on purpose, so the package takes no dependency for
+ * a single page type.
+ */
+/** The raw payload array of a Nuxt page, or `null` when the page has none. */
+export declare function extractNuxtPayload(html: string): unknown[] | null;
+/** The index of the first plain object in the payload that has every one of `keys`. */
+export declare function findPayloadObject(payload: unknown[], keys: string[]): number;
+/** Resolves the entry at `index` into a plain value — references followed, wrappers unwrapped. */
+export declare function hydratePayload(payload: unknown[], index: number): unknown;
+//# sourceMappingURL=nuxt-payload.d.ts.map