@wix/himalaya-cli 0.970.0 → 0.971.0

package/templates/restaurant-owner/tier5-src/_shared/aria-chat.ts

@@ -89,6 +89,19 @@ export interface AriaChatState {
   error: string;
   /** Bound seed for the composer field. */
   input: string;
+  /** Transient result of the last Copy: the confirmation, or the failure.
+   *
+   *  It exists because `writeText` resolves or throws and NOTHING else in the
+   *  state changes either way — so without this the owner cannot tell a copy
+   *  that took from one the platform refused. Saying "Copied" when nothing
+   *  reached the clipboard is a known way for a copy control to lie; this is
+   *  the field that makes the difference observable. */
+  copyNote: string;
+  /** Collapses the Copy / Regenerate row. Derived, like `stopHidden`: shown
+   *  only when the newest bubble is a REPLY (not the owner's message, not the
+   *  local greeting) and no turn is out. A pure function of other fields, so it
+   *  is computed once in `gated` rather than maintained by every reducer. */
+  replyActionsHidden: boolean;
   messages: AriaBubble[];
   /** Non-empty ONLY on the greeting-only empty state. */
   prompts: AriaPromptChip[];
@@ -199,6 +212,12 @@ export interface AriaChatLabels {
   /** Status line after the owner stopped a reply. Sits in the NEUTRAL slot:
    *  they asked for it, so nothing went wrong. */
   stopped?: Resolvable<string>;
+  /** Shown after a clipboard write that RESOLVED. */
+  copied?: Resolvable<string>;
+  /** Shown after a clipboard write that threw, or when the host supplied no
+   *  clipboard at all. Deliberately distinct from `copied`: the point of the
+   *  pair is that the owner can tell which of the two happened. */
+  copyFailed?: Resolvable<string>;
   /** Shown under a picker once the owner has chosen as many options as the
    *  service allows. Takes the limit, because "pick up to 3" is the whole of
    *  the information. */
@@ -242,6 +261,13 @@ export interface AriaChatOptions {
   /** Opens an external URL. Apps whose descriptors carry their own open-url
    *  action (the clone) leave this unset and never invoke `openLink`. */
   openLink?: (url: string) => Promise<boolean>;
+
+  /** Put `text` on the system clipboard. Injected rather than imported so the
+   *  shared core stays free of the SDK, exactly as `openLink` is.
+   *
+   *  It RESOLVES or THROWS — there is no boolean. A host that does not supply
+   *  it has no clipboard, and `copyMessage` says so rather than pretending. */
+  copyText?: (text: string) => Promise<void>;
   /** Maps an Aria action-link URL to an in-app screen. A hit navigates via a
    *  `_nav` directive — the host applies the same linkable-target check an
    *  authored `himi.open` gets — and a miss falls through to `openLink`. */
@@ -573,6 +599,16 @@ export function toBubbles(msgs: ConversationMessage[], assistantName: string, yo
     .filter((b) => b.content && b.content.trim());
 }
 
+/** The reply the Copy / Regenerate row acts on: the LAST bubble, when it is an
+ *  answer. Not "the newest assistant bubble": a widget-only answer leaves no
+ *  bubble, so the transcript then ends on the owner's question, and searching
+ *  back past it would offer the previous turn's answer as if it were this one.
+ *  The greeting is excluded because it is a local bubble, not a reply. */
+function lastReply(s: { messages: AriaBubble[] }): AriaBubble | undefined {
+  const last = s.messages[s.messages.length - 1];
+  return last && last.notUser && last.id !== GREETING_ID ? last : undefined;
+}
+
 /** Chips are visible only before the owner has said anything. */
 function promptsFor(msgs: AriaBubble[], prompts: AriaPromptChip[]): AriaPromptChip[] {
   return msgs.some((b) => b.role === "USER") ? [] : prompts;
@@ -845,6 +881,24 @@ export interface AriaChatCore {
    *  that moved during the abort makes this snapshot stale, and committing it
    *  would end a turn the owner has since started. */
   stop(s: AriaChatState): Promise<AriaChatState | undefined>;
+
+  /** Put one reply's prose on the clipboard. Defaults to the newest assistant
+   *  bubble, which is the only one the descriptor offers the control on.
+   *
+   *  Copies `bubble.content`, which is ALREADY the normalized prose — the
+   *  envelope scan and the markdown stripper both ran on the way in
+   *  (`bubblesFrom`), so the owner gets what they can read rather than the
+   *  wire text. */
+  /** `undefined` when the turn moved on while the write was out — see `stop`. */
+  copyMessage(s: AriaChatState, arg?: AriaActionArg): Promise<AriaChatState | undefined>;
+
+  /** Ask for another answer.
+   *
+   *  NOT a protocol feature: it sends ordinary user text, the same literal the
+   *  native Aria app sends, through the one send path (`send`). Not through
+   *  `submit`: with no argument that reads the COMPOSER, so a regenerate would
+   *  send whatever the owner had half-typed instead of the retry. */
+  regenerate(s: AriaChatState): Promise<AriaChatState>;
   /** Tapping the active widget's primary / secondary footer button.
    *
    *  The url is read from STATE rather than bound into the action's params.
@@ -880,6 +934,10 @@ export interface AriaChatCore {
 }
 
 const POLL_ID = "aria-turn";
+/** What Regenerate sends. Ordinary user text, matching the native Aria app —
+ *  the chat-service has no retry verb, and inventing one here would be a
+ *  protocol we then had to keep. */
+const REGENERATE_TEXT = "Let's try that again.";
 /** Id of the local greeting bubble. Shared by the minting and the
  *  "is it still the empty state?" test so the two cannot drift apart. */
 const GREETING_ID = "greeting";
@@ -915,7 +973,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
   const localHistory = o.localHistory !== false;
 
   const initialState: AriaChatState = {
-    status: "loading", statusText: "", error: "", input: "",
+    status: "loading", statusText: "", error: "", input: "", copyNote: "", replyActionsHidden: true,
     messages: [], prompts: [], _convId: "", _siteId: "", _pending: "",
     _pendingAfter: 0, _replyAfter: 0, _srvUsers: 0, _srvAssistants: 0,
     _abortId: "", _turnId: "", stopHidden: true, ok: false,
@@ -966,6 +1024,10 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
    *  those. `submitting` stays on the state because the descriptor needs
    *  something to disable a button with; it is the shadow, not the guard. */
   let widgetSending = false;
+  /** A regenerate is on its way. Refuses a double-tap in the window before
+   *  `send` has written `_pending` — the same window `widgetSending` next door
+   *  closes for two taps of one option. */
+  let regenerating = false;
 
   /** A turn the server STORED but never got asked to answer.
    *
@@ -1188,7 +1250,10 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     // state this action RETURNS, so on the `_poll` path they paint immediately.
     const optimistic: AriaBubble[] = [...s.messages, plainBubble(`u${s.messages.length}`, "USER", you(), content)];
     const base: AriaChatState = {
-      ...s, prompts: [], input: "", error: "",
+      // `copyNote: ""` — a Copy confirmation belongs to the moment, and a new
+      // turn ends it. Left in place it would sit under the next reply saying
+      // "Copied" about text the owner copied several turns ago.
+      ...s, prompts: [], input: "", error: "", copyNote: "",
       // The PREVIOUS turn's handles must not survive into this one: aborting by
       // a stale id would abandon a reply that has already been read, and waiting
       // on a stale turn id would look for an answer that already exists. Both
@@ -1410,9 +1475,36 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
    *  function of two other fields, and eight reducers each remembering to set it
    *  is eight chances for the control to be shown when there is nothing to stop
    *  — or, worse, hidden while a reply the owner wants to abandon runs on. */
+  let committed: AriaChatState | null = null;
+  let commits = 0;
+  /** A result as the runtime stores it: the one-shot directives it strips on
+   *  commit (`_stream`, `_nav`, `_poll`, `_error` — see `applyNext` in the web
+   *  host's runtime bootstrap) removed. */
+  const settled = (s: AriaChatState): AriaChatState => {
+    const r = s as AriaChatState & Record<string, unknown>;
+    if (r._stream === undefined && r._nav === undefined && r._poll === undefined && r._error === undefined) return s;
+    const { _stream: _a, _nav: _b, _poll: _c, _error: _d, ...rest } = r;
+    return rest as AriaChatState;
+  };
   const gated = (s: AriaChatState): AriaChatState => {
     const hidden = !(turnInFlight(s) && !!s._abortId);
-    return s.stopHidden === hidden ? s : { ...s, stopHidden: hidden };
+    // The reply actions follow the same rule for the same reason: a derived
+    // flag, recomputed on every action's way out, so no reducer can forget it.
+    // `_pending` rather than `turnInFlight` — see `regenerate` for why `status`
+    // is not trusted to have been cleared.
+    const replyActionsHidden = !(lastReply(s) && !s._pending);
+    const out = s.stopHidden === hidden && s.replyActionsHidden === replyActionsHidden
+      ? s
+      : { ...s, stopHidden: hidden, replyActionsHidden };
+    // Every state the runtime commits passes through here (an `undefined`
+    // result commits nothing and skips it), so this is the newest committed
+    // state — what `copyMessage` puts its note on when other actions landed
+    // while its write was out. Kept as the runtime STORES it, i.e. without the
+    // transient directives it strips on commit: re-returning a `_nav` or a
+    // `_poll` from here would navigate, or re-arm the timer, a second time.
+    committed = settled(out);
+    commits += 1;
+    return out;
   };
 
   /** Ask the service how an async job is getting on.
@@ -1550,7 +1642,10 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
           const raw = messagesOf(gm);
           const bubbles = toBubbles(raw, assistant(), you());
           const resumed = bubbles.length ? bubbles : greetingOnly();
-          return { ...s, status: "ready", _convId: resumeId, _siteId: site, _pending: "", statusText: "", error: "",
+          // `copyNote: ""` — a resumed transcript ends in a reply, so the row is
+          // shown at once; a note carried over would say "Copied" beside an
+          // answer from a different conversation that nobody copied.
+          return { ...s, status: "ready", _convId: resumeId, _siteId: site, _pending: "", statusText: "", error: "", copyNote: "",
             messages: resumed, ...observed(raw, s.widget), prompts: promptsFor(resumed, promptList()) };
         } catch { /* expired or unreachable — fall through to a fresh one */ }
       }
@@ -1649,11 +1744,11 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
         // previous one, which reads as ➕ having done nothing.
         turnSeq += 1;
         return slow({ ...s, status: "ready", _convId: conversationIdOf(res), _siteId: site, input: "", statusText: "", error: "",
-          _pending: "", _abortId: "", _turnId: "", messages: greetingOnly(), ...observed([]), prompts: promptList(), ok: false });
+          _pending: "", _abortId: "", _turnId: "", copyNote: "", messages: greetingOnly(), ...observed([]), prompts: promptList(), ok: false });
       } catch (e) {
         turnSeq += 1;   // see above — a failed create commits state too
         return slow({ ...s, status: "ready", _convId: "", _siteId: site, input: "", ...failureSlots(e, unavailableText),
-          _pending: "", _abortId: "", _turnId: "", messages: greetingOnly(), ...observed([]), prompts: promptList(), ok: false });
+          _pending: "", _abortId: "", _turnId: "", copyNote: "", messages: greetingOnly(), ...observed([]), prompts: promptList(), ok: false });
       }
     },
 
@@ -1972,6 +2067,79 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       return slow(withDraft(
         { ...s, status: "ready", statusText: stoppedText(), error: "", _pending: "", _abortId: "" }, typedAt));
     },
+
+    copyMessage: async (s, arg) => {
+      // Which bubble. The descriptor offers Copy on the newest assistant reply,
+      // so the id is optional and that bubble is the default — but an id IS
+      // accepted, because a row-scoped control passing `$item.id` is the
+      // established shape on this screen (the link rows do exactly that).
+      const wanted = typeof arg === "object" && arg !== null ? String((arg as { id?: string }).id ?? "") : "";
+      const target = wanted
+        ? s.messages.find((m) => m.id === wanted)
+        // The LAST bubble, and only if it is a reply — the same test `gated`
+        // shows the row on. Searching back for the newest reply instead would,
+        // after a widget-only answer (which leaves no bubble), skip over the
+        // owner's question and copy the answer to the turn BEFORE it. The
+        // greeting is excluded because it is a local bubble, not a reply.
+        : lastReply(s);
+      // `content` is ALREADY the prose: `bubblesFrom` scans the widget envelope
+      // out first and then strips markdown, so this is what the owner can read
+      // rather than the wire text.
+      const text = (target?.content ?? "").trim();
+      const failed = () => res(o.labels?.copyFailed ?? "Couldn't copy");
+      if (!text) return { ...s, copyNote: failed() };
+      // No clipboard on this host: say so, rather than report a success that
+      // never happened. Same rule as the throw below.
+      if (!o.copyText) return { ...s, copyNote: failed() };
+      // Read BEFORE the await, compared after: `s` is a pre-await snapshot,
+      // and the runtime commits the whole returned state. Two cases.
+      //  - A send or + moved the turn boundary: the note is about a reply that
+      //    is gone, so stand down and commit nothing (as `stop` does).
+      //  - Anything else landed — a keystroke, a widget selection, a query —
+      //    so `{ ...s }` would silently undo it. Put the note on the newest
+      //    COMMITTED state instead of on the snapshot.
+      const seq = turnSeq;
+      const at = commits;
+      let note: string;
+      try {
+        await o.copyText(text);
+        note = res(o.labels?.copied ?? "Copied");
+      } catch {
+        // The web Async Clipboard API rejects without a user gesture, and
+        // Android refuses while the app is unfocused. Both land here, and both
+        // are a FAILURE the owner is told about.
+        note = failed();
+      }
+      if (turnSeq !== seq) return undefined;
+      // No separate guard for a resume: `load` resumes only when the screen
+      // holds no live conversation, and a Copy row exists only under a reply
+      // in one — so a resume cannot land while a Copy is out. (The nav input
+      // and site are fixed for a worker's life; a site switch boots a new one.)
+      return { ...(commits !== at && committed ? committed : s), copyNote: note };
+    },
+
+    regenerate: async (s) => {
+      // Refuse a double-tap, and refuse while a reply is still coming — there
+      // is nothing to regenerate until the last one has landed.
+      // `_pending` rather than `turnInFlight`, and the difference is load-bearing.
+      // `turnInFlight` is `status === "sending" || !!_pending`, and `status` can
+      // still read "sending" after a turn has actually closed — a tick whose read
+      // straddled a turn boundary returns `undefined` and writes nothing back, so
+      // the status it would have cleared stays put. Measured: with `turnInFlight`
+      // here, the SECOND regenerate of a conversation was refused even though the
+      // first reply had landed. `_pending` is set by `send` and cleared when the
+      // reply arrives, so it tracks "a turn is out" exactly; the latch above
+      // covers the double-tap that `_pending` is too slow for.
+      if (regenerating || !!s._pending) return s;
+      regenerating = true;
+      try {
+        // `send` directly: it is the one send path, and `submit` with no
+        // argument would read the composer instead of sending the retry.
+        return await send(s, REGENERATE_TEXT);
+      } finally {
+        regenerating = false;
+      }
+    },
   };
 
   // Every action's result goes through the Stop gate on its way out.
@@ -1985,6 +2153,8 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     tick: (s) => impl.tick(s).then((r) => (r ? gated(r) : r)),
     openLink: (s, arg) => impl.openLink(s, arg).then(gated),
     stop: (s) => impl.stop(s).then((r) => (r ? gated(r) : r)),
+    copyMessage: (s, arg) => impl.copyMessage(s, arg).then((r) => (r ? gated(r) : r)),
+    regenerate: (s) => impl.regenerate(s).then(gated),
     // Synchronous, like `typing`: a selection edit makes no network call, so
     // gating it is a plain call rather than a `.then`.
     widgetToggle: (s, arg) => gated(impl.widgetToggle(s, arg)),

package/templates/restaurant-owner/tier5-src/himi-owner-lite-aria/index.ts

@@ -23,6 +23,7 @@
 
 import { defineService } from "@himalaya/state";
 import { open } from "@himalaya/open-url";
+import { writeText } from "@himalaya/clipboard";
 import {
   activeSiteId,
   createAriaChat,
@@ -148,6 +149,11 @@ const core = createAriaChat({
     typing: () => copyParam("ownerAria.typing", "Aria is typing…"),
     slow: () => copyParam("ownerAria.slow", "Aria is taking a while…"),
     stopped: () => copyParam("ownerAria.stopped", "Stopped."),
+    // The note beside Copy. Through copyParam for the same reason as the rest:
+    // the buttons are localized by the pack, and a note left on the core's
+    // English default would be the one line under them that is not.
+    copied: () => copyParam("ownerAria.copied", "Copied"),
+    copyFailed: () => copyParam("ownerAria.copyFailed", "Couldn't copy"),
     // Shown when the HOST carries no Wix app binding, so no Wix call can leave
     // the browser (the web preview). Through copyParam like every other string
     // here — a default baked into the shared core cannot be localized by this
@@ -167,6 +173,9 @@ const core = createAriaChat({
   localHistory: false,
   siteId: activeSiteId,
   openLink: async (url) => (await open(url, "system_browser")).opened,
+  // Resolves or throws — `copyMessage` keys its confirmation on which, so a
+  // write the platform refused is never reported as a copy.
+  copyText: (text) => writeText(text),
   resolveEntity: (url) => {
     const screenId = screenForUrl(url, allowedTargets());
     return screenId ? { screenId } : null;
@@ -191,6 +200,10 @@ const svc = defineService<AriaChatState, {
   // new chat) holds a pre-boundary snapshot, and committing it would end the
   // turn the owner has since started.
   stop: (s: AriaChatState) => Promise<AriaChatState | undefined>;
+  // `undefined` for the same reason again: a write still out when the turn
+  // moved on must not commit its pre-await snapshot over the new one.
+  copyMessage: (s: AriaChatState, arg?: AriaActionArg) => Promise<AriaChatState | undefined>;
+  regenerate: (s: AriaChatState) => Promise<AriaChatState>;
   widgetPrimary: (s: AriaChatState) => Promise<AriaChatState>;
   widgetSecondary: (s: AriaChatState) => Promise<AriaChatState>;
   widgetToggle: (s: AriaChatState, arg?: AriaActionArg) => AriaChatState;
@@ -218,6 +231,8 @@ const svc = defineService<AriaChatState, {
     // false — so this is only ever dispatched while a reply is outstanding and
     // the worker is holding the handle that can abort it.
     stop: core.stop,
+    copyMessage: core.copyMessage,
+    regenerate: core.regenerate,
     // The active widget's footer buttons. Named here as well as in the core:
     // the descriptor dispatches `tier5.<service>.<action>`, and an action the
     // entry does not export is a control that renders and does nothing.

package/templates/retail-store-owner/config.ts

@@ -37,7 +37,7 @@ export default defineApp({
     actions: "http://localhost:8190/v1/actions",
     sync: "http://localhost:8190/v1/sync",
   },
-  capabilities: ["live_activity","push","share","secure_storage","open_url","local_database"],
+  capabilities: ["live_activity","push","share","secure_storage","open_url","local_database","clipboard"],
   designTokensPath: "./tokens.json",
   navigation: {
     "navKind": "responsive",

package/templates/retail-store-owner/dev/index.ts

@@ -54809,6 +54809,83 @@ const SCREENS = runtimeSetting({
                 }
               }
             },
+            {
+              "id": "himi_owner_lite_aria.reply_actions",
+              "body": {
+                "package": "himalaya",
+                "type": "HStack",
+                "props": {
+                  "spacing": 4,
+                  "children": [
+                    {
+                      "id": "himi_owner_lite_aria.copy",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Button",
+                        "props": {
+                          "title": "Copy",
+                          "style": "plain",
+                          "size": "sm",
+                          "fullWidth": false,
+                          "leadingIcon": "copy",
+                          "action": {
+                            "actionId": "tier5.himiOwnerLiteAria.copyMessage"
+                          }
+                        }
+                      }
+                    },
+                    {
+                      "id": "himi_owner_lite_aria.regenerate",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Button",
+                        "props": {
+                          "title": "Regenerate",
+                          "style": "plain",
+                          "size": "sm",
+                          "fullWidth": false,
+                          "leadingIcon": "refresh",
+                          "action": {
+                            "actionId": "tier5.himiOwnerLiteAria.regenerate"
+                          }
+                        }
+                      }
+                    },
+                    {
+                      "id": "",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Text",
+                        "props": {
+                          "text": "$service:himiOwnerLiteAria.copyNote",
+                          "style": "footnote",
+                          "color": "textSecondary",
+                          "maxLines": 1,
+                          "collapseWhenEmpty": true
+                        }
+                      }
+                    },
+                    {
+                      "id": "",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Spacer",
+                        "props": {}
+                      }
+                    }
+                  ]
+                }
+              },
+              "modifiers": {
+                "padding": {
+                  "leading": 0,
+                  "trailing": 0,
+                  "top": 0,
+                  "bottom": 4
+                },
+                "hiddenPath": "$service:himiOwnerLiteAria.replyActionsHidden"
+              }
+            },
             {
               "id": "himi_owner_lite_aria.prompts.bound",
               "body": {
@@ -58188,7 +58265,8 @@ const SCREENS = runtimeSetting({
       "contentType": "application/javascript+ts-bundle",
       "declaredCapabilities": [
         "wix_api",
-        "open_url"
+        "open_url",
+        "clipboard"
       ],
       "minBinaryVersion": "0.1.0",
       "bundleVersion": "0.0.1"