@hanzo/rooms 0.1.0

package/dist/lib/todo.js

@@ -0,0 +1,379 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * THE COLUMNS, and they are the platform's own closed set rather than a list a
+ * reader types. `newIssue` names them: "backlog, todo, in_progress, done or
+ * canceled". A column that is not one of these cannot be moved to, because the
+ * move is a relabel and the forge would not know the label.
+ */
+export const COLUMNS = [
+    { id: 'backlog', label: 'Backlog' },
+    { id: 'todo', label: 'To do' },
+    { id: 'in_progress', label: 'Doing' },
+    { id: 'done', label: 'Done' },
+    { id: 'canceled', label: 'Canceled' },
+];
+/** The priorities the store accepts, loudest first. */
+export const PRIORITIES = ['urgent', 'high', 'medium', 'low', 'none'];
+const STORAGE_KEY = 'hanzo_board_cards';
+export const DEFAULT_CARDS = [
+    {
+        id: 'hanzo-1',
+        identifier: 'HANZO#1',
+        projectKey: 'hanzo',
+        number: 1,
+        kind: 'task',
+        source: 'agent',
+        title: 'Deploy 3D Gaussian Splat Whale & Video Reconstructor',
+        description: '- [x] Build 148,000 particle oceanic kinematics\n- [x] Integrate real-time WebXR canvas\n- [x] Add custom .mp4 / .ply dropzone',
+        status: 'done',
+        priority: 'high',
+        assignee: 'Architect',
+        labels: ['3d', 'splat', 'webxr'],
+        createdAt: Date.now() - 3600000 * 4,
+        updatedAt: Date.now() - 3600000 * 2,
+    },
+    {
+        id: 'hanzo-2',
+        identifier: 'HANZO#2',
+        projectKey: 'hanzo',
+        number: 2,
+        kind: 'task',
+        source: 'team',
+        title: 'Sovereign Cloud Exec Runner & MicroVM Sandbox',
+        description: '- [x] Mount /v1/exec native command runner\n- [x] Add gVisor runtime container isolation\n- [ ] Add real-time PTY terminal streaming',
+        status: 'in_progress',
+        priority: 'urgent',
+        assignee: 'Satoshi',
+        labels: ['cloud', 'microvm', 'sandbox'],
+        createdAt: Date.now() - 3600000 * 8,
+        updatedAt: Date.now() - 3600000 * 1,
+    },
+    {
+        id: 'hanzo-3',
+        identifier: 'HANZO#3',
+        projectKey: 'hanzo',
+        number: 3,
+        kind: 'task',
+        source: 'team',
+        title: 'Pay & Billing Architecture Unification',
+        description: '- [x] Fix root basePath for billing.hanzo.ai\n- [x] Re-route commerceUrl to api.hanzo.ai\n- [ ] Enable multi-org ledger checkout',
+        status: 'todo',
+        priority: 'high',
+        assignee: 'Turing',
+        labels: ['billing', 'pay', 'checkout'],
+        createdAt: Date.now() - 3600000 * 12,
+        updatedAt: Date.now() - 3600000 * 3,
+    },
+    {
+        id: 'hanzo-4',
+        identifier: 'HANZO#4',
+        projectKey: 'hanzo',
+        number: 4,
+        kind: 'task',
+        source: 'agent',
+        title: 'Autonomous Swarm Collaboration in Channels',
+        description: '- [x] Route multi-agent turns with voice dictation\n- [ ] Sync forge issues directly into channel threads',
+        status: 'backlog',
+        priority: 'medium',
+        assignee: 'Ada',
+        labels: ['swarm', 'chat', 'agents'],
+        createdAt: Date.now() - 3600000 * 24,
+        updatedAt: Date.now() - 3600000 * 12,
+    },
+];
+function getLocalCards(key) {
+    if (typeof window === 'undefined')
+        return DEFAULT_CARDS;
+    try {
+        const raw = window.localStorage.getItem(STORAGE_KEY);
+        const cards = raw ? JSON.parse(raw) : DEFAULT_CARDS;
+        const list = Array.isArray(cards) && cards.length > 0 ? cards : DEFAULT_CARDS;
+        if (!key || key === 'all')
+            return list;
+        const filtered = list.filter((c) => c.projectKey?.toLowerCase() === key.toLowerCase());
+        if (filtered.length > 0)
+            return filtered;
+        return [
+            {
+                id: `${key}-1`,
+                identifier: `${key.toUpperCase()}#1`,
+                projectKey: key,
+                number: 1,
+                kind: 'task',
+                source: 'team',
+                title: `Welcome to ${key} board`,
+                description: '- [ ] Add tasks\n- [ ] Configure workflow',
+                status: 'todo',
+                priority: 'medium',
+                labels: [key],
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            },
+        ];
+    }
+    catch {
+        return DEFAULT_CARDS;
+    }
+}
+function saveLocalCards(cards) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        const raw = window.localStorage.getItem(STORAGE_KEY);
+        const existing = raw ? JSON.parse(raw) : DEFAULT_CARDS;
+        const map = new Map();
+        for (const c of existing)
+            map.set(c.id || c.identifier, c);
+        for (const c of cards)
+            map.set(c.id || c.identifier, c);
+        window.localStorage.setItem(STORAGE_KEY, JSON.stringify(Array.from(map.values())));
+    }
+    catch { }
+}
+/** Every card on the org's board, or one project's when `key` is given. */
+export async function board(client, params = {}, signal) {
+    if (!client)
+        return getLocalCards(params.key);
+    try {
+        const query = {};
+        if (params.key)
+            query.key = params.key;
+        if (params.status)
+            query.status = params.status;
+        if (params.label)
+            query.label = params.label;
+        if (params.scheduled !== undefined)
+            query.scheduled = String(params.scheduled);
+        const out = await client.http.json({
+            path: '/v1/todo/board',
+            query,
+            signal,
+        });
+        const fetched = rows(out);
+        // A SUCCESSFUL READ IS THE ANSWER, EMPTY OR NOT. An org whose board holds
+        // no cards yet is a fact about the org — the empty state a reader is owed
+        // — not a fact this browser failed to learn. Treating the two alike is
+        // what used to hand a brand-new org four invented demo cards on its first
+        // paint: the store answered `[]`, this fell to the local cache, and the
+        // cache had never been written for that org, so `DEFAULT_CARDS` stood in
+        // as if it were real. Only a request that never came back reaches the
+        // fallback below.
+        if (fetched.length > 0)
+            saveLocalCards(fetched);
+        return fetched;
+    }
+    catch (e) {
+        const code = e?.status;
+        if (typeof code === 'number' && code >= 500)
+            throw e;
+        return getLocalCards(params.key);
+    }
+}
+/** The boards themselves — a project is a repository on the forge. */
+export async function projects(client, signal) {
+    const fallback = [
+        { key: 'hanzo', name: 'Hanzo Core' },
+        { key: 'cloud', name: 'Hanzo Cloud' },
+        { key: 'swarm', name: 'Agent Swarm' },
+        { key: 'dev', name: 'Hanzo Dev' },
+    ];
+    if (!client)
+        return fallback;
+    try {
+        const [todoPs, devPs] = await Promise.all([
+            client.http
+                .json({
+                path: '/v1/todo/projects',
+                signal,
+            })
+                .catch(() => null),
+            client.http
+                .json({
+                path: '/v1/projects',
+                signal,
+            })
+                .catch(() => null),
+        ]);
+        const map = new Map();
+        for (const f of fallback)
+            map.set(f.key, f);
+        const todoList = rows(todoPs);
+        for (const p of todoList ?? []) {
+            if (p?.key)
+                map.set(p.key, { key: p.key, name: p.name || p.key });
+        }
+        for (const p of devPs ?? []) {
+            const k = (p.name || p.id).toLowerCase().replace(/[^a-z0-9]+/g, '-');
+            if (k && !map.has(k))
+                map.set(k, { key: k, name: p.name || k });
+        }
+        return Array.from(map.values());
+    }
+    catch {
+        return fallback;
+    }
+}
+/** Opens a card in a column. */
+export async function open(client, key, card, signal) {
+    const current = getLocalCards();
+    const nextNum = current.length > 0 ? Math.max(...current.map((c) => c.number || 0)) + 1 : 1;
+    const newCard = {
+        id: `${key}-${nextNum}-${Date.now()}`,
+        identifier: `${key.toUpperCase()}#${nextNum}`,
+        projectKey: key || 'hanzo',
+        number: nextNum,
+        kind: 'task',
+        source: 'team',
+        title: card.title,
+        description: card.description ?? '',
+        status: card.status ?? 'backlog',
+        priority: card.priority ?? 'medium',
+        labels: card.labels ?? ['task'],
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+    };
+    if (client) {
+        try {
+            const created = await client.http.json({
+                method: 'POST',
+                path: `/v1/todo/projects/${encodeURIComponent(key)}/issues`,
+                body: card,
+                signal,
+            });
+            if (created?.id) {
+                saveLocalCards([created, ...current]);
+                return created;
+            }
+        }
+        catch {
+            // Fall through to local save
+        }
+    }
+    saveLocalCards([newCard, ...current]);
+    return newCard;
+}
+/**
+ * Edits a card. Absent fields are left alone.
+ */
+export async function edit(client, key, num, patch, signal) {
+    const current = getLocalCards();
+    let updatedCard = null;
+    const updatedList = current.map((c) => {
+        if (c.number === num || c.identifier.endsWith(`#${num}`)) {
+            updatedCard = {
+                ...c,
+                ...patch,
+                updatedAt: Date.now(),
+            };
+            return updatedCard;
+        }
+        return c;
+    });
+    if (updatedCard) {
+        saveLocalCards(updatedList);
+    }
+    if (client) {
+        try {
+            const serverUpdated = await client.http.json({
+                method: 'PATCH',
+                path: `/v1/todo/projects/${encodeURIComponent(key)}/issues/${num}`,
+                body: patch,
+                signal,
+            });
+            if (serverUpdated?.id) {
+                return serverUpdated;
+            }
+        }
+        catch { }
+    }
+    return updatedCard ?? current[0];
+}
+/** Takes the card — the store's own verb for who is doing the work. */
+export async function claim(client, key, num, signal) {
+    if (client) {
+        try {
+            return await client.http.json({
+                method: 'POST',
+                path: `/v1/todo/projects/${encodeURIComponent(key)}/issues/${num}/claim`,
+                body: {},
+                signal,
+            });
+        }
+        catch { }
+    }
+    return edit(client, key, num, { assignee: 'me' }, signal);
+}
+/** The rows out of whichever envelope the route used. */
+function rows(out) {
+    if (Array.isArray(out))
+        return out;
+    return out?.issues ?? out?.items ?? out?.projects ?? [];
+}
+const TASK = /^(\s*)[-*]\s+\[([ xX])\]\s?(.*)$/;
+/**
+ * The task items in a description.
+ */
+export function steps(description = '') {
+    const out = [];
+    description.split('\n').forEach((raw, line) => {
+        const m = TASK.exec(raw);
+        if (m)
+            out.push({ done: m[2].toLowerCase() === 'x', text: m[3].trim(), line });
+    });
+    return out;
+}
+/** The description with one step's box flipped, and every other line untouched. */
+export function tick(description, line, done) {
+    const lines = description.split('\n');
+    const m = TASK.exec(lines[line] ?? '');
+    if (!m)
+        return description;
+    lines[line] = `${m[1]}- [${done ? 'x' : ' '}] ${m[3]}`;
+    return lines.join('\n');
+}
+/** The description with one more step at the end of its list. */
+export function addStep(description, text) {
+    const body = description.trimEnd();
+    return `${body}${body ? '\n' : ''}- [ ] ${text.trim()}`;
+}
+export const SETTLED = new Set(['done', 'canceled']);
+export function sift(cards, want, me, agents) {
+    const now = Date.now() / 1000;
+    const within = { day: 1, week: 7, month: 31 };
+    return cards.filter((c) => {
+        if (want.holder === 'none' && c.assignee)
+            return false;
+        if (want.holder === 'me' && c.assignee !== me)
+            return false;
+        if (want.holder && !['none', 'me'].includes(want.holder) && c.assignee !== want.holder)
+            return false;
+        if (want.by === 'agent' && !(c.source === 'agent' || (c.assignee && agents?.has(c.assignee))))
+            return false;
+        if (want.by === 'person' && (c.source === 'agent' || (c.assignee && agents?.has(c.assignee))))
+            return false;
+        if (want.state === 'done' && !SETTLED.has(c.status))
+            return false;
+        if (want.state === 'open' && SETTLED.has(c.status))
+            return false;
+        if (want.due === 'none' && c.dueAt)
+            return false;
+        if (want.due && want.due !== 'none') {
+            if (!c.dueAt)
+                return false;
+            if (want.due === 'late' && c.dueAt >= now)
+                return false;
+            if (want.due !== 'late' && !(c.dueAt >= now && c.dueAt <= now + within[want.due] * 86400))
+                return false;
+        }
+        if (want.labels?.length && !want.labels.some((l) => c.labels.includes(l)))
+            return false;
+        if (want.active && !(c.updatedAt >= now - want.active * 86400))
+            return false;
+        if (want.text) {
+            const hay = `${c.title} ${c.description ?? ''}`.toLowerCase();
+            if (!hay.includes(want.text.toLowerCase()))
+                return false;
+        }
+        return true;
+    });
+}

package/dist/look.d.ts

@@ -0,0 +1 @@
+export declare function Look(): import("react").JSX.Element;

package/dist/look.js

@@ -0,0 +1,21 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * HOW THE APP LOOKS.
+ *
+ * One panel, `@hanzo/appearance`'s: theme, type, spacing, corners and accent,
+ * resolved for the organization in scope and kept with the person's IAM
+ * account, so it follows them to every Hanzo surface. The theme used to be a
+ * row of its own here, written to next-themes and to IAM's per-subject key —
+ * two more places a theme lived, neither of which crossed an origin.
+ */
+import { Text, YStack } from "@hanzo/ui";
+import { Appearance } from "@hanzo/appearance";
+import { useIam } from "@hanzo/iam/react";
+import { iam } from "./lib/api.js";
+import { useOrg } from "./host.js";
+export function Look() {
+    const { accessToken } = useIam();
+    const org = useOrg();
+    return (_jsxs(YStack, { gap: "$3", maxW: 420, children: [_jsx(Text, { fontSize: "$3", color: "$soft", children: "Kept with your account, so it follows you to every Hanzo surface." }), _jsx(Appearance, { org: org.id, orgName: org.name || "Hanzo", account: { base: iam(), token: accessToken ?? undefined } })] }));
+}

package/dist/meters.d.ts

@@ -0,0 +1,8 @@
+import { type Limits } from './lib/limits.js';
+/** What a spent month says. */
+export declare const SPENT = "Monthly included usage is used; Enso and Zen keep answering.";
+/** The plan holder's windows, or nothing where the limits name none. */
+export declare function Meters({ limits, large }: {
+    limits: Limits;
+    large?: boolean;
+}): import("react").JSX.Element;

package/dist/meters.js

@@ -0,0 +1,31 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// A plan's windows as bars of what is LEFT: the five-hour session, the day and
+// the billing month, each with when it starts over. Shares only — a plan is a
+// subscription with limits, never a balance, so no count and no amount is
+// drawn. The month spent refuses nothing (Enso and Zen keep answering), which
+// is why it is a quiet line under the bars rather than a warning.
+//
+// One component for the composer's foot and for the usage page: `large` is the
+// page's size. Each bar is drawn above its words so the three bars stay on one
+// line however the words under them wrap on a phone.
+import { Progress, Text, XStack, YStack } from '@hanzo/ui';
+import { clock, day, left } from './lib/limits.js';
+/** What a spent month says. */
+export const SPENT = 'Monthly included usage is used; Enso and Zen keep answering.';
+const WINDOWS = [
+    ['session', 'Session', (s) => (s.resets_at ? `resets ${clock(s.resets_at)}` : '')],
+    ['day', 'Today', (s) => (s.resets_at ? `resets ${clock(s.resets_at)}` : '')],
+    ['month', 'This month', (s) => (s.resets_at ? `renews ${day(s.resets_at)}` : '')],
+];
+/** The plan holder's windows, or nothing where the limits name none. */
+export function Meters({ limits, large = false }) {
+    const shown = WINDOWS.flatMap(([key, name, when]) => {
+        const span = limits[key];
+        return span ? [{ name, span, when: when(span) }] : [];
+    });
+    if (!shown.length)
+        return null;
+    const size = large ? '$3' : '$1';
+    return (_jsxs(YStack, { gap: large ? '$4' : '$1.5', width: "100%", minW: 0, children: [_jsx(XStack, { gap: large ? '$6' : '$3', rowGap: "$4", width: "100%", flexWrap: large ? 'wrap' : 'nowrap', children: shown.map(({ name, span, when }) => (_jsxs(YStack, { flex: 1, minW: large ? 200 : 0, gap: large ? '$2' : '$1', children: [_jsx(Progress, { value: left(span), height: large ? 8 : 4, minW: 0, "aria-label": name }), _jsxs(XStack, { flexWrap: "wrap", columnGap: "$1.5", items: "baseline", minW: 0, children: [_jsx(Text, { fontSize: size, color: large ? '$ink' : '$soft', numberOfLines: 1, children: name }), _jsxs(XStack, { children: [_jsxs(Text, { fontSize: size, color: "$ink", fontWeight: "500", fontVariant: ['tabular-nums'], children: [left(span), "%"] }), _jsx(Text, { fontSize: size, color: "$ink", display: large ? 'flex' : 'none', $sm: { display: 'flex' }, children: "\u00A0left" })] }), when ? (_jsx(Text, { fontSize: large ? '$2' : '$1', color: "$soft", numberOfLines: 1, children: when })) : null] })] }, name))) }), limits.month && limits.month.percent >= 100 ? (_jsx(Text, { fontSize: large ? '$2' : '$1', color: "$soft", children: SPENT })) : null] }));
+}

package/dist/model.d.ts

@@ -0,0 +1,4 @@
+/** Make `model` the chat default, in this browser, for every open chat. */
+export declare function remember(model: string): void;
+/** The signed-in chat default, shared by Settings and every new conversation. */
+export declare function useModel(): readonly [string, (model: string) => void];

package/dist/model.js

@@ -0,0 +1,44 @@
+"use client";
+import { useEffect, useState } from "react";
+import { ENSO } from "./lib/ai.js";
+const KEY = "hanzo.chat.model";
+const CHANGE = "hanzo:model";
+function read() {
+    if (typeof window === "undefined")
+        return ENSO;
+    try {
+        return window.localStorage.getItem(KEY) || ENSO;
+    }
+    catch {
+        return ENSO;
+    }
+}
+/** Make `model` the chat default, in this browser, for every open chat. */
+export function remember(model) {
+    try {
+        window.localStorage.setItem(KEY, model);
+    }
+    catch {
+        // A private browser may refuse persistence; this tab still keeps the choice.
+    }
+    window.dispatchEvent(new Event(CHANGE));
+}
+/** The signed-in chat default, shared by Settings and every new conversation. */
+export function useModel() {
+    const [model, setModel] = useState(ENSO);
+    useEffect(() => {
+        setModel(read());
+        const sync = () => setModel(read());
+        window.addEventListener("storage", sync);
+        window.addEventListener(CHANGE, sync);
+        return () => {
+            window.removeEventListener("storage", sync);
+            window.removeEventListener(CHANGE, sync);
+        };
+    }, []);
+    const choose = (next) => {
+        setModel(next);
+        remember(next);
+    };
+    return [model, choose];
+}

package/dist/network.d.ts

@@ -0,0 +1,64 @@
+import { type LucideIcon } from 'lucide-react';
+interface Net {
+    /** What a person calls it. */
+    name: string;
+    /** The brand's own colour, `#rrggbb`, where a silhouette needs a ground. */
+    hex?: string;
+    /** The 24x24 silhouette, where simple-icons ships one. */
+    path?: string;
+    /** The vendor's own SVG, where simple-icons ships none and the vendor
+     *  publishes one that can be fetched. */
+    art?: string;
+    /** Set where the row is a capability rather than a brand. */
+    glyph?: LucideIcon;
+}
+/** What we know about a channel key, including one nobody taught us — which is
+ *  a name and nothing else, and lands on the same initial Yahoo does. */
+export declare function of(channel: string): Net;
+/**
+ * WHAT TO CALL THE SPEAKER.
+ *
+ * NOTHING THAT ARRIVES HERE CARRIES A NAME. `sender` is the network's own id
+ * for the person — "U031THJJ7F1" on Slack, a snowflake on Discord, a GUID on
+ * Teams — because that is what every adapter puts there; the envelope declares
+ * a `Display` beside it (cloud apps/channels/envelope.go) and not one of the
+ * five adapters fills it, so no name is stored and none is served.
+ * `senderUser` is not the name either: it is the linked account's OIDC `sub`,
+ * which IAM mints from a UUID, so it identifies a Hanzo account without saying
+ * who holds it — printing it swaps one opaque string for another.
+ *
+ * An id printed where a name goes READS as a name, and a reader takes
+ * "U031THJJ7F1" for what somebody calls themselves. So the id is MARKED as an
+ * id — '@' is how every one of these networks writes a handle it has not
+ * resolved — and it is kept, because it is the only thing that tells two
+ * speakers apart. A room holds messages from many people (useInbox groups by
+ * channel and room, never by sender), so dropping it renders every line of a
+ * group identically and a reader cannot tell who said what. Only where no id
+ * arrived at all is the network the one thing left to say. The day the
+ * platform resolves a name, this is where it goes.
+ */
+export declare const speaker: (channel: string, sender?: string) => string;
+/** A room is named by its own address, not by whoever spoke in it last: the
+ *  handle for a DM, the network's room id otherwise. */
+export declare function roomName(room: {
+    channel: string;
+    roomId?: string;
+    roomKind: string;
+    last: {
+        sender?: string;
+    };
+}): string;
+/**
+ * One channel's mark, at whatever size the caller has room for.
+ *
+ * A rounded square rather than a disc, because in the Inbox the face beside it
+ * IS a disc and two circles the same size read as two people rather than as a
+ * person and where they wrote from. The Channels grid draws the same mark at
+ * 46px, which is the size the vendor files were cut for and still the size the
+ * simple-icons silhouettes were meant to scale to.
+ */
+export declare function Network({ channel, size }: {
+    channel: string;
+    size?: number;
+}): import("react").JSX.Element;
+export {};