@fungi.computer/tourtois 0.0.0-stage → 0.0.1

package/dist/app-menus.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Button } from "@fungi.computer/caps/components/button";
+import { useEffect, useMemo, useRef, useState, useSyncExternalStore, } from "react";
+import { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, } from "@fungi.computer/caps/components/dropdown-menu";
+const emptyMenu = Object.freeze([]);
+const noSubscription = () => () => undefined;
+function outcomeMessage(outcome) {
+    if (outcome.status === "handled")
+        return null;
+    if (outcome.status === "unavailable")
+        return outcome.reason;
+    if (outcome.status === "failed")
+        return outcome.error.message;
+    if (outcome.status === "closed")
+        return "This App has closed.";
+    return "This App action is no longer available.";
+}
+/** Render the focused App's Whistle commands in the desktop's system bar. */
+export function AppMenus({ host, container: popover, }) {
+    const menu = useSyncExternalStore(host?.subscribe ?? noSubscription, host?.menu ?? (() => emptyMenu), () => emptyMenu);
+    const [pending, setPending] = useState(null);
+    const [message, setMessage] = useState(null);
+    const invocation = useRef(null);
+    const categories = useMemo(() => {
+        const grouped = new Map();
+        for (const command of menu) {
+            // This menu invokes argument-free actions. Typed handoffs remain in the
+            // host graph for programmatic discovery, not as broken clickable rows.
+            if (command.action?.inputSchema !== undefined)
+                continue;
+            const commands = grouped.get(command.category) ?? [];
+            commands.push(command);
+            grouped.set(command.category, commands);
+        }
+        return [...grouped];
+    }, [menu]);
+    useEffect(() => {
+        invocation.current?.abort();
+        invocation.current = null;
+        setPending(null);
+        setMessage(null);
+        return () => {
+            invocation.current?.abort();
+            invocation.current = null;
+        };
+    }, []);
+    if (!host || categories.length === 0)
+        return null;
+    return (_jsxs(_Fragment, { children: [categories.map(([category, commands]) => (_jsxs(DropdownMenu, { modal: false, children: [_jsx(DropdownMenuTrigger, { render: _jsx(Button, { size: "menubar", variant: "ghost" }), children: category }), _jsx(DropdownMenuContent, { align: "start", finalFocus: false, container: popover, children: commands.map((command) => {
+                            const unavailable = command.availability.status === "unavailable";
+                            return (_jsx(DropdownMenuItem, { disabled: pending !== null || unavailable, title: unavailable
+                                    ? command.availability.reason
+                                    : command.description, onSelect: () => {
+                                    const controller = new AbortController();
+                                    invocation.current = controller;
+                                    setPending(command.commandId);
+                                    setMessage(null);
+                                    void host
+                                        .execute(command.commandId, {
+                                        origin: "menu",
+                                        signal: controller.signal,
+                                    })
+                                        .then((outcome) => {
+                                        if (invocation.current === controller)
+                                            setMessage(outcomeMessage(outcome));
+                                    })
+                                        .catch((cause) => {
+                                        console.error("App command failed", cause);
+                                        if (invocation.current === controller &&
+                                            !controller.signal.aborted)
+                                            setMessage("This App action failed.");
+                                    })
+                                        .finally(() => {
+                                        if (invocation.current !== controller)
+                                            return;
+                                        invocation.current = null;
+                                        setPending(null);
+                                    });
+                                }, children: command.title }, command.commandId));
+                        }) })] }, category))), message ? (_jsx("span", { className: "tourtois-system-command-status", role: "status", children: message })) : null] }));
+}

package/dist/app-open-url.d.ts

@@ -0,0 +1,8 @@
+import { type AppOpenInput } from "@fungi.computer/agar/apps";
+export type AppOpenUrlSearch = AppOpenInput;
+/** URLSearchParams owns decoding; Agar owns the bounded intent grammar. */
+export declare function appOpenUrlSearch(search: string): AppOpenUrlSearch | null;
+export declare function appOpenInputFromUrl(search: string): AppOpenInput | null;
+/** Keep unrelated query fields while consuming or dropping a bad handoff. */
+export declare function withoutAppOpenUrlSearch(search: string): string;
+export declare function cleanInvalidAppOpenUrlSearch(search: string): string;

package/dist/app-open-url.js

@@ -0,0 +1,63 @@
+import { appOpenInputSchema, } from "@fungi.computer/agar/apps";
+import * as Schema from "effect/Schema";
+const handoffFields = ["open", "app", "intent", "text"];
+const handoffBaseFields = handoffFields;
+/** URLSearchParams owns decoding; Agar owns the bounded intent grammar. */
+export function appOpenUrlSearch(search) {
+    const parameters = new URLSearchParams(search);
+    if (handoffFields.some((field) => parameters.getAll(field).length > 1) ||
+        parameters.getAll("mode").length > 1)
+        return null;
+    if (parameters.has("open") === parameters.has("app"))
+        return null;
+    const targetKey = parameters.has("app") ? "app" : "open";
+    const kind = parameters.get("intent");
+    const required = kind === "compose"
+        ? [targetKey, "intent", "text"]
+        : kind === "navigate"
+            ? [targetKey, "intent"]
+            : [];
+    if (required.length === 0 || required.some((field) => !parameters.has(field)))
+        return null;
+    let intent = null;
+    if (kind === "compose")
+        intent = { kind, text: parameters.get("text") ?? "" };
+    if (kind === "navigate") {
+        const params = [...parameters.entries()]
+            .filter(([key]) => !handoffBaseFields.includes(key) && key !== "mode")
+            .map(([key, value]) => ({ key, value }));
+        if (params.some(({ key }) => key.length > 64 || key.length === 0) ||
+            new Set(params.map(({ key }) => key)).size !== params.length)
+            return null;
+        intent = { kind, params };
+    }
+    const candidate = parameters.has("app")
+        ? { appId: parameters.get("app"), intent }
+        : { role: parameters.get("open"), intent };
+    return Schema.is(appOpenInputSchema)(candidate) ? candidate : null;
+}
+export function appOpenInputFromUrl(search) {
+    return appOpenUrlSearch(search);
+}
+/** Keep unrelated query fields while consuming or dropping a bad handoff. */
+export function withoutAppOpenUrlSearch(search) {
+    const parameters = new URLSearchParams(search);
+    const isNavigation = parameters.get("intent") === "navigate";
+    for (const field of handoffFields)
+        parameters.delete(field);
+    if (isNavigation) {
+        const remainingKeys = new Set(["mode"]);
+        for (const key of Array.from(parameters.keys()))
+            if (!remainingKeys.has(key))
+                parameters.delete(key);
+    }
+    const remaining = parameters.toString();
+    return remaining ? `?${remaining}` : "";
+}
+export function cleanInvalidAppOpenUrlSearch(search) {
+    const parameters = new URLSearchParams(search);
+    return handoffFields.some((field) => parameters.has(field)) &&
+        appOpenUrlSearch(search) === null
+        ? withoutAppOpenUrlSearch(search)
+        : search;
+}

package/dist/app-surface.d.ts

@@ -0,0 +1,62 @@
+import { type ReactNode } from "react";
+import type { WhistleCommand, WhistleExecutionInput, WhistleExecutionOutcome, WhistleMenuProjection, WhistleSnapshot } from "@fungi.computer/whistle";
+import type { AgentSessionSelection, AppNavigationState, AppStatusItem, FileNavigationInput } from "@fungi.computer/agar";
+import type { AppOpenInput, AppRoleChoice } from "@fungi.computer/agar/apps";
+import type { AppDeclaredCommand } from "@fungi.computer/puffball/app";
+import type { AppWindowMount } from "./app-windows.js";
+/** What one mounted App may raise toward the shell. */
+export type TourtoisAppMountEvents = Readonly<{
+    onComputerChoice?: () => Promise<void>;
+    onAgentSessionSelection: (selection: AgentSessionSelection | null) => Promise<void>;
+    /** A presentation-neutral file handoff to another App. */
+    onNavigation?: (input: FileNavigationInput) => Promise<void>;
+    onAppOpen?: (input: AppOpenInput) => Promise<void>;
+    /** Which App the Team's role routing would open for one role. */
+    onAppRole?: (role: string) => Promise<AppRoleChoice>;
+    onSelectionChanged?: () => Promise<boolean>;
+    /** The App's parsed navigation state for its window chrome. */
+    onNavigationState?: (state: AppNavigationState | null) => void;
+    /** The App's parsed status readouts for its window's status bar. */
+    onStatusItems?: (items: readonly AppStatusItem[]) => void;
+    /**
+     * The App's own document took focus, as when the person clicks into it.
+     * Its sandboxed frame keeps that pointer from this document, so the App's
+     * focus report is what raises its window.
+     */
+    onFocus?: () => void;
+}>;
+export type TourtoisAppSurfaceHost = Readonly<{
+    /** Mount an App and route its presentation-neutral events here. */
+    mount: (container: Parameters<AppWindowMount>[0], launch: Parameters<AppWindowMount>[1], signal: Parameters<AppWindowMount>[2], events: TourtoisAppMountEvents) => ReturnType<AppWindowMount>;
+    /** Select the App whose commands are currently addressable by the shell. */
+    focus?: (surfaceId: string | null) => void;
+    /** Register Tourtois's global shell commands in the shared Whistle graph. */
+    registerShellCommands?: (commands: readonly WhistleCommand<never>[]) => () => void;
+    /** Project Release-advertised rows into Cmd-K before the App is mounted. */
+    registerDirectoryCommands?: (commands: readonly Readonly<{
+        surfaceId: string;
+        appTitle: string;
+        command: AppDeclaredCommand;
+    }>[], run: (surfaceId: string, commandId: string) => Promise<void>) => () => void;
+    /** Commands contributed by the currently focused App window. */
+    menu: () => readonly WhistleMenuProjection[];
+    /** The shell-owned semantic command graph, including every mounted App. */
+    snapshot: () => WhistleSnapshot;
+    /**
+     * Commands active for the current focus: shell rows plus the focused App's
+     * rows. Palette, keys and the command line read this, never the whole graph.
+     */
+    active: () => WhistleSnapshot;
+    /** Execute an active command or an exact host-owned programmatic action. */
+    execute: (commandId: string, input: WhistleExecutionInput) => Promise<WhistleExecutionOutcome>;
+    /** Bind one mounted App's explicit Agent Session selection to the shell. */
+    reportAgentSessionSelection?: (teamId: string, mountId: string, selection: AgentSessionSelection | null) => Promise<void> | void;
+    /** Observe focused App and command-graph changes. */
+    subscribe: (listener: () => void) => () => void;
+}>;
+export declare function AppSurfaceHostProvider({ children, value, }: {
+    children: ReactNode;
+    value: TourtoisAppSurfaceHost | null;
+}): import("react/jsx-runtime").JSX.Element;
+/** The outer authenticated host supplies the isolated App transport. */
+export declare function useAppSurfaceHost(): TourtoisAppSurfaceHost | null;

package/dist/app-surface.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const AppSurfaceHostContext = createContext(null);
+export function AppSurfaceHostProvider({ children, value, }) {
+    return (_jsx(AppSurfaceHostContext.Provider, { value: value, children: children }));
+}
+/** The outer authenticated host supplies the isolated App transport. */
+export function useAppSurfaceHost() {
+    return useContext(AppSurfaceHostContext);
+}

package/dist/app-windows.d.ts

@@ -0,0 +1,107 @@
+import type { AppOpenRequest } from "@fungi.computer/agar";
+import { type WindowHost, type WindowEvents, type WindowProjection, type WindowMount, type WindowManager, type WindowManagerOptions } from "@fungi.computer/oyster/shell/window-manager";
+export type AppLaunchDescriptor = Readonly<{
+    windowId: string;
+    /** Stable presentation identity across default inheritance/customization. */
+    surfaceId: string;
+    installationId: string | null;
+    appId: string;
+    releaseId: string;
+    title: string;
+    href: string;
+    openRequest: AppOpenRequest | null;
+    /** Roles the App's Release declares; the shell's mark follows them. */
+    roles: readonly string[];
+    /** Digest-covered command declarations shown before the App is opened. */
+    commands: readonly import("@fungi.computer/puffball/app").AppDeclaredCommand[];
+    /**
+     * The granted Computers this window's status bar offers the person.
+     * Absent for an App that attaches to no Computer, or while the Team's
+     * Computers cannot be read.
+     */
+    computers?: readonly Readonly<{
+        computerId: string;
+        name: string;
+    }>[];
+}>;
+export type AppWindowHost = WindowHost<AppLaunchDescriptor>;
+export type AppWindowEvents = WindowEvents;
+export type AppWindowProjection = WindowProjection<AppLaunchDescriptor, HTMLElement>;
+export type AppWindowMount = WindowMount<AppLaunchDescriptor, HTMLElement>;
+export type AppWindowManager = WindowManager<AppLaunchDescriptor, HTMLElement>;
+export type AppWindowManagerOptions = Pick<WindowManagerOptions<AppLaunchDescriptor, HTMLElement>, "mount" | "waitForAttachment"> & Readonly<{
+    createContainer?: (launch: AppLaunchDescriptor) => HTMLElement;
+}>;
+export declare const hasVisibleAppWindows: (projection: Readonly<{
+    windows: readonly Readonly<{
+        windowId: string;
+        launch: Readonly<{
+            windowId: string;
+            /** Stable presentation identity across default inheritance/customization. */
+            surfaceId: string;
+            installationId: string | null;
+            appId: string;
+            releaseId: string;
+            title: string;
+            href: string;
+            openRequest: AppOpenRequest | null;
+            /** Roles the App's Release declares; the shell's mark follows them. */
+            roles: readonly string[];
+            /** Digest-covered command declarations shown before the App is opened. */
+            commands: readonly Readonly<{
+                id: string;
+                title: string;
+                category: string;
+                description?: string | undefined;
+                sigil?: string | undefined;
+                projections?: Readonly<{
+                    bindings?: (Readonly<{
+                        order?: number | undefined;
+                    }> & Readonly<{
+                        values: readonly string[];
+                    }>) | undefined;
+                    agent?: (Readonly<{
+                        order?: number | undefined;
+                    }> & Readonly<{
+                        keybind?: string | undefined;
+                    }>) | undefined;
+                    help?: Readonly<{
+                        order?: number | undefined;
+                    }> | undefined;
+                    menu?: Readonly<{
+                        order?: number | undefined;
+                    }> | undefined;
+                    palette?: Readonly<{
+                        order?: number | undefined;
+                    }> | undefined;
+                    slash?: (Readonly<{
+                        order?: number | undefined;
+                    }> & Readonly<{
+                        aliases: readonly string[];
+                    }>) | undefined;
+                }> | undefined;
+            }>[];
+            /**
+             * The granted Computers this window's status bar offers the person.
+             * Absent for an App that attaches to no Computer, or while the Team's
+             * Computers cannot be read.
+             */
+            computers?: readonly Readonly<{
+                computerId: string;
+                name: string;
+            }>[];
+        }>;
+        container: HTMLElement;
+        status: import("@fungi.computer/oyster/shell/window-manager").WindowStatus;
+        generation: number;
+        error?: unknown;
+        cleanupError?: unknown;
+        navigation: Readonly<{
+            canGoBack: boolean;
+            title?: string;
+        }> | null;
+        statusItems: readonly import("@fungi.computer/agar").AppStatusItem[];
+    }>[];
+}>) => boolean;
+/** DOM attachment and App identity belong to the browser host. */
+export declare function createAppWindowManager(options: AppWindowManagerOptions): AppWindowManager;

package/dist/app-windows.js

@@ -0,0 +1,21 @@
+import { createWindowManager, hasVisibleWindows, } from "@fungi.computer/oyster/shell/window-manager";
+export const hasVisibleAppWindows = (hasVisibleWindows);
+/** DOM attachment and App identity belong to the browser host. */
+export function createAppWindowManager(options) {
+    return createWindowManager({
+        ...options,
+        createContainer: options.createContainer ?? (() => document.createElement("div")),
+        isAttached: (container) => container.isConnected,
+        // The offered Computers are the shell's status bar alone; the App never
+        // receives them, so a new offer re-admits nothing.
+        isChromeOnlyChange: (current, next) => JSON.stringify(current.computers) !== JSON.stringify(next.computers) &&
+            JSON.stringify({ ...current, computers: null }) ===
+                JSON.stringify({ ...next, computers: null }),
+        validateReconfiguration: (current, next) => {
+            if (next.appId !== current.appId ||
+                next.surfaceId !== current.surfaceId ||
+                next.releaseId !== current.releaseId)
+                throw new Error("App identity cannot change during window reconfiguration");
+        },
+    });
+}

package/dist/chrome.css

@@ -0,0 +1,153 @@
+/* Tourtois desktop chrome: menu bar, App menus, command dialogs and status. */
+.tourtois-desktop-menu {
+  display: flex;
+  align-items: center;
+  box-sizing: border-box;
+  /* A 48px bar on the Stipe grid: 40px launcher and 32px menu triggers sit
+     on whole 4px and 8px insets. Its rules are inset shadows, so the 1px
+     lines never push the row off the grid. */
+  flex: 0 0 var(--spacing-3xl);
+  height: var(--spacing-3xl);
+  min-height: var(--spacing-3xl);
+  gap: var(--spacing-xs);
+  padding: 0 var(--spacing-sm);
+  background: var(--color-base-200);
+  color: var(--color-base-content);
+  box-shadow:
+    inset 0 1px 0 color-mix(in oklab, white 24%, transparent),
+    inset 0 -1px 0
+      color-mix(in oklab, var(--color-base-content) 14%, var(--color-base-200));
+  font-size: 12px;
+}
+.tourtois-focused-app {
+  min-width: 0;
+  overflow: hidden;
+  font-weight: 750;
+  line-height: var(--spacing-lg);
+  padding-inline: var(--spacing-xs);
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.tourtois-command-palette {
+  display: grid;
+  gap: var(--spacing-sm);
+  max-width: min(44rem, calc(100vw - 1rem));
+  width: min(44rem, calc(100vw - 1rem));
+}
+.tourtois-command-palette-heading {
+  align-items: center;
+  display: flex;
+  font-size: var(--text-lg);
+  font-weight: 650;
+  gap: var(--spacing-sm);
+  padding: var(--spacing-xs) var(--spacing-sm);
+}
+.tourtois-command-palette-heading svg {
+  height: 1.5rem;
+  width: 1.5rem;
+}
+.tourtois-command-palette-item {
+  align-items: center;
+  display: flex;
+  gap: var(--spacing-xs);
+  min-width: 0;
+  width: 100%;
+}
+.tourtois-command-palette-item-icon {
+  display: grid;
+  flex: 0 0 1.5rem;
+  height: 1.5rem;
+  place-items: center;
+  width: 1.5rem;
+}
+.tourtois-command-palette-item-icon svg {
+  height: 1.5rem;
+  width: 1.5rem;
+}
+.tourtois-command-palette-item-title {
+  flex: 1 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.tourtois-command-palette-item small {
+  flex: 0 0 auto;
+  color: var(--stipe-fg-muted);
+  font-size: var(--text-xs);
+  white-space: nowrap;
+}
+.tourtois-command-palette-shortcut {
+  align-items: center;
+  display: flex;
+  flex: 0 0 auto;
+  gap: 0.2rem;
+  justify-content: flex-end;
+  margin-left: auto;
+}
+.tourtois-command-palette-footer {
+  align-items: center;
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--spacing-sm);
+  justify-content: space-between;
+  padding: var(--spacing-xs) var(--spacing-sm) 0;
+}
+.tourtois-command-palette-close-hint {
+  color: var(--stipe-fg-muted);
+  font-size: var(--text-xs);
+}
+.tourtois-command-palette-leader-hint {
+  align-items: center;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.2rem;
+  justify-content: flex-end;
+}
+@media (max-width: 28rem) {
+  .tourtois-command-palette-item small {
+    font-size: 0.6rem;
+    max-width: 4.5rem;
+    text-align: right;
+    white-space: normal;
+  }
+  .tourtois-command-palette-footer {
+    align-items: flex-start;
+    flex-direction: column;
+  }
+  .tourtois-command-palette-leader-hint {
+    justify-content: flex-start;
+  }
+}
+
+@media (max-width: 540px) {
+  .tourtois-desktop-menu {
+    gap: 0;
+  }
+  /* The App surface identifies itself without a clipped repeat in the bar. */
+  .tourtois-focused-app {
+    display: none;
+  }
+}
+
+/* App status actions: flat chips on the picker's surface that keep their
+   size, show a pressed or open state, and go icon-only on a phone. */
+.tourtois-status-chip {
+  flex: none;
+  max-width: none;
+}
+.tourtois-status-chip[aria-pressed="true"],
+.tourtois-status-chip[aria-expanded="true"] {
+  background: var(--color-base-300);
+}
+@media (max-width: 640px) {
+  .tourtois-status-chip:has(> svg) .tourtois-status-chip-label {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+  }
+}

package/dist/command-dialogs.d.ts

@@ -0,0 +1,42 @@
+import { type ReactNode } from "react";
+import type { WhistleSnapshot } from "@fungi.computer/whistle";
+import type { AppDeclaredCommand } from "@fungi.computer/puffball/app";
+import { type AppSurfaceCommandHost } from "@fungi.computer/oyster/shell/command-host";
+/** Current command view and the host-owned dialog visibility. */
+export type ShellCommandState = Readonly<{
+    active: WhistleSnapshot;
+    keysOpen: boolean;
+    /** Open or close the leader-key dialog in the owning shell. */
+    setKeysOpen: (open: boolean) => void;
+    commandLineOpen: boolean;
+    /** Open or close the command palette in the owning shell. */
+    setCommandLineOpen: (open: boolean) => void;
+}>;
+/** One installed App advertised in the shell command palette. */
+export type PaletteApp = Readonly<{
+    commands: readonly AppDeclaredCommand[];
+    name: string;
+    icon?: string | null | undefined;
+    roles: readonly string[];
+    surfaceId: string;
+}>;
+/** Which-key list and `:` line for the focused window, drawn from Caps. */
+export declare function CommandDialogs({ host, state, focusedWindow, directoryApps, onStatus, finalFocus, container: dialog, renderIcon, }: Readonly<{
+    host: Pick<AppSurfaceCommandHost, "execute"> | null;
+    state: ShellCommandState;
+    focusedWindow: Readonly<{
+        launch: Readonly<{
+            appId: string;
+            icon?: string | null | undefined;
+            commands: readonly AppDeclaredCommand[];
+            roles: readonly string[];
+            surfaceId: string;
+            title: string;
+        }>;
+    }> | undefined;
+    directoryApps: readonly PaletteApp[];
+    onStatus: (message: string) => void;
+    finalFocus: () => HTMLElement | null;
+    container: HTMLElement | null;
+    renderIcon: (roles: readonly string[], sigil?: string) => ReactNode;
+}>): React.JSX.Element;