@buoy-gg/scenarios 7.0.76 → 7.0.77

package/lib/typescript/store/scenariosStore.d.ts

@@ -23,7 +23,26 @@
  */
 import { dispatchToolAction } from "@buoy-gg/shared-ui";
 import { type PreflightResult } from "../engine";
+import { type TeamClientDeps, type TeamScenarioRow } from "../team/teamClient";
 import type { ActiveScenario, DeactivateReport, RunReport, Scenario, ScenarioVarValue, StepReport } from "../types";
+/** Tests swap the buoy.gg calls. Null puts the real ones back. */
+export declare function setTeamClientDepsForTests(deps: TeamClientDeps | null): void;
+/** One row from buoy.gg as a read-only `team` scenario. */
+export declare function teamScenarioFromRow(row: TeamScenarioRow): Scenario;
+/**
+ * The team list's state. `off` means there is no team list here (no sign-in
+ * on a team, or no app id) and `message` says why. `error` keeps the last list.
+ */
+export interface TeamInfo {
+    status: "idle" | "loading" | "ready" | "off" | "error";
+    message?: string;
+    /** Why it is `off`: no team sign-in, no app id, or buoy.gg said no. */
+    reason?: "no-team" | "no-app" | "refused";
+    /** The signed-in account, to tell which team scenarios are yours. */
+    you: string | null;
+    admin: boolean;
+    pulledAt?: number;
+}
 /** Device library cap — a phone is not a database. */
 export declare const MAX_DEVICE_SCENARIOS = 100;
 export interface RunState {
@@ -42,6 +61,9 @@ export interface ScenariosState {
     device: Scenario[];
     /** Authored remotely, inert until accepted. */
     drafts: Scenario[];
+    /** Shared by this app's team, pulled from buoy.gg — read-only on device. */
+    team: Scenario[];
+    teamInfo: TeamInfo;
     active: ActiveScenario | null;
     runState: RunState | null;
     lastDeactivateReport: DeactivateReport | null;
@@ -61,7 +83,11 @@ declare class ScenariosStore {
     getState: () => ScenariosState;
     subscribe: (listener: () => void) => (() => void);
     private setState;
-    /** All runnable scenarios, code first; a code scenario wins an id clash. */
+    /**
+     * All runnable scenarios: code, then the team's, then this device's. An id
+     * clash goes the same way, so a scenario shared from this device shows once,
+     * as the team's copy.
+     */
     allScenarios(): Scenario[];
     find(id: string): Scenario | undefined;
     /**
@@ -78,6 +104,38 @@ declare class ScenariosStore {
     private load;
     private persistLibrary;
     private persistActive;
+    private persistTeam;
+    private teamRows;
+    private teamPull;
+    /** The token and team the last pull went out with, to notice a new sign-in. */
+    private teamCredentialKey;
+    private credentialKey;
+    /**
+     * Account access changed (a sign-in, a sign-out, a new key). Pull again only
+     * when the team credential is a different one; other license events pass.
+     */
+    onAccountChange(): Promise<void>;
+    /**
+     * Pull the team's scenarios for this app from buoy.gg. Opening Scenarios
+     * calls this; a pull from the last 30 s counts unless `force` (Refresh).
+     * No team sign-in, or no app id: the team list goes away and says why.
+     * buoy.gg unreachable: the last list stays, with the reason.
+     */
+    refreshTeam(options?: {
+        force?: boolean;
+    }): Promise<void>;
+    private pullTeam;
+    /**
+     * Share a scenario saved on this device with the team. A person's tap only:
+     * no tool action, MCP call or Desktop panel reaches this.
+     */
+    shareWithTeam(id: string): Promise<Scenario>;
+    /** True in a dashboard that mirrors a device (Desktop). Sharing is the device's to do. */
+    isMirror(): boolean;
+    /** Whether this person may take a team scenario off the list: its sharer or an admin. */
+    canRemoveFromTeam(scenario: Scenario): boolean;
+    /** Take a team scenario off the team's list, for everyone. Sharer or admin, a person's tap only. */
+    removeFromTeam(id: string): Promise<void>;
     /**
      * Verify the active scenario's effects still exist. An override rule can be
      * deleted from the Network tool, cleared by the launch guard, or lost to a

package/lib/typescript/sync/scenariosSyncAdapter.d.ts

@@ -28,6 +28,7 @@ export declare const scenariosSyncAdapter: {
             };
             createdAt: number;
             updatedAt: number;
+            team: import("../types").ScenarioTeamInfo | undefined;
             steps: (ScenarioStep | {
                 params: undefined;
                 paramsOmitted: boolean;
@@ -66,6 +67,7 @@ export declare const scenariosSyncAdapter: {
             };
             createdAt: number;
             updatedAt: number;
+            team: import("../types").ScenarioTeamInfo | undefined;
             steps: (ScenarioStep | {
                 params: undefined;
                 paramsOmitted: boolean;
@@ -104,6 +106,7 @@ export declare const scenariosSyncAdapter: {
             };
             createdAt: number;
             updatedAt: number;
+            team: import("../types").ScenarioTeamInfo | undefined;
             steps: (ScenarioStep | {
                 params: undefined;
                 paramsOmitted: boolean;
@@ -118,6 +121,46 @@ export declare const scenariosSyncAdapter: {
                 durability: import("..").Durability;
             }[];
         }[];
+        team: {
+            id: string;
+            name: string;
+            description: string | undefined;
+            version: number;
+            source: import("..").ScenarioSource;
+            author: string | undefined;
+            folder: string | undefined;
+            tags: string[] | undefined;
+            vars: import("..").ScenarioVar[];
+            stepCount: number;
+            expectedOutcome: string | undefined;
+            authoredAgainst: string | undefined;
+            verifiedAt: {
+                build: string;
+                at: number;
+            } | undefined;
+            unsavedToRepo: boolean | undefined;
+            usage: {
+                runs: number;
+                lastRunAt?: number;
+            };
+            createdAt: number;
+            updatedAt: number;
+            team: import("../types").ScenarioTeamInfo | undefined;
+            steps: (ScenarioStep | {
+                params: undefined;
+                paramsOmitted: boolean;
+                id: string;
+                tool: string;
+                action: string;
+                label?: string;
+                timeoutMs?: number;
+            })[];
+            stepLines: {
+                label: string;
+                durability: import("..").Durability;
+            }[];
+        }[];
+        teamInfo: import("..").TeamInfo;
         active: import("..").ActiveScenario | null;
         runState: import("..").RunState | null;
         hasLoaded: boolean;
@@ -151,6 +194,7 @@ export declare const scenariosSyncAdapter: {
                 };
                 createdAt: number;
                 updatedAt: number;
+                team: import("../types").ScenarioTeamInfo | undefined;
                 steps: (ScenarioStep | {
                     params: undefined;
                     paramsOmitted: boolean;
@@ -189,6 +233,7 @@ export declare const scenariosSyncAdapter: {
                 };
                 createdAt: number;
                 updatedAt: number;
+                team: import("../types").ScenarioTeamInfo | undefined;
                 steps: (ScenarioStep | {
                     params: undefined;
                     paramsOmitted: boolean;
@@ -227,6 +272,46 @@ export declare const scenariosSyncAdapter: {
                 };
                 createdAt: number;
                 updatedAt: number;
+                team: import("../types").ScenarioTeamInfo | undefined;
+                steps: (ScenarioStep | {
+                    params: undefined;
+                    paramsOmitted: boolean;
+                    id: string;
+                    tool: string;
+                    action: string;
+                    label?: string;
+                    timeoutMs?: number;
+                })[];
+                stepLines: {
+                    label: string;
+                    durability: import("..").Durability;
+                }[];
+            }[];
+            team: {
+                id: string;
+                name: string;
+                description: string | undefined;
+                version: number;
+                source: import("..").ScenarioSource;
+                author: string | undefined;
+                folder: string | undefined;
+                tags: string[] | undefined;
+                vars: import("..").ScenarioVar[];
+                stepCount: number;
+                expectedOutcome: string | undefined;
+                authoredAgainst: string | undefined;
+                verifiedAt: {
+                    build: string;
+                    at: number;
+                } | undefined;
+                unsavedToRepo: boolean | undefined;
+                usage: {
+                    runs: number;
+                    lastRunAt?: number;
+                };
+                createdAt: number;
+                updatedAt: number;
+                team: import("../types").ScenarioTeamInfo | undefined;
                 steps: (ScenarioStep | {
                     params: undefined;
                     paramsOmitted: boolean;
@@ -241,6 +326,7 @@ export declare const scenariosSyncAdapter: {
                     durability: import("..").Durability;
                 }[];
             }[];
+            teamInfo: import("..").TeamInfo;
             active: import("..").ActiveScenario | null;
             runState: import("..").RunState | null;
             hasLoaded: boolean;

package/lib/typescript/team/teamClient.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Shared Scenarios for teams: the three calls to buoy.gg (SHARED_SCENARIOS_PLAN.md).
+ *
+ * A device sends the token it already holds, a sign-in or the dev token from
+ * `buoy login`, plus this app's id. buoy.gg keeps one row per team, app and
+ * scenario. Bot keys and plain license keys get no team list.
+ */
+import type { Scenario } from "../types";
+export interface TeamScenarioRow {
+    id: string;
+    app: string;
+    scenario: Scenario;
+    version: number;
+    sharedBy: {
+        id: string;
+        label: string;
+    };
+    sharedAt: number;
+    updatedAt: number;
+}
+export interface TeamPullResult {
+    scenarios: TeamScenarioRow[];
+    /** The caller's account id. */
+    you: string;
+    admin: boolean;
+}
+/**
+ * Why a call didn't happen or didn't work:
+ * - `no-team`: no sign-in on a Business team (or a plain key).
+ * - `no-app`: Buoy can't tell which app this is.
+ * - `network`: buoy.gg couldn't be reached.
+ * - `refused`: buoy.gg said no; `message` says why.
+ */
+export type TeamFailure = {
+    ok: false;
+    code: "no-team" | "no-app" | "network" | "refused";
+    message: string;
+};
+export type TeamCall<T> = {
+    ok: true;
+    value: T;
+} | TeamFailure;
+export interface TeamClientDeps {
+    credential: () => {
+        token: string;
+        origin: string;
+        team: string;
+        appId: string | null;
+    } | null;
+    appId: () => string | null;
+    fetch: (url: string, init: {
+        method: string;
+        headers: Record<string, string>;
+        body: string;
+        signal?: AbortSignal;
+    }) => Promise<{
+        status: number;
+        json(): Promise<unknown>;
+    }>;
+}
+export declare const NO_TEAM_MESSAGE = "Sign in with a Business team account to share scenarios with your team.";
+export declare const NO_APP_MESSAGE = "Buoy can't tell which app this is. Pass signIn={{ appId }} to FloatingDevTools to name it.";
+export declare function defaultTeamClientDeps(): TeamClientDeps;
+/** The app this device's team list belongs to: the one its sign-in names, else the one core found. */
+export declare function teamAppId(deps: TeamClientDeps): string | null;
+/** The team's scenarios for this app. */
+export declare function pullTeamScenarios(deps?: TeamClientDeps): Promise<TeamCall<TeamPullResult>>;
+/**
+ * Fields that only mean something on this device. They never leave it:
+ * how often it ran here, when someone here last checked it, where it came from.
+ */
+export declare function forSharing(scenario: Scenario): Omit<Scenario, "usage" | "source" | "verifiedAt" | "team">;
+/** Share one scenario with the team. A person's tap only: no tool action calls this. */
+export declare function shareTeamScenario(scenario: Scenario, deps?: TeamClientDeps): Promise<TeamCall<TeamScenarioRow>>;
+/** Take one scenario off the team's list. Only its sharer or a team admin may. */
+export declare function removeTeamScenario(id: string, deps?: TeamClientDeps): Promise<TeamCall<true>>;
+//# sourceMappingURL=teamClient.d.ts.map

package/lib/typescript/types.d.ts

@@ -48,8 +48,21 @@ export interface ScenarioStep {
  * - `device` — saved on this device; editable, deletable, exportable.
  * - `draft`  — authored remotely (MCP/desktop) and INERT until a human accepts it
  *              on-device. A draft never runs and never appears as a Run target.
+ * - `team`   — shared by someone on this app's Business team, pulled from
+ *              buoy.gg. Read-only on device, like `code`; runs like any other.
  */
-export type ScenarioSource = "code" | "device" | "draft";
+export type ScenarioSource = "code" | "device" | "draft" | "team";
+/** Who shared a team scenario, and when. Only on `team` scenarios. */
+export interface ScenarioTeamInfo {
+    sharedBy: {
+        id: string;
+        label: string;
+    };
+    sharedAt: number;
+    updatedAt: number;
+    /** The app it was shared from, which is this app. */
+    app: string;
+}
 export interface Scenario {
     id: string;
     /** Placeholders allowed: "Out-of-stock item at store {{storeId}}". */
@@ -99,6 +112,8 @@ export interface Scenario {
         runs: number;
         lastRunAt?: number;
     };
+    /** Set on `team` scenarios. */
+    team?: ScenarioTeamInfo;
 }
 /**
  * An effect a run actually applied. Recorded per-step AS IT SUCCEEDS, so a
@@ -153,6 +168,12 @@ export interface ActiveScenario {
     effects: AppliedEffect[];
     /** Epoch ms after which the runner auto-deactivates. */
     expiresAt?: number;
+    /**
+     * The undo steps as they were when it ran. A team scenario can change or
+     * go away while it is on, and undo must still run the steps that match
+     * what was applied.
+     */
+    undoSteps?: ScenarioStep[];
 }
 export interface StepReport {
     id: string;