@wix/himalaya-cli 0.1030.0 → 0.1032.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/dev-server/src/app-config.d.ts

@@ -174,6 +174,13 @@ export interface DevGatewayConfig {
         url: string;
         integrity: string;
     };
+    /** What the DEV-SERVER gateway does in `mock` mode with a call no rule matches:
+     *  `passthrough` (default) forwards it to the real host; `fail` answers a deterministic
+     *  `404 HIMI_HERMETIC_NO_FIXTURE` and sends nothing upstream (#3019). Honoured by the
+     *  dev-server's `/v1/__webwix/call` bridge (web host) and `/__dev/{wix,net}/proxy`
+     *  (native redirect). On-device `NetFake` does not read it yet — an unmatched call there
+     *  still falls through to the real capability. */
+    unmatched?: "passthrough" | "fail";
 }
 /** Derive the OTA authConfig block from a defineApp auth block
  *  ({ providerId, config }). `required` is read from `config.required === true`

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/dev-server/src/wix-gateway.d.ts

@@ -1,9 +1,22 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { WixGatewayMode, WixMockRule, WixTrafficEvent } from "./wix-gateway.rules.js";
 export * from "./wix-gateway.rules.js";
+/** What `mock` mode does with a call NO rule matches.
+ *
+ *  `passthrough` (the default, and the only behaviour before #3019) forwards it to the real
+ *  host and records the answer — fine for a partial fixture over a live site. `fail` is a
+ *  SEALED data plane: the call is answered with a deterministic `404`
+ *  (`HIMI_HERMETIC_NO_FIXTURE`, see `hermeticRefusal`) and recorded, and nothing is sent
+ *  upstream — not the call, not a visitor-token mint. A hermetic app scenario declares it
+ *  (`devGateway.unmatched`), because "mock mode" alone never meant fail-closed on any
+ *  surface, however many comments said so. Only meaningful in `mock` mode; `record` always
+ *  forwards. */
+export type WixGatewayUnmatched = "passthrough" | "fail";
 export interface WixGatewayState {
     mode: WixGatewayMode;
     rules: WixMockRule[];
+    /** See `WixGatewayUnmatched`. Absent ⇒ `passthrough`. */
+    unmatched?: WixGatewayUnmatched;
     /** An OPERATOR replaced the rules or the mode through `/__dev/{wix,net}/*`.
      *
      *  Read by the date-rollover re-seed (net-mocks-rollover.ts), which must not
@@ -28,7 +41,25 @@ export declare function createWixGatewayState(): WixGatewayState;
 export interface NetMocksFile {
     mode?: WixGatewayMode;
     rules?: WixMockRule[];
+    /** See `WixGatewayUnmatched`. Absent ⇒ `passthrough`. */
+    unmatched?: WixGatewayUnmatched;
 }
+/** The mock-rule id a fail-closed refusal is logged under, so `/__dev/net/log` tells a
+ *  sealed miss apart from a fixture that answered 404 on purpose. */
+export declare const UNMATCHED_FAIL_CLOSED_ID = "unmatched:fail-closed";
+/** True when `mock` mode must refuse a call no rule matched instead of forwarding it. */
+export declare function failsClosed(gw: Pick<WixGatewayState, "mode" | "unmatched">): boolean;
+/** The deterministic answer to an unmatched call on a sealed gateway.
+ *
+ *  404, not 403/503: a 5xx reads as an outage the owner workers downgrade to labelled demo
+ *  data (`isBridgeUnavailable` matches 405/501/502/503), which would put a THIRD data source
+ *  on the screen — the mixing #3019 is about. The body is a Wix-shaped error envelope that
+ *  names the call, so the developer who sees it knows which fixture to add. */
+export declare function hermeticRefusal(method: string, path: string): {
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+};
 /** Apply a net-mocks fixture to the gateway state — assigns rule ids, installs
  *  the rule set, and sets the mode (defaults to "mock" when the fixture has rules
  *  and no explicit mode, so a checked-in file serves without extra setup). The
@@ -56,6 +87,7 @@ export declare function applyNetMocks(gw: WixGatewayState, mocks: NetMocksFile):
 export declare function resolveNetMocks(fileMocks: NetMocksFile | null, appDeclared?: {
     mode?: WixGatewayMode;
     rules?: unknown;
+    unmatched?: WixGatewayUnmatched;
 }): {
     mocks: NetMocksFile;
     source: "file" | "app";

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/dev-server/src/wix-gateway.rules.d.ts

@@ -20,7 +20,8 @@ export interface WixTrafficEvent {
     reqBody?: string;
     respHeaders?: Record<string, string>;
     respBody?: string;
-    mockRuleId?: number;
+    /** The rule that answered. Rule ids are author-chosen strings or auto-assigned numbers. */
+    mockRuleId?: number | string;
 }
 /** A response transform (record-proxy then patch the REAL upstream response).
  *  `mergeJson` deep-merges into a JSON body; `replaceBody` replaces it wholesale;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/ts/src/define-app.d.ts

@@ -986,6 +986,13 @@ export interface DevGatewayConfig {
         url: string;
         integrity: string;
     };
+    /** What the DEV-SERVER gateway does in `mock` mode with a call no rule matches:
+     *  `passthrough` (default) forwards it to the real host; `fail` answers a deterministic
+     *  `404 HIMI_HERMETIC_NO_FIXTURE` and sends nothing upstream (#3019). Honoured by the
+     *  dev-server's `/v1/__webwix/call` bridge (web host) and `/__dev/{wix,net}/proxy`
+     *  (native redirect). On-device `NetFake` does not read it yet — an unmatched call there
+     *  still falls through to the real capability. */
+    unmatched?: "passthrough" | "fail";
 }
 export declare function defineApp(config: AppConfig): AppConfig;
 export declare function defineApp(config: FunctionsAppConfig): FunctionsAppConfig;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/genie-chat/src/index.d.ts

@@ -51,9 +51,40 @@ export interface ConversationMessage {
     role?: MessageRole;
     createdDate?: string;
     status?: MessageStatus;
+    /** Files the owner attached to this turn, as the service stored them. */
+    attachments?: Attachment[];
     /** Client tools this assistant turn asks the CALLER to run — see `FunctionCall`. */
     functionCalls?: FunctionCall[];
 }
+/** A file on a message — the service's `Attachment` entity.
+ *
+ *  `url` is the service's own REFERENCE to an uploaded file
+ *  (`genie-upload://<id>`, see `genieUploadRef`), not a fetchable address: no
+ *  route that resolves it to a download url is published, so a client can name a
+ *  sent attachment but not show it again from the server's copy. `viewUrl` is
+ *  whatever preview the SENDING client chose to store, and is not trusted to
+ *  resolve anywhere else. */
+export interface Attachment {
+    /** Original file name including extension. The service caps it at 255. */
+    fileName: string;
+    /** e.g. `"image/jpeg"`. The service caps it at 100. */
+    mimeType: string;
+    url?: string;
+    viewUrl?: string;
+}
+/** The mint of an upload: where to send the bytes, and the record's id. */
+export interface CreateFileUploadResponse {
+    upload?: {
+        uploadUrl?: string;
+        id?: string;
+    };
+}
+export interface CreateFileUploadOptions {
+    /** The same client-declared scoping flag every other chat-service request
+     *  takes. Omitted unless given — the dashboard sends it only when its own
+     *  account-scoping gate is on. */
+    enforceAccountScopedConversations?: boolean;
+}
 /** A client-side tool the assistant wants the caller to run before it can go on
  *  — asking the owner for consent, say. It arrives on the `/user-message`
  *  response and the agent then WAITS: nothing more is written until the result
@@ -169,6 +200,9 @@ export interface SendMessageOptions {
     enforceAccountScopedConversations?: boolean;
     /** Tag the turn with the same origin the conversation was created under. */
     origin?: string;
+    /** Files already UPLOADED (see `createFileUpload`) to store with the turn.
+     *  Rides step 1 only — the trigger names the stored turn, which carries them. */
+    attachments?: Attachment[];
 }
 export interface ConversationUserMessageResponse {
     userMessage?: ConversationMessage;
@@ -232,6 +266,32 @@ export declare function sendFunctionCallResults(conversationId: string, results:
  *  transcript. Rejecting means the turn is still running: treat it as "could
  *  not stop", never as "stopped". */
 export declare function abortAssistantMessageGeneration(userMessageId: string): Promise<AbortAssistantMessageGenerationResponse>;
+/** Mint an upload for one file: a pre-signed url to send its bytes to, and the
+ *  id the message will reference it by (`genieUploadRef`).
+ *
+ *  Only the MINT goes through the chat-service; the bytes go straight to
+ *  `upload.uploadUrl` (see the file header). Resolving is not proof the file
+ *  exists — nothing is stored until those bytes land, so a caller must not
+ *  attach the reference before its upload has succeeded. */
+export declare function createFileUpload(fileName: string, mimeType: string, opts?: CreateFileUploadOptions): Promise<CreateFileUploadResponse>;
+/** The scheme every first-party creator uses to reference an uploaded file from
+ *  a message attachment. */
+export declare const GENIE_UPLOAD_SCHEME = "genie-upload://";
+/** `genie-upload://<id>`, or "" for no id — never a reference to nothing. */
+export declare function genieUploadRef(id: string | undefined): string;
+/** Where the bytes actually go: `uploadUrl` with `path` and `acl=private` set.
+ *
+ *  Mirrors the Media Platform browser uploader every first-party client relies
+ *  on. The service rewrites the storage key itself, so `path` is advisory; it is
+ *  sent anyway, for parity with the clients whose uploads are known to work.
+ *
+ *  String surgery rather than `new URL`, because the worker runtimes (JSContext,
+ *  Hermes, QuickJS) do not all ship the URL constructor — and MERGED rather than
+ *  appended, because the signed url may already carry a query, and a second `?`
+ *  would corrupt the signature it carries. An existing `path` / `acl` is
+ *  replaced rather than duplicated; everything else, the fragment included, is
+ *  kept byte for byte. */
+export declare function uploadTargetUrl(uploadUrl: string, fileName: string): string;
 /** Fetch the messages of a conversation (poll after sendMessage). */
 export declare function getConversationMessages(conversationId: string): Promise<GetConversationMessagesResponse>;
 /** The transcript from a getConversationMessages response, under either key. */
@@ -253,6 +313,10 @@ export declare function conversationIdOf(res: CreateConversationResponse | null
 /** A message's text. `content` is normally a string, but can arrive as an object
  *  carrying `text`; anything else is stringified rather than dropped. */
 export declare function messageText(m: ConversationMessage | null | undefined): string;
+/** A message's attachments that name a file, in order. Anything that is not an
+ *  object with a non-empty `fileName` is dropped rather than rendered as a blank
+ *  entry — the list is display-only, so a malformed row has nothing to show. */
+export declare function attachmentsOf(m: ConversationMessage | null | undefined): Attachment[];
 /** The last ASSISTANT message in a transcript, or undefined. The "has the reply
  *  landed?" predicate every poller needs. */
 export declare function lastAssistantMessage(msgs: ConversationMessage[]): ConversationMessage | undefined;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/wix-genie-chat.mjs

@@ -36,7 +36,7 @@ function getConversations(origin) {
 function conversationUserMessage(conversationId, content, opts = {}) {
   if (!conversationId) throw new Error("conversationUserMessage: conversationId is required");
   return wixCall("POST", `${BASE}/conversation-user-message`, {
-    attachments: [],
+    attachments: opts.attachments ?? [],
     messageReferences: [],
     userMessageContent: content,
     origin: opts.origin ?? ARIA_ORIGIN,
@@ -113,6 +113,36 @@ function abortAssistantMessageGeneration(userMessageId) {
   if (!userMessageId) throw new Error("abortAssistantMessageGeneration: userMessageId is required");
   return wixCall("POST", `${BASE}/abort-assistant-message-generation`, { userMessageId });
 }
+function createFileUpload(fileName, mimeType, opts = {}) {
+  if (!fileName) throw new Error("createFileUpload: fileName is required");
+  return wixCall("POST", `${BASE}/files/create-upload`, {
+    fileName,
+    mimeType,
+    ...opts.enforceAccountScopedConversations === void 0 ? {} : { enforceAccountScopedConversations: opts.enforceAccountScopedConversations }
+  });
+}
+var GENIE_UPLOAD_SCHEME = "genie-upload://";
+function genieUploadRef(id) {
+  const v = (id ?? "").trim();
+  return v ? `${GENIE_UPLOAD_SCHEME}${v}` : "";
+}
+function uploadTargetUrl(uploadUrl, fileName) {
+  const raw = (uploadUrl ?? "").trim();
+  if (!raw) return "";
+  const hashAt = raw.indexOf("#");
+  const fragment = hashAt >= 0 ? raw.slice(hashAt) : "";
+  const noFragment = hashAt >= 0 ? raw.slice(0, hashAt) : raw;
+  const qAt = noFragment.indexOf("?");
+  const base = qAt >= 0 ? noFragment.slice(0, qAt) : noFragment;
+  const kept = (qAt >= 0 ? noFragment.slice(qAt + 1) : "").split("&").filter((pair) => {
+    if (!pair) return false;
+    const key = pair.split("=")[0];
+    return key !== "path" && key !== "acl";
+  });
+  const path = `/${(fileName ?? "").replace(/^\/+/, "")}`;
+  kept.push(`path=${encodeURIComponent(path)}`, "acl=private");
+  return `${base}?${kept.join("&")}${fragment}`;
+}
 function getConversationMessages(conversationId) {
   if (!conversationId) throw new Error("getConversationMessages: conversationId is required");
   return wixCall("GET", `${BASE}/conversation-messages?conversationId=${encodeURIComponent(conversationId)}`);
@@ -145,6 +175,11 @@ function messageText(m) {
   }
   return "";
 }
+function attachmentsOf(m) {
+  const raw = m?.attachments;
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((a) => !!a && typeof a === "object" && typeof a.fileName === "string" && !!a.fileName.trim());
+}
 function lastAssistantMessage(msgs) {
   for (let i = msgs.length - 1; i >= 0; i--) {
     if (msgs[i]?.role === "ASSISTANT") return msgs[i];
@@ -154,13 +189,17 @@ function lastAssistantMessage(msgs) {
 export {
   ARIA_ORIGIN,
   ARIA_UNIFIED_ASSISTANT_ID,
+  GENIE_UPLOAD_SCHEME,
   abortAssistantMessageGeneration,
   ariaAssistantConfig,
+  attachmentsOf,
   conversationIdOf,
   conversationUserMessage,
   createConversation,
+  createFileUpload,
   functionCallsOf,
   genieChatError,
+  genieUploadRef,
   getConversationMessages,
   getConversations,
   isGenieChatError,
@@ -170,6 +209,7 @@ export {
   sendFunctionCallResults,
   sendMessage,
   triggerAssistantMessage,
+  uploadTargetUrl,
   userMessageIdOf,
   wixCall
 };