@vendoai/vendo 0.4.0

package/dist/cli/playground/app/embed-entry.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * The docs inline-embed entry (vendo.run/playground/embed.js): mounts REAL
+ * chrome surfaces — scripted data, no model key — directly into a host page's
+ * DOM (no iframe). Built by scripts/build-playground.mjs into
+ * embed-bundle.gen.ts; the CLI playground server and the vendo-web static
+ * export both serve it as /embed.js.
+ *
+ *   window.VendoDocsEmbed.mount(el, { scenario: "approval-flow" })
+ *   window.VendoDocsEmbed.mountLauncher()
+ *
+ * `mount` returns a dispose function. `mountLauncher` drops the real corner
+ * launcher + overlay onto the page (the actual product drop-in) — one call,
+ * one line to remove.
+ */
+import { defaultVendoTheme } from "@vendoai/ui";
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import { ScenarioMount } from "./scenario-mount.js";
+import { scenarios } from "./scenarios.js";
+import { decodeThemeParam } from "./theme-state.js";
+function mount(el, options) {
+    const scenario = scenarios.find((entry) => entry.id === options.scenario);
+    if (!scenario) {
+        const known = scenarios.map((entry) => entry.id).join(", ");
+        throw new Error(`[vendo-embed] unknown scenario "${options.scenario}" — one of: ${known}`);
+    }
+    const theme = decodeThemeParam(options.theme ?? null) ?? defaultVendoTheme;
+    const root = createRoot(el);
+    root.render(_jsx(StrictMode, { children: _jsx(ScenarioMount, { scenario: scenario, theme: theme, root: el }) }));
+    return () => root.unmount();
+}
+/** The real product drop-in: corner launcher pill + overlay, scripted data. */
+function mountLauncher(options = {}) {
+    const host = document.createElement("div");
+    host.dataset.vendoDocsLauncher = "";
+    document.body.append(host);
+    const dispose = mount(host, { scenario: "overlay-launcher", theme: options.theme });
+    return () => {
+        dispose();
+        host.remove();
+    };
+}
+window.VendoDocsEmbed = { mount, mountLauncher };
+// Host pages poll for readiness; give them an event too.
+window.dispatchEvent(new Event("vendo-docs-embed-ready"));

package/dist/cli/playground/app/fake-client.d.ts

@@ -0,0 +1,3 @@
+import type { VendoClient } from "@vendoai/ui";
+import type { PlaygroundFixtures } from "./fixtures.js";
+export declare function createFakeClient(fixtures: PlaygroundFixtures): VendoClient;

package/dist/cli/playground/app/fake-client.js

@@ -0,0 +1,215 @@
+/**
+ * An in-page VendoClient over the static wire payload fixtures — the
+ * playground's replacement for the live wire. Reads answer from fixture
+ * state; mutations update that state in memory so flows (approve, dismiss,
+ * disconnect) behave; streaming never lands here because every scenario mounts
+ * the ScriptedTransport at the provider seam.
+ */
+import { VendoError } from "@vendoai/core";
+export function createFakeClient(fixtures) {
+    const state = {
+        threads: [...fixtures.threads],
+        apps: [...fixtures.apps],
+        automations: fixtures.automations.map((entry) => ({ ...entry })),
+        connections: [...fixtures.connections],
+        approvals: [...fixtures.approvals],
+        approvalResolutions: new Map(),
+        grants: [...fixtures.grants],
+        runs: [...fixtures.runs],
+    };
+    const app = (id) => {
+        const found = state.apps.find((candidate) => candidate.id === id);
+        if (!found)
+            throw new VendoError("not-found", `Unknown app ${id}`);
+        return found;
+    };
+    return {
+        baseUrl: "playground:fake",
+        headers: {},
+        threads: {
+            // Streaming rides the scripted transport (the provider override); the
+            // playground never opens a live turn stream.
+            stream: async () => new Response(null, { status: 501 }),
+            list: async () => state.threads.map(({ id, title, updatedAt }) => ({ id, title, updatedAt })),
+            get: async (id) => {
+                const found = state.threads.find((candidate) => candidate.id === id);
+                if (!found)
+                    throw new VendoError("not-found", `Unknown thread ${id}`);
+                return found.thread;
+            },
+            delete: async (id) => {
+                state.threads = state.threads.filter((candidate) => candidate.id !== id);
+            },
+        },
+        approvals: {
+            pending: async () => [...state.approvals],
+            decide: async (ids, decision) => {
+                const decided = new Set(Array.isArray(ids) ? ids : [ids]);
+                state.approvals = state.approvals.filter((approval) => !decided.has(approval.id));
+                // Existing-agents — mirror the wire's park→resume so a scenario's
+                // <VendoApprovalEmbed> resolves in place after a decision.
+                for (const id of decided) {
+                    state.approvalResolutions.set(id, decision.approve
+                        ? { state: "executed", outcome: { status: "ok", output: { delivered: true } } }
+                        : { state: "declined" });
+                }
+            },
+            get: async (id) => {
+                const pending = state.approvals.find((approval) => approval.id === id);
+                if (pending)
+                    return { state: "pending", request: pending };
+                const resolved = state.approvalResolutions.get(id);
+                if (resolved)
+                    return resolved;
+                throw new VendoError("not-found", `Unknown approval ${id}`);
+            },
+        },
+        grants: {
+            list: async () => [...state.grants],
+            revoke: async (id) => {
+                state.grants = state.grants.filter((grant) => grant.id !== id);
+            },
+        },
+        connections: {
+            list: async () => [...state.connections],
+            // The scripted catalog mirrors the scenarios' explicit connectors prop;
+            // surfaces resolving in auto mode see the same two toolkits.
+            catalog: async () => [
+                { toolkit: "slack", connector: "composio" },
+                { toolkit: "github", connector: "composio" },
+            ],
+            initiate: async ({ toolkit, connector }) => ({
+                id: `conn_${toolkit}_new`,
+                connector: connector ?? "composio",
+                // A same-page anchor: nothing to OAuth against in the playground.
+                redirectUrl: "#connected",
+            }),
+            status: async (id) => {
+                const found = state.connections.find((candidate) => candidate.id === id);
+                return found ?? { id, connector: "composio", toolkit: "slack", status: "active" };
+            },
+            disconnect: async (id) => {
+                state.connections = state.connections.filter((candidate) => candidate.id !== id);
+            },
+        },
+        apps: {
+            list: async () => [...state.apps],
+            create: async ({ prompt }) => {
+                const created = {
+                    format: "vendo/app@1",
+                    id: `app_created_${state.apps.length + 1}`,
+                    name: prompt.slice(0, 40) || "New app",
+                    description: `Scripted playground app for “${prompt}”.`,
+                    ui: "tree",
+                    tree: state.apps[0]?.tree,
+                };
+                state.apps.push(created);
+                return created;
+            },
+            get: async (id) => app(id),
+            delete: async (id) => {
+                state.apps = state.apps.filter((candidate) => candidate.id !== id);
+            },
+            open: async (id) => {
+                const document = app(id);
+                if (!document.tree)
+                    throw new VendoError("validation", `App ${id} has no tree surface`);
+                return { kind: "tree", payload: document.tree };
+            },
+            call: async () => ({ status: "ok", output: { ok: true } }),
+            pingMachine: async () => ({ state: "awake" }),
+            edit: async (id) => ({ app: app(id), version: { at: new Date().toISOString(), intent: "edit", rung: 2 } }),
+            history: async () => [{ at: "2026-07-18T09:05:30.000Z", intent: "create", rung: 2 }],
+            undo: async (id) => app(id),
+            exportApp: async (id) => new TextEncoder().encode(JSON.stringify(app(id))),
+            importApp: async (bytes) => {
+                const imported = JSON.parse(new TextDecoder().decode(bytes));
+                state.apps.push(imported);
+                return imported;
+            },
+            fork: async (id) => {
+                const source = app(id);
+                const fork = { ...source, id: `${source.id}_fork`, name: `${source.name} (fork)`, forkedFrom: source.id };
+                state.apps.push(fork);
+                return fork;
+            },
+            shipDiff: async (id) => ({ appId: id, versionHash: "sha256:playground", pins: [], generated: [] }),
+            pinDrift: async () => [],
+            forkPin: async ({ appId, slot }) => {
+                // Persist like the real runtime: the fork must land in the store so
+                // slot discovery (apps.list) can mount it. An empty-slot gesture
+                // mints a new app around the pin; a filled gesture pins in place.
+                const pin = { slot, base: "sha256:playground" };
+                let forked;
+                if (appId === undefined) {
+                    forked = {
+                        format: "vendo/app@1",
+                        id: `app_remix_${state.apps.length + 1}`,
+                        name: `${slot} remix`,
+                        description: `Playground remix of the "${slot}" slot.`,
+                        ui: "tree",
+                        tree: state.apps[0]?.tree,
+                        pins: [pin],
+                    };
+                    state.apps.push(forked);
+                }
+                else {
+                    const target = app(appId);
+                    forked = { ...target, pins: [...(target.pins ?? []), pin] };
+                    state.apps = state.apps.map((candidate) => (candidate.id === appId ? forked : candidate));
+                }
+                return {
+                    app: forked,
+                    version: { at: new Date().toISOString(), intent: `Remix the host component "${slot}"`, rung: 2 },
+                    slot,
+                    componentName: `Pinned${slot}`,
+                };
+            },
+            rebasePin: async (id, slot) => ({
+                status: "rebased",
+                app: app(id),
+                version: { at: new Date().toISOString(), intent: "rebase", rung: 2 },
+                slot,
+                baseHash: "sha256:playground",
+                replayed: [],
+            }),
+        },
+        automations: {
+            list: async () => state.automations.map((entry) => ({ ...entry })),
+            enable: async (id) => {
+                const entry = state.automations.find((candidate) => candidate.app.id === id);
+                if (entry)
+                    entry.enabled = true;
+                return { enabled: true, missing: [] };
+            },
+            disable: async (id) => {
+                const entry = state.automations.find((candidate) => candidate.app.id === id);
+                if (entry)
+                    entry.enabled = false;
+            },
+            dryRun: async () => ({
+                steps: [
+                    { id: "step_1", tool: "host_listRenewals", wouldAsk: false },
+                    { id: "step_2", tool: "slack_SLACK_SEND_MESSAGE", wouldAsk: true },
+                ],
+                grantsMissing: [],
+            }),
+        },
+        runs: {
+            list: async (filter) => ({
+                runs: state.runs.filter((run) => (filter?.appId === undefined ? true : run.appId === filter.appId)),
+            }),
+            get: async (id) => {
+                const found = state.runs.find((run) => run.id === id);
+                if (!found)
+                    throw new VendoError("not-found", `Unknown run ${id}`);
+                return found;
+            },
+            stop: async () => undefined,
+        },
+        activity: {
+            list: async () => [...fixtures.activity],
+        },
+        status: async () => fixtures.status,
+    };
+}

package/dist/cli/playground/app/fixtures.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Playground fixtures — every scenario renders the REAL chrome against these:
+ * director-mode scripts (the `DirectorScript` format the demo-host fixtures
+ * already use, see packages/ui/src/hooks/scripted-transport.ts) for streamed
+ * turns, and static wire payloads served by the in-page fake client for
+ * everything the collection hooks fetch. No model key, no network.
+ */
+import type { AppDocument, ApprovalRequest, AuditEvent, PermissionGrant, UIPayload } from "@vendoai/core";
+import type { AutomationEntry, ConnectionAccount, DirectorScript, RunRecord, Thread, ThreadSummary, ToolMetaMap, VendoStatus } from "@vendoai/ui";
+/** Friendly labels so build beats speak like a host would make them speak. */
+export declare const playgroundToolMeta: ToolMetaMap;
+/** The finished "Renewals radar" view — also the slot's pinned payload. */
+export declare function renewalsViewPayload(): UIPayload;
+/** A deliberately broken payload. The renderer is fail-soft about CONTENT
+ *  problems (bad root, missing components → contained notices), so to reach
+ *  the slot's recovery path this has to crash the renderer itself: a partial
+ *  (`streaming: true`) payload whose `nodes` is malformed throws host-side in
+ *  TreeView, outside the per-node boundaries — and VendoSlot's PinMount
+ *  boundary keeps the host's original children visible (06-apps §8). */
+export declare function brokenViewPayload(): UIPayload;
+/** A long, slowly streaming text turn — the "streaming" screenshot state. */
+export declare function streamingScript(): DirectorScript;
+/** Tool beats → a generated view streaming in → a closing summary. */
+export declare function viewScript(): DirectorScript;
+/** Turn 0 parks on a write approval; deciding it resumes turn 1 (03-agent §4). */
+export declare function approvalScript(): DirectorScript;
+/** A connector call that needs a per-user connected account first (04 §3). */
+export declare function connectScript(): DirectorScript;
+export interface PlaygroundFixtures {
+    status: VendoStatus;
+    threads: Array<ThreadSummary & {
+        thread: Thread;
+    }>;
+    apps: AppDocument[];
+    automations: AutomationEntry[];
+    connections: ConnectionAccount[];
+    approvals: ApprovalRequest[];
+    grants: PermissionGrant[];
+    activity: AuditEvent[];
+    runs: RunRecord[];
+}
+/** The Activities empty state: a workspace where the agent has not acted yet —
+ *  no pending approvals, no audit trail. Everything else stays populated so
+ *  the surface sits in a realistic host page. */
+export declare function emptyActivitiesFixtures(): PlaygroundFixtures;
+/** Fresh copies every call: scenario state never leaks between mounts. */
+export declare function playgroundFixtures(): PlaygroundFixtures;