sensorium-mcp 3.1.2 → 3.1.3-board.2

package/dist/board/state/auth.js

@@ -0,0 +1,55 @@
+/**
+ * Auth composable + token accessor.  ❌ FROZEN SEAM.
+ *
+ * The Bearer token is entered once in the UI and kept in localStorage (the
+ * dashboard-proven pattern). In preview mode auth is a NO-OP: the mock adapter
+ * ignores the token, so `isAuthed()` is always true and every screen renders.
+ */
+
+import { ref } from "../vendor/vue.esm-browser.js";
+import { MODE } from "../config.js";
+
+const KEY = "BOARD_API_TOKEN";
+
+function read() {
+  try {
+    return localStorage.getItem(KEY) || "";
+  } catch {
+    return "";
+  }
+}
+
+/** Reactive token — a single shared ref across the app. */
+const token = ref(read());
+
+/** Plain accessor for the production fetch adapter (avoids importing Vue there). */
+export function getToken() {
+  return token.value;
+}
+
+export function setToken(value) {
+  const v = value || "";
+  token.value = v;
+  try {
+    if (v) localStorage.setItem(KEY, v);
+    else localStorage.removeItem(KEY);
+  } catch {
+    /* storage unavailable in sandbox — the ref still drives the UI this session */
+  }
+}
+
+export function clearToken() {
+  setToken("");
+}
+
+export function useAuth() {
+  return {
+    token,
+    mode: MODE,
+    isPreview: MODE === "preview",
+    /** True when the app may talk to the API — always true in preview. */
+    isAuthed: () => MODE === "preview" || !!token.value,
+    setToken,
+    clearToken,
+  };
+}

package/dist/board/state/useBoard.js

@@ -0,0 +1,149 @@
+/**
+ * Board store — cards + lanes polling and operator actions.  ❌ FROZEN SEAM.
+ *
+ * Frozen return surface (the seam the UI is built against):
+ *   { cards, lanes, loading, error, laneFilter, includeArchived,
+ *     byStatus, statuses, laneName, start, stop, actions }
+ *
+ * A single shared instance (module singleton) so the board view and any header
+ * share one poll loop.
+ *
+ * @typedef {import('../api/contract.js').BoardCard} BoardCard
+ */
+
+import { ref, computed } from "../vendor/vue.esm-browser.js";
+import { api } from "../api/api.js";
+import { POLL_INTERVAL_MS, CARD_STATUSES } from "../config.js";
+
+let singleton = null;
+
+export function useBoard() {
+  if (singleton) return singleton;
+
+  const cards = ref([]);
+  const lanes = ref([]);
+  const loading = ref(false);
+  const error = ref(null);
+  const laneFilter = ref(null); // null = all lanes
+  const includeArchived = ref(false);
+  let timer = null;
+
+  async function refresh() {
+    try {
+      error.value = null;
+      const [c, l] = await Promise.all([
+        api.listCards({
+          includeArchived: includeArchived.value,
+          ...(laneFilter.value != null ? { lane: laneFilter.value } : {}),
+        }),
+        api.listLanes(),
+      ]);
+      cards.value = c;
+      lanes.value = l;
+    } catch (e) {
+      error.value = (e && e.message) || String(e);
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  async function load() {
+    loading.value = true;
+    await refresh();
+  }
+
+  function start() {
+    stop();
+    load();
+    timer = setInterval(() => {
+      if (typeof document === "undefined" || document.visibilityState === "visible") refresh();
+    }, POLL_INTERVAL_MS);
+  }
+
+  function stop() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+
+  /** Cards grouped by status, each group priority-desc then oldest-first. */
+  const byStatus = computed(() => {
+    const groups = {};
+    for (const s of CARD_STATUSES) groups[s] = [];
+    for (const card of cards.value) (groups[card.status] ||= []).push(card);
+    for (const s of Object.keys(groups)) {
+      groups[s].sort((a, b) => b.priority - a.priority || (a.createdAt < b.createdAt ? -1 : 1));
+    }
+    return groups;
+  });
+
+  const laneName = (threadId) =>
+    lanes.value.find((l) => l.threadId === threadId)?.name ?? `Thread ${threadId}`;
+
+  const actions = {
+    setLaneFilter: (v) => {
+      laneFilter.value = v;
+      return refresh();
+    },
+    setIncludeArchived: (v) => {
+      includeArchived.value = v;
+      return refresh();
+    },
+    create: async (card) => {
+      const c = await api.createCard(card);
+      await refresh();
+      return c;
+    },
+    move: async (id, status) => {
+      const c = await api.updateCard(id, { status });
+      await refresh();
+      return c;
+    },
+    stop: async (id) => {
+      const c = await api.stopCard(id);
+      await refresh();
+      return c;
+    },
+    archive: async (id) => {
+      const c = await api.updateCard(id, { archivedAt: new Date().toISOString() });
+      await refresh();
+      return c;
+    },
+    remove: async (id) => {
+      await api.deleteCard(id);
+      await refresh();
+    },
+    addLane: async (name) => {
+      const l = await api.createLane(name);
+      await refresh();
+      return l;
+    },
+    renameLane: async (id, name) => {
+      const l = await api.updateLane(id, { name });
+      await refresh();
+      return l;
+    },
+    removeLane: async (id) => {
+      await api.deleteLane(id);
+      await refresh();
+    },
+    refresh,
+  };
+
+  singleton = {
+    cards,
+    lanes,
+    loading,
+    error,
+    laneFilter,
+    includeArchived,
+    byStatus,
+    statuses: CARD_STATUSES,
+    laneName,
+    start,
+    stop,
+    actions,
+  };
+  return singleton;
+}

package/dist/board/state/useBuilder.js

@@ -0,0 +1,98 @@
+/**
+ * Card-builder draft store.  ❌ FROZEN SEAM.
+ *
+ * P0 is the placeholder builder SHELL: the WHAT fields (title / description /
+ * acceptance) plus type / lane / priority, submitted via the create endpoint.
+ * The schema-driven HOW builder + compiled preview arrive in P1 — this surface
+ * stays stable so the UI is not rewired then. It is extended ADDITIVELY here
+ * with { policySchema, presets } (the How-step field schema + presets, sourced
+ * from the editable schema/policy.js via the data seam); the original returns
+ * ({ draft, lanes, profiles, types, submitting, error, load, reset, submit }) are
+ * unchanged.
+ */
+
+import { reactive, ref } from "../vendor/vue.esm-browser.js";
+import { api } from "../api/api.js";
+
+export function useBuilder() {
+  const draft = reactive({
+    title: "",
+    description: "",
+    acceptance: "",
+    type: "chore",
+    laneThreadId: null,
+    priority: 0,
+  });
+
+  const lanes = ref([]);
+  const profiles = ref({});
+  const types = ref([]);
+  const submitting = ref(false);
+  const error = ref(null);
+  // How-step schema + presets (additive; from schema/policy.js via the seam).
+  const policySchema = ref([]);
+  const presets = ref([]);
+
+  async function load() {
+    try {
+      const [l, p] = await Promise.all([api.listLanes(), api.getProfiles()]);
+      lanes.value = l;
+      profiles.value = p;
+      types.value = Object.keys(p);
+      if (draft.laneThreadId == null && l.length) draft.laneThreadId = l[0].threadId;
+    } catch (e) {
+      error.value = (e && e.message) || String(e);
+    }
+    // Additive, non-fatal: the schema-driven How controls. In production the real
+    // API may not implement these yet (P1 TODO in api/client.js) — degrade to a
+    // schema-less builder rather than failing the whole load.
+    try {
+      const [schema, ps] = await Promise.all([api.getPolicySchema(), api.getPresets()]);
+      policySchema.value = schema;
+      presets.value = ps;
+    } catch {
+      /* schema/presets unavailable — builder still renders the WHAT step */
+    }
+  }
+
+  function reset() {
+    Object.assign(draft, {
+      title: "",
+      description: "",
+      acceptance: "",
+      type: "chore",
+      priority: 0,
+    });
+  }
+
+  /** @returns {Promise<import('../api/contract.js').BoardCard|null>} */
+  async function submit() {
+    error.value = null;
+    if (!draft.title.trim()) {
+      error.value = "Title is required";
+      return null;
+    }
+    if (draft.laneThreadId == null) {
+      error.value = "A lane is required";
+      return null;
+    }
+    submitting.value = true;
+    try {
+      return await api.createCard({
+        title: draft.title.trim(),
+        description: draft.description,
+        acceptance: draft.acceptance,
+        type: draft.type,
+        laneThreadId: Number(draft.laneThreadId),
+        priority: Number(draft.priority) || 0,
+      });
+    } catch (e) {
+      error.value = (e && e.message) || String(e);
+      return null;
+    } finally {
+      submitting.value = false;
+    }
+  }
+
+  return { draft, lanes, profiles, types, policySchema, presets, submitting, error, load, reset, submit };
+}

package/dist/board/state/useCard.js

@@ -0,0 +1,67 @@
+/**
+ * Single-card store — card + comments + worker health, plus operator actions.
+ * ❌ FROZEN SEAM.
+ *
+ * Frozen return surface: { card, comments, running, loading, error, load, actions }.
+ * `running` is null unless the card is in_progress (P3 adds richer health/logs).
+ */
+
+import { ref } from "../vendor/vue.esm-browser.js";
+import { api } from "../api/api.js";
+
+export function useCard(cardId) {
+  const id = Number(cardId);
+  const card = ref(null);
+  const comments = ref([]);
+  const running = ref(null);
+  const loading = ref(false);
+  const error = ref(null);
+
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const detail = await api.getCard(id);
+      card.value = detail.card;
+      comments.value = detail.comments;
+      if (detail.card.status === "in_progress" && detail.card.workerThreadId != null) {
+        running.value = await api.threadRunning(detail.card.workerThreadId).catch(() => null);
+      } else {
+        running.value = null;
+      }
+    } catch (e) {
+      error.value = (e && e.message) || String(e);
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  const actions = {
+    reload: load,
+    comment: async (content) => {
+      await api.addComment(id, content);
+      await load();
+    },
+    move: async (status) => {
+      await api.updateCard(id, { status });
+      await load();
+    },
+    stop: async () => {
+      await api.stopCard(id);
+      await load();
+    },
+    archive: async () => {
+      await api.updateCard(id, { archivedAt: new Date().toISOString() });
+      await load();
+    },
+    remove: async () => {
+      await api.deleteCard(id);
+    },
+    save: async (patch) => {
+      await api.updateCard(id, patch);
+      await load();
+    },
+  };
+
+  return { card, comments, running, loading, error, load, actions };
+}