@frockbot/plugin-package-publisher 0.0.0 → 0.1.1

package/src/backend.ts

@@ -0,0 +1,125 @@
+import type { Plugin } from "cordis";
+import {
+  PackagePublisherConflictError,
+  PackagePublisherDecodeError,
+  decodeRollbackPackageCommandV1,
+  type PackagePublicationReceiptV1,
+  type PackageRevisionHistoryV1,
+  type RollbackPackageCommandV1,
+} from "./shared.js";
+
+export interface PackagePublisherGatewayHost {
+  read(userId: string): Promise<PackageRevisionHistoryV1>;
+  rollback(
+    userId: string,
+    command: RollbackPackageCommandV1,
+  ): Promise<PackagePublicationReceiptV1>;
+}
+
+export interface PackagePublisherBackendRouteContribution {
+  packageId: string;
+  route(
+    request: Request,
+    url: URL,
+    context: { userId?: string; client: "browser" | "desktop" },
+  ): Promise<Response | undefined>;
+}
+
+function errorResponse(error: unknown): Response {
+  if (
+    error instanceof PackagePublisherDecodeError ||
+    (typeof error === "object" &&
+      error !== null &&
+      "name" in error &&
+      error.name === "PackagePublisherDecodeError")
+  ) {
+    return Response.json(
+      {
+        error:
+          error instanceof Error ? error.message : "package request is invalid",
+        code: "invalid-request",
+        definitive: true,
+      },
+      { status: 400 },
+    );
+  }
+  if (
+    error instanceof PackagePublisherConflictError ||
+    (typeof error === "object" &&
+      error !== null &&
+      "name" in error &&
+      error.name === "PackagePublisherConflictError")
+  ) {
+    const currentRevision =
+      typeof error === "object" &&
+      error !== null &&
+      "currentRevision" in error &&
+      typeof error.currentRevision === "number"
+        ? error.currentRevision
+        : 0;
+    return Response.json(
+      {
+        error: `package revision is ${currentRevision}`,
+        code: "revision-conflict",
+        currentRevision,
+        definitive: true,
+      },
+      { status: 409 },
+    );
+  }
+  return Response.json(
+    {
+      error:
+        error instanceof Error ? error.message : "package publication failed",
+    },
+    { status: 500 },
+  );
+}
+
+export function createPackagePublisherBackendContribution(
+  host: PackagePublisherGatewayHost,
+): PackagePublisherBackendRouteContribution {
+  return {
+    packageId: "package-publisher",
+    async route(request, url, context) {
+      if (!context.userId) return undefined;
+      const revisions = url.pathname === "/api/package-revisions";
+      const rollback = url.pathname === "/api/package-revisions/rollback";
+      if (!revisions && !rollback) return undefined;
+      try {
+        if (revisions && request.method === "GET") {
+          return Response.json(await host.read(context.userId));
+        }
+        if (request.method !== "POST") {
+          return Response.json(
+            { error: "method not allowed" },
+            { status: 405 },
+          );
+        }
+        if (rollback) {
+          return Response.json(
+            await host.rollback(
+              context.userId,
+              decodeRollbackPackageCommandV1(await request.json()),
+            ),
+          );
+        }
+        return Response.json({ error: "method not allowed" }, { status: 405 });
+      } catch (error) {
+        return errorResponse(error);
+      }
+    },
+  };
+}
+
+export namespace createPackagePublisherBackendContribution {
+  export function plugin(
+    host: PackagePublisherGatewayHost,
+    lifecycle: {
+      mount(value: PackagePublisherBackendRouteContribution): () => void;
+    },
+  ): Plugin {
+    return () =>
+      lifecycle.mount(createPackagePublisherBackendContribution(host));
+  }
+}

package/src/client/PackagePublisherSection.vue

@@ -0,0 +1,79 @@
+<script setup lang="ts">
+import { clientSurfaceRegistryKey } from "@frockbot/client-core";
+import { UiButton, UiIcon } from "@frockbot/client-ui";
+import { computed, inject, onMounted } from "vue";
+import { packagePublisherStateKey } from "./state.js";
+
+const surfaces = inject(clientSurfaceRegistryKey);
+const state = inject(packagePublisherStateKey);
+if (!surfaces || !state) {
+  throw new Error("Package Publisher client services were not provided");
+}
+const publisher = state;
+const summary = computed(() => {
+  const history = publisher.value.history;
+  if (!history) return "Not published yet";
+  const active = history.activePackageRevision;
+  if (active === undefined) return `${history.revisions.length} revisions`;
+  return `Revision ${active} · active`;
+});
+
+onMounted(() => publisher.value.load());
+</script>
+
+<template>
+  <div class="publisher-section">
+    <span class="publisher-section__icon" aria-hidden="true"
+      ><UiIcon name="history"
+    /></span>
+    <span class="publisher-section__text">
+      <strong>Setup revisions</strong>
+      <small>{{ summary }}</small>
+    </span>
+    <UiButton type="button" @click="surfaces.open('package-publisher')">
+      Open
+    </UiButton>
+  </div>
+</template>
+
+<style scoped>
+.publisher-section {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 12px;
+  border: 1px solid var(--frock-border);
+  border-radius: var(--frock-radius-card);
+  background: var(--frock-surface-subtle);
+}
+
+.publisher-section__icon {
+  display: grid;
+  width: var(--frock-avatar-sm);
+  height: var(--frock-avatar-sm);
+  flex: 0 0 auto;
+  place-items: center;
+  border-radius: 8px;
+  color: var(--frock-action-primary);
+  background: var(--frock-surface);
+  box-shadow: inset 0 0 0 1px var(--frock-border);
+}
+
+.publisher-section__text {
+  display: flex;
+  min-width: 0;
+  flex: 1 1 auto;
+  flex-direction: column;
+}
+
+.publisher-section__text strong {
+  color: var(--frock-text);
+  font-size: var(--frock-text-md);
+  font-weight: 600;
+}
+
+.publisher-section__text small {
+  color: var(--frock-text-muted);
+  font-size: var(--frock-text-sm);
+}
+</style>

package/src/client/PackagePublisherSurface.vue

@@ -0,0 +1,122 @@
+<script setup lang="ts">
+import { UiButton } from "@frockbot/client-ui";
+import { computed, inject, onMounted } from "vue";
+import { packagePublisherStateKey } from "./state.js";
+
+const providedState = inject(packagePublisherStateKey);
+if (!providedState) throw new Error("package publisher state was not provided");
+const state = providedState;
+const revisions = computed(() =>
+  [...(state.value.history?.revisions ?? [])].toReversed(),
+);
+
+onMounted(() => state.value.load());
+</script>
+
+<template>
+  <div class="publisher-surface">
+    <header>
+      <h2>Published setup</h2>
+      <p>
+        Publishing activates one immutable setup for all of your Bots. Rollback
+        changes the shared active revision.
+      </p>
+    </header>
+
+    <div v-if="revisions.length" class="revision-list">
+      <article
+        v-for="revision in revisions"
+        :key="revision.packageRevision"
+        class="revision-card"
+      >
+        <div>
+          <strong>Revision {{ revision.packageRevision }}</strong>
+          <small>{{ new Date(revision.publishedAt).toLocaleString() }}</small>
+          <code>{{ revision.applicationHash.slice(0, 22) }}…</code>
+        </div>
+        <span
+          v-if="
+            state.history?.activePackageRevision === revision.packageRevision
+          "
+          class="active-revision"
+        >
+          Active
+        </span>
+        <UiButton
+          v-else
+          :disabled="state.busy"
+          @click="state.rollback(revision.packageRevision)"
+        >
+          Roll back
+        </UiButton>
+      </article>
+    </div>
+    <p v-else-if="!state.error" class="empty-revisions">
+      No custom setup has been published yet.
+    </p>
+    <p v-if="state.error" class="publisher-error" role="alert">
+      {{ state.error }}
+    </p>
+  </div>
+</template>
+
+<style scoped>
+.publisher-surface {
+  padding: 24px;
+}
+
+.publisher-surface h2 {
+  margin: 0;
+  font-family: var(--frock-font-display);
+}
+
+.publisher-surface header p,
+.empty-revisions {
+  color: var(--frock-text-muted);
+  font-size: var(--frock-text-base);
+  line-height: 1.5;
+}
+
+.revision-list {
+  display: grid;
+  gap: 12px;
+  margin-top: 20px;
+}
+
+.revision-card {
+  display: flex;
+  min-width: 0;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  padding: 14px;
+  border: 1px solid var(--frock-border);
+  border-radius: var(--frock-radius-card);
+  background: var(--frock-surface-raised);
+  box-shadow: var(--frock-shadow-card);
+}
+
+.revision-card strong,
+.revision-card small,
+.revision-card code {
+  display: block;
+}
+
+.revision-card small,
+.revision-card code {
+  margin-top: 4px;
+  color: var(--frock-text-muted);
+  font-size: var(--frock-text-sm);
+}
+
+.active-revision {
+  color: var(--frock-success);
+  font-size: var(--frock-text-sm);
+  font-weight: 700;
+}
+
+.publisher-error {
+  color: var(--frock-danger-text);
+  font-size: var(--frock-text-sm);
+}
+</style>

package/src/client/index.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "bun:test";
+import {
+  clientSurfaceRegistryKey,
+  type ClientPluginContext,
+  type ClientSlotRegistration,
+} from "@frockbot/client-core";
+import { createClientSurfaceRegistry } from "@frockbot/client-ui";
+import { packagePublisherClientPlugin } from "./index.js";
+import { packagePublisherStateKey } from "./state.js";
+
+const history = {
+  schemaVersion: 1 as const,
+  revision: 2,
+  activePackageRevision: 2,
+  revisions: [
+    {
+      packageRevision: 1,
+      applicationHash: "sha256:one",
+      publishedAt: "2026-09-01T00:00:00.000Z",
+      checks: [{ name: "test", status: "passed" as const }],
+    },
+    {
+      packageRevision: 2,
+      applicationHash: "sha256:two",
+      publishedAt: "2026-09-02T00:00:00.000Z",
+      checks: [{ name: "test", status: "passed" as const }],
+    },
+  ],
+};
+
+describe("Package Publisher client contribution", () => {
+  test("registers revision UI and rolls back through the hosted protocol", async () => {
+    const surfaces = createClientSurfaceRegistry();
+    const slots: ClientSlotRegistration[] = [];
+    const calls: Array<[string, string | undefined, string | undefined]> = [];
+    let state: unknown;
+    const context: ClientPluginContext = {
+      transport: {
+        turn: () => Promise.resolve({ runId: "run", text: "", events: [] }),
+        hostedRequest: (path, method, body) => {
+          calls.push([path, method, body]);
+          if (path.endsWith("/rollback")) {
+            return Promise.resolve({
+              schemaVersion: 1,
+              commandId: JSON.parse(body ?? "{}").commandId,
+              status: "active",
+              revision: 3,
+              packageRevision: 1,
+              applicationHash: "sha256:one",
+            });
+          }
+          return Promise.resolve(history);
+        },
+      },
+      inject: (key) => {
+        if (key !== clientSurfaceRegistryKey) {
+          throw new Error("unexpected client provider");
+        }
+        return surfaces as never;
+      },
+      provide: (key, value) => {
+        if (key === packagePublisherStateKey) state = value;
+        return () => {};
+      },
+      slot: (registration) => {
+        slots.push(registration);
+        return () => slots.splice(slots.indexOf(registration), 1);
+      },
+    };
+
+    const disposers = packagePublisherClientPlugin(context);
+    if (!Array.isArray(disposers)) throw new Error("expected registrations");
+    expect(surfaces.has("package-publisher")).toBe(true);
+    expect(slots.map((slot) => slot.slot)).toEqual([
+      "frockbot.user-settings-sections",
+    ]);
+
+    const publisher = state as {
+      value: {
+        load(): Promise<void>;
+        rollback(revision: number): Promise<void>;
+      };
+    };
+    await publisher.value.load();
+    await publisher.value.rollback(1);
+    expect(calls.map(([path]) => path)).toEqual([
+      "/api/package-revisions",
+      "/api/package-revisions/rollback",
+      "/api/package-revisions",
+    ]);
+    expect(JSON.parse(calls[1]![2] ?? "{}")).toMatchObject({
+      expectedRevision: 2,
+      packageRevision: 1,
+    });
+
+    for (const dispose of disposers.toReversed()) dispose();
+    expect(surfaces.has("package-publisher")).toBe(false);
+  });
+});

package/src/client/index.ts

@@ -0,0 +1,84 @@
+/// <reference path="../env.d.ts" />
+
+// The immutable hosted client mounts this built-in Package Contribution.
+import {
+  clientSurfaceRegistryKey,
+  type ClientPlugin,
+} from "@frockbot/client-core";
+import { ref } from "vue";
+import {
+  decodePackagePublicationReceiptV1,
+  decodePackageRevisionHistoryV1,
+} from "../shared.js";
+import PackagePublisherSection from "./PackagePublisherSection.vue";
+import PackagePublisherSurface from "./PackagePublisherSurface.vue";
+import {
+  packagePublisherStateKey,
+  type PackagePublisherClientState,
+} from "./state.js";
+
+export const packagePublisherClientPlugin: ClientPlugin = (ctx) => {
+  const surfaces = ctx.inject(clientSurfaceRegistryKey);
+  const state = ref<PackagePublisherClientState>({
+    busy: false,
+    async load() {
+      if (!ctx.transport.hostedRequest) {
+        state.value.error = "Package revisions are unavailable";
+        return;
+      }
+      try {
+        state.value.history = decodePackageRevisionHistoryV1(
+          await ctx.transport.hostedRequest("/api/package-revisions"),
+        );
+        state.value.error = undefined;
+      } catch (error) {
+        state.value.error =
+          error instanceof Error ? error.message : "Could not load revisions";
+      }
+    },
+    async rollback(packageRevision: number) {
+      if (!ctx.transport.hostedRequest || !state.value.history) {
+        throw new Error("Package revisions are unavailable");
+      }
+      state.value.busy = true;
+      try {
+        decodePackagePublicationReceiptV1(
+          await ctx.transport.hostedRequest(
+            "/api/package-revisions/rollback",
+            "POST",
+            JSON.stringify({
+              schemaVersion: 1,
+              commandId: crypto.randomUUID(),
+              expectedRevision: state.value.history.revision,
+              packageRevision,
+            }),
+          ),
+        );
+        await state.value.load();
+      } catch (error) {
+        state.value.error =
+          error instanceof Error ? error.message : "Rollback failed";
+      } finally {
+        state.value.busy = false;
+      }
+    },
+  });
+
+  return [
+    ctx.provide(packagePublisherStateKey, state),
+    surfaces.register({
+      id: "package-publisher",
+      title: "Published setup",
+      component: PackagePublisherSurface,
+    }),
+    // Revisions are an internal detail: they live inside the User profile's
+    // advanced section rather than the sidebar.
+    ctx.slot({
+      slot: "frockbot.user-settings-sections",
+      order: 20,
+      component: PackagePublisherSection,
+    }),
+  ];
+};
+
+export default packagePublisherClientPlugin;

package/src/client/state.ts

@@ -0,0 +1,14 @@
+import type { PackageRevisionHistoryV1 } from "../shared.js";
+import type { InjectionKey, Ref } from "vue";
+
+export interface PackagePublisherClientState {
+  history?: PackageRevisionHistoryV1;
+  busy: boolean;
+  error?: string;
+  load(): Promise<void>;
+  rollback(packageRevision: number): Promise<void>;
+}
+
+export const packagePublisherStateKey: InjectionKey<
+  Ref<PackagePublisherClientState>
+> = Symbol("package-publisher-state");

package/src/env.d.ts

@@ -0,0 +1,6 @@
+declare module "*.vue" {
+  import type { DefineComponent } from "vue";
+
+  const component: DefineComponent;
+  export default component;
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./backend.js";
+export * from "./shared.js";
+export * from "./user.js";

package/src/manifest.ts

@@ -0,0 +1,3 @@
+import manifest from "../frockbot.json" with { type: "json" };
+
+export default manifest;