@geteigen/cli 0.0.0-stage → 3.1.0

package/dist/shared/roomContext.js

@@ -0,0 +1,133 @@
+/** Room-scoped repo map + shared memory contracts. */
+export const MEMORY_KINDS = [
+    "goal",
+    "decision",
+    "constraint",
+    "discovery",
+    "handoff",
+    "feedback",
+];
+export const MEMORY_STATUSES = [
+    "active",
+    "proposed",
+    "archived",
+    "superseded",
+];
+export const MEMORY_SOURCES = ["human", "auto", "agent_proposed"];
+export const AUTO_MEMORY_MODES = ["off", "extract"];
+export function isMemorySource(v) {
+    return typeof v === "string" && MEMORY_SOURCES.includes(v);
+}
+export function parseAutoMemoryMode(raw, fallback = "extract") {
+    if (typeof raw !== "string")
+        return fallback;
+    const n = raw.trim().toLowerCase();
+    if (n === "off" || n === "extract")
+        return n;
+    return fallback;
+}
+export const MEMORY_TITLE_MAX = 160;
+export const MEMORY_CONTENT_MAX = 4000;
+export const CONTEXT_BUDGET_CHARS = 12_000;
+export const BASELINE_BUDGET_CHARS = 8_000;
+export const TASK_PACK_FILES = 12;
+export const TASK_PACK_EDGES = 20;
+const SECRET_PATTERNS = [
+    /\b(sk|rk|pk)-[A-Za-z0-9_-]{16,}\b/g,
+    /\b(ghp|gho|github_pat)_[A-Za-z0-9_]{20,}\b/g,
+    /\b(xox[baprs]-)[A-Za-z0-9-]{10,}\b/g,
+    /\bAKIA[0-9A-Z]{16}\b/g,
+    /\bBearer\s+[A-Za-z0-9._\-+=/]{20,}\b/gi,
+];
+export function isMemoryKind(v) {
+    return typeof v === "string" && MEMORY_KINDS.includes(v);
+}
+/** Standing instructions / jailbreak-shaped text must never auto-accept. */
+export function looksLikeMemoryInjection(input) {
+    const q = input.toLowerCase();
+    return (/\b(ignore|disregard)\s+(all\s+)?(previous|prior|system)\b/.test(q) ||
+        /\b(you are now|jailbreak|system prompt)\b/.test(q) ||
+        /\b(always obey|must follow these instructions|from now on you)\b/.test(q) ||
+        /\b(do not follow|override)\s+(the\s+)?(safety|platform|user request)\b/.test(q));
+}
+export function isMemoryStatus(v) {
+    return typeof v === "string" && MEMORY_STATUSES.includes(v);
+}
+export function stripControlChars(input) {
+    return input.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "");
+}
+export function redactSecrets(input) {
+    let out = input;
+    for (const re of SECRET_PATTERNS) {
+        out = out.replace(re, "[redacted]");
+    }
+    return out;
+}
+export function sanitizeMemoryText(input, max) {
+    if (typeof input !== "string")
+        return "";
+    return redactSecrets(stripControlChars(input)).trim().slice(0, max);
+}
+export function tokenizeQuery(text) {
+    const stop = new Set([
+        "a",
+        "an",
+        "the",
+        "to",
+        "for",
+        "with",
+        "from",
+        "and",
+        "or",
+        "of",
+        "on",
+        "in",
+        "by",
+        "you",
+        "your",
+        "can",
+        "please",
+        "fix",
+        "update",
+        "make",
+        "show",
+        "change",
+        "do",
+        "it",
+        "this",
+        "that",
+        "api",
+    ]);
+    const words = text.toLowerCase().match(/[a-zA-Z0-9_]+/g) || [];
+    const out = [];
+    const seen = new Set();
+    for (const w of words) {
+        if (w.length < 2 || stop.has(w) || seen.has(w))
+            continue;
+        seen.add(w);
+        out.push(w);
+    }
+    return out;
+}
+export function classifyIntent(query) {
+    const q = query.toLowerCase();
+    if (/\b(GET|POST|PUT|DELETE|PATCH)\s+\//i.test(query))
+        return "debug";
+    if (/\b(why|explain|architecture|how does)\b/.test(q))
+        return "explain";
+    if (/\b(error|bug|crash|failing|broken|exception|404|500)\b/.test(q)) {
+        return "debug";
+    }
+    if (/\b(test|coverage|spec)\b/.test(q))
+        return "test";
+    if (/\b(refactor|cleanup|simplify|optimize)\b/.test(q))
+        return "refactor";
+    if (/\b(add|create|implement|build|support)\b/.test(q))
+        return "feature";
+    if (/\b(fix|update|change|edit|modify|patch)\b/.test(q))
+        return "edit";
+    return "general";
+}
+export function wrapUntrustedBlock(tag, attrs, body) {
+    return `<${tag}${attrs ? ` ${attrs}` : ""}>\n${body.trim()}\n</${tag}>`;
+}

package/dist/shared/roomPermissions.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Room collaboration permissions.
+ *
+ * Roles:
+ * - owner: room host
+ * - editor: can collaborate (subject to control mode)
+ * - viewer: read-only
+ *
+ * Control modes:
+ * - open: any editor can steer
+ * - driver: only the current driver (or host) can steer
+ * - host: only the host can steer
+ */
+export type RoomRole = "owner" | "editor" | "viewer";
+export type RoomInviteRole = "editor" | "viewer";
+export type ControlMode = "open" | "driver" | "host";
+/**
+ * Who can open a session in a team workspace: "team" = every workspace member,
+ * "private" = only its owner and people they invite (admins included only if invited).
+ */
+export type RoomVisibility = "team" | "private";
+export declare function parseRoomVisibility(value: unknown): RoomVisibility;
+/** Do workspace members get in without an invite? */
+export declare function teamCanAccessRoom(row: {
+    org_id?: string | null;
+    visibility?: string | null;
+}): boolean;
+export declare function normalizeRoomRole(raw: string | null | undefined): RoomRole | null;
+export declare function parseRoomInviteRole(raw: unknown, fallback?: RoomInviteRole): RoomInviteRole;
+export declare function parseControlMode(raw: unknown, fallback?: ControlMode): ControlMode;
+/** Default control mode for newly created rooms. Local agents are higher risk. */
+export declare function defaultControlModeForRuntime(runtime: "local" | "cloud" | string): ControlMode;
+export declare function roomRoleLabel(role: RoomRole): string;
+export declare function roomRoleDescription(role: RoomRole): string;
+export declare function controlModeLabel(mode: ControlMode): string;
+export declare function controlModeDescription(mode: ControlMode): string;
+export declare function canManageRoom(role: RoomRole | null | undefined): boolean;
+export declare function canRequestDrive(role: RoomRole | null | undefined): boolean;
+/** Viewers can read room memory; only editors and the host can mutate it. */
+export declare function canEditMemory(role: RoomRole | null | undefined): boolean;
+export declare function canSteerWithRole(opts: {
+    role: RoomRole | null | undefined;
+    controlMode: ControlMode;
+    isDrivingAgent: boolean;
+}): boolean;
+/** Abort follows the same gate as steering. */
+export declare function canAbortWithRole(opts: {
+    role: RoomRole | null | undefined;
+    controlMode: ControlMode;
+    isDrivingAgent: boolean;
+}): boolean;
+export declare function steerDeniedReason(opts: {
+    role: RoomRole | null | undefined;
+    controlMode: ControlMode;
+    isDrivingAgent: boolean;
+}): string | null;

package/dist/shared/roomPermissions.js

@@ -0,0 +1,133 @@
+/**
+ * Room collaboration permissions.
+ *
+ * Roles:
+ * - owner: room host
+ * - editor: can collaborate (subject to control mode)
+ * - viewer: read-only
+ *
+ * Control modes:
+ * - open: any editor can steer
+ * - driver: only the current driver (or host) can steer
+ * - host: only the host can steer
+ */
+export function parseRoomVisibility(value) {
+    return value === "private" ? "private" : "team";
+}
+/** Do workspace members get in without an invite? */
+export function teamCanAccessRoom(row) {
+    return Boolean(row.org_id) && parseRoomVisibility(row.visibility) === "team";
+}
+/** Legacy room_members.role values still present in older DBs. */
+const LEGACY_MEMBER_ALIASES = {
+    owner: "owner",
+    editor: "editor",
+    viewer: "viewer",
+    member: "editor",
+    admin: "editor",
+};
+export function normalizeRoomRole(raw) {
+    if (!raw)
+        return null;
+    return LEGACY_MEMBER_ALIASES[raw.trim().toLowerCase()] ?? null;
+}
+export function parseRoomInviteRole(raw, fallback = "viewer") {
+    if (typeof raw !== "string")
+        return fallback;
+    const n = raw.trim().toLowerCase();
+    if (n === "editor")
+        return "editor";
+    if (n === "viewer")
+        return "viewer";
+    // Legacy invite rows may lack a role; treat historical "member" as editor.
+    if (n === "member" || n === "admin")
+        return "editor";
+    return fallback;
+}
+export function parseControlMode(raw, fallback = "open") {
+    if (typeof raw !== "string")
+        return fallback;
+    const n = raw.trim().toLowerCase();
+    if (n === "open" || n === "driver" || n === "host")
+        return n;
+    return fallback;
+}
+/** Default control mode for newly created rooms. Local agents are higher risk. */
+export function defaultControlModeForRuntime(runtime) {
+    return runtime === "local" ? "driver" : "open";
+}
+export function roomRoleLabel(role) {
+    if (role === "owner")
+        return "Host";
+    if (role === "editor")
+        return "Editor";
+    return "Viewer";
+}
+export function roomRoleDescription(role) {
+    if (role === "owner") {
+        return "Full control — manage agents, invites, and settings";
+    }
+    if (role === "editor") {
+        return "Can steer agents according to the room control mode";
+    }
+    return "Can watch chat, diffs, and presence — cannot steer";
+}
+export function controlModeLabel(mode) {
+    if (mode === "open")
+        return "Open collaboration";
+    if (mode === "driver")
+        return "Driver enforced";
+    return "Host only";
+}
+export function controlModeDescription(mode) {
+    if (mode === "open") {
+        return "Any editor can message agents";
+    }
+    if (mode === "driver") {
+        return "Only the current driver (or host) can message agents";
+    }
+    return "Only the host can message agents";
+}
+export function canManageRoom(role) {
+    return role === "owner";
+}
+export function canRequestDrive(role) {
+    return role === "owner" || role === "editor";
+}
+/** Viewers can read room memory; only editors and the host can mutate it. */
+export function canEditMemory(role) {
+    return role === "owner" || role === "editor";
+}
+export function canSteerWithRole(opts) {
+    const { role, controlMode, isDrivingAgent } = opts;
+    if (!role)
+        return false;
+    if (role === "owner")
+        return true;
+    if (role === "viewer")
+        return false;
+    // editor
+    if (controlMode === "host")
+        return false;
+    if (controlMode === "open")
+        return true;
+    return isDrivingAgent;
+}
+/** Abort follows the same gate as steering. */
+export function canAbortWithRole(opts) {
+    return canSteerWithRole(opts);
+}
+export function steerDeniedReason(opts) {
+    if (canSteerWithRole(opts))
+        return null;
+    if (!opts.role || opts.role === "viewer") {
+        return "Viewers cannot steer agents";
+    }
+    if (opts.controlMode === "host") {
+        return "Only the host can steer in host-only mode";
+    }
+    if (opts.controlMode === "driver" && !opts.isDrivingAgent) {
+        return "Request control to steer this agent";
+    }
+    return "You do not have permission to steer this agent";
+}

package/dist/shared/sessionSeats.d.ts

@@ -0,0 +1,29 @@
+import type { AgentBackendKind } from "./backends/types.js";
+import type { SessionSeat } from "./events.js";
+/** One agent row, plus who is with it, before it becomes a SessionSeat. */
+export interface SeatSourceAgent {
+    id: string;
+    backend: AgentBackendKind;
+    label: string;
+    createdBy?: string | null;
+    working: boolean;
+    /** Live driver, or the last person granted the driver seat. */
+    driverUserId?: string | null;
+    /** Person who steered the in-flight run. Preferred while working. */
+    steerer?: {
+        userId?: string;
+        name: string;
+    } | null;
+    /** Latest one-line focus from the agent's `update_focus` tool. */
+    focus?: string | null;
+}
+export interface SeatPerson {
+    userId: string;
+    name: string;
+    avatarUrl?: string;
+}
+/** First occurrence of each harness. Three Cursors and one Codex become two marks. */
+export declare function uniqueAgentBackends(backends: readonly AgentBackendKind[] | undefined): AgentBackendKind[];
+export declare function buildSessionSeats(agents: readonly SeatSourceAgent[], people: readonly SeatPerson[]): SessionSeat[];
+/** Agents that are mid-run. Idle seats stay off the session row. */
+export declare function workingSeats(seats: readonly SessionSeat[] | undefined): SessionSeat[];

package/dist/shared/sessionSeats.js

@@ -0,0 +1,57 @@
+/** First occurrence of each harness. Three Cursors and one Codex become two marks. */
+export function uniqueAgentBackends(backends) {
+    if (!backends?.length)
+        return [];
+    const seen = new Set();
+    const out = [];
+    for (const backend of backends) {
+        if (seen.has(backend))
+            continue;
+        seen.add(backend);
+        out.push(backend);
+    }
+    return out;
+}
+function personFor(agent, people) {
+    const steerer = agent.steerer?.name?.trim();
+    if (agent.working && steerer) {
+        const known = agent.steerer?.userId
+            ? people.get(agent.steerer.userId)
+            : undefined;
+        return {
+            userId: agent.steerer?.userId || known?.userId,
+            name: steerer,
+            avatarUrl: known?.avatarUrl,
+        };
+    }
+    const userId = agent.driverUserId || agent.createdBy || undefined;
+    const known = userId ? people.get(userId) : undefined;
+    if (known) {
+        return { userId: known.userId, name: known.name, avatarUrl: known.avatarUrl };
+    }
+    if (userId)
+        return { userId, name: "Teammate" };
+    return { name: agent.label };
+}
+export function buildSessionSeats(agents, people) {
+    const byId = new Map(people.map((person) => [person.userId, person]));
+    return agents.map((agent) => {
+        const person = personFor(agent, byId);
+        return {
+            agentId: agent.id,
+            backend: agent.backend,
+            agentLabel: agent.label,
+            working: agent.working,
+            userId: person.userId,
+            name: person.name,
+            avatarUrl: person.avatarUrl,
+            ...(agent.focus?.trim() ? { focus: agent.focus.trim() } : {}),
+        };
+    });
+}
+/** Agents that are mid-run. Idle seats stay off the session row. */
+export function workingSeats(seats) {
+    if (!seats?.length)
+        return [];
+    return seats.filter((seat) => seat.working);
+}

package/dist/shared/slashCommands.d.ts

@@ -0,0 +1,39 @@
+import type { AgentBackendKind } from "./backends/types.js";
+/**
+ * Slash commands typed into an agent's composer. `steer` commands are
+ * handled by Steer itself; `cli` commands go to the agent's CLI verbatim
+ * (Claude Code runs them locally in headless mode — `/context` costs no
+ * tokens). Imported by the web bundle, so no runtime imports here.
+ */
+export interface SlashCommandInfo {
+    name: string;
+    description: string;
+    handledBy: "steer" | "cli";
+}
+export type SteerCommandName = "clear" | "issue" | "status" | "ask" | "remember" | "integrate";
+/** What Claude Code reports at startup (`system/init`), stored per agent. */
+export interface CliCommandCatalog {
+    commands: string[];
+    /** Interactive-terminal-only commands (from the CLI itself). */
+    terminalOnly: string[];
+    skills: string[];
+}
+export declare function slashCommandsFor(backend: AgentBackendKind | undefined, catalog?: CliCommandCatalog | null): SlashCommandInfo[];
+/** Menu matches: prefix matches first, then names containing the query. */
+export declare function matchSlashCommands(commands: SlashCommandInfo[], query: string): SlashCommandInfo[];
+export interface ParsedSlashCommand {
+    name: string;
+    /** Text after the command name (e.g. `/compact keep the API notes`). */
+    args: string;
+}
+/** `/name [args]` → parts; null for normal messages (and paths like `/src/x`). */
+export declare function parseSlashCommand(text: string): ParsedSlashCommand | null;
+export type SlashCommandAction = SteerCommandName | "passthrough" | "unsupported";
+/**
+ * How a slash message for `backend` should be handled:
+ * - an Eigen command: Steer handles it in-process (see `SteerCommandName`)
+ * - `passthrough`: send the text to the CLI exactly as typed
+ * - `unsupported`: tell the user (the CLI can't run commands headless)
+ * - null: not a slash command for this agent — treat as a normal message
+ */
+export declare function slashCommandAction(backend: AgentBackendKind | undefined, text: string): SlashCommandAction | null;

package/dist/shared/slashCommands.js

@@ -0,0 +1,166 @@
+const CLEAR = {
+    name: "clear",
+    description: "Start a new conversation (the agent forgets this chat)",
+    handledBy: "steer",
+};
+/**
+ * Steer-owned commands. These run in-process (no CLI parsing, no model tokens
+ * unless the command explicitly asks the agent to act) and are offered for
+ * every backend.
+ */
+const STEER_COMMANDS = [
+    CLEAR,
+    {
+        name: "issue",
+        description: "File a Eigen Issue from this chat — the agent writes the title and description",
+        handledBy: "steer",
+    },
+    {
+        name: "status",
+        description: "Show this agent's backend, model, machine, clone path, branch, and PR",
+        handledBy: "steer",
+    },
+    {
+        name: "ask",
+        description: "Ask Keel about this workspace — cited answer from team memory (/ask <question>)",
+        handledBy: "steer",
+    },
+    {
+        name: "remember",
+        description: "Save a durable fact to team memory (/remember <fact>)",
+        handledBy: "steer",
+    },
+    {
+        name: "integrate",
+        description: "Merge this agent's branch into the session's integration branch",
+        handledBy: "steer",
+    },
+];
+const STEER_NAMES = new Set(STEER_COMMANDS.map((command) => command.name));
+const CLAUDE_COMMANDS = [
+    CLEAR,
+    { name: "context", description: "Show context window usage", handledBy: "cli" },
+    { name: "compact", description: "Summarize the conversation to free up context", handledBy: "cli" },
+];
+/**
+ * Built-ins that work in the headless runs behind the chat (checked against
+ * `claude -p`): they print a result without needing the terminal UI.
+ */
+const CLAUDE_BUILTIN_ALLOWED = {
+    context: "Show context window usage",
+    compact: "Summarize the conversation to free up context",
+    cost: "Token usage and cost for this conversation",
+    usage: "Token usage and cost for this conversation",
+    recap: "Recap of the conversation so far",
+    mcp: "List the MCP servers and tools the agent has",
+    init: "Write a CLAUDE.md describing this repo",
+    review: "Review the current changes",
+    "security-review": "Security review of the pending changes",
+    "pr-comments": "Fetch comments from the GitHub pull request",
+};
+/**
+ * Built-ins hidden from the chat: terminal UI / settings that wouldn't stick
+ * (every chat message is a fresh process — Eigen's own picker sets the
+ * model), or ones the CLI reports as unavailable headless.
+ */
+const CLAUDE_BUILTIN_HIDDEN = new Set([
+    "clear", "model", "effort", "fast", "config", "status", "memory", "hooks",
+    "permissions", "agents", "insights", "doctor", "color", "focus", "theme",
+    "vim", "output-style", "statusline", "terminal-setup", "ide", "add-dir",
+    "resume", "rewind", "rename", "export", "exit", "quit", "login", "logout",
+    "upgrade", "release-notes", "bug", "feedback", "privacy-settings",
+    "install-github-app", "reload-plugins", "reload-skills", "heapdump",
+    "auto-mode-setup", "autocompact", "plugin", "plugins", "skills", "tasks",
+    "loop", "goal", "advisor", "team-onboarding", "list-agents", "import",
+    "design-consent", "design-revoke", "workflow-launch-exec", "batch", "help",
+]);
+/**
+ * Menu entries for Claude Code: `/clear` (Eigen), allowed built-ins the CLI
+ * reports, then the repo's custom commands, skills and plugin commands.
+ * Without a catalog yet (agent hasn't run), the verified basics.
+ */
+function claudeCommandsFrom(catalog) {
+    if (!catalog?.commands?.length)
+        return CLAUDE_COMMANDS;
+    const terminalOnly = new Set(catalog.terminalOnly ?? []);
+    const skills = new Set(catalog.skills ?? []);
+    const builtins = [];
+    const custom = [];
+    const seen = new Set(["clear"]);
+    for (const raw of catalog.commands) {
+        const name = raw.replace(/^\//, "").trim();
+        if (!name || seen.has(name) || name.startsWith("_") || terminalOnly.has(name))
+            continue;
+        seen.add(name);
+        if (CLAUDE_BUILTIN_ALLOWED[name]) {
+            builtins.push({ name, description: CLAUDE_BUILTIN_ALLOWED[name], handledBy: "cli" });
+        }
+        else if (!CLAUDE_BUILTIN_HIDDEN.has(name)) {
+            custom.push({
+                name,
+                description: name.includes(":")
+                    ? "Plugin command"
+                    : skills.has(name)
+                        ? "Skill"
+                        : "Custom command",
+                handledBy: "cli",
+            });
+        }
+    }
+    // Keep the two verified essentials even if a CLI version renames things.
+    for (const base of CLAUDE_COMMANDS) {
+        if (!seen.has(base.name) && base.name !== "clear")
+            builtins.push(base);
+    }
+    custom.sort((a, b) => a.name.localeCompare(b.name));
+    return [CLEAR, ...builtins, ...custom];
+}
+/** Steer commands first, then backend commands that don't shadow them. */
+function withSteerCommands(commands) {
+    return [
+        ...STEER_COMMANDS,
+        ...commands.filter((command) => !STEER_NAMES.has(command.name)),
+    ];
+}
+export function slashCommandsFor(backend, catalog) {
+    if (backend === "claude-code")
+        return withSteerCommands(claudeCommandsFrom(catalog));
+    return [...STEER_COMMANDS];
+}
+/** Menu matches: prefix matches first, then names containing the query. */
+export function matchSlashCommands(commands, query) {
+    const q = query.toLowerCase();
+    const prefix = commands.filter((c) => c.name.startsWith(q));
+    const inner = commands.filter((c) => !c.name.startsWith(q) && c.name.includes(q));
+    return [...prefix, ...inner];
+}
+/** `/name [args]` → parts; null for normal messages (and paths like `/src/x`). */
+export function parseSlashCommand(text) {
+    const match = /^\/([a-z][\w:-]*)(?:\s+([\s\S]*))?$/i.exec(text.trim());
+    if (!match)
+        return null;
+    return { name: match[1].toLowerCase(), args: (match[2] ?? "").trim() };
+}
+/**
+ * How a slash message for `backend` should be handled:
+ * - an Eigen command: Steer handles it in-process (see `SteerCommandName`)
+ * - `passthrough`: send the text to the CLI exactly as typed
+ * - `unsupported`: tell the user (the CLI can't run commands headless)
+ * - null: not a slash command for this agent — treat as a normal message
+ */
+export function slashCommandAction(backend, text) {
+    const parsed = parseSlashCommand(text);
+    if (!parsed)
+        return null;
+    if (STEER_NAMES.has(parsed.name)) {
+        return parsed.name;
+    }
+    if (backend === "claude-code") {
+        // Claude Code also runs project/user custom commands and skills.
+        return "passthrough";
+    }
+    if (backend === "codex" || backend === "opencode") {
+        return "unsupported";
+    }
+    return null;
+}

package/dist/shared/space.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Space metadata carried on chat messages (`ChatMessage.space`).
+ *
+ * Stored as one JSON column so new Space features (reactions, pins, …) can
+ * add fields here without another schema migration. Keep this file free of
+ * runtime imports — the web bundler can't resolve "./x.js" between shared/
+ * files.
+ */
+export interface SpaceHandoffRef {
+    /** Agent whose reply is being handed off. */
+    agentId: string;
+    /** The assistant message that was handed off. */
+    messageId: string;
+}
+export interface SpaceMessageMeta {
+    /**
+     * Where the message was composed: the room-wide Space, or another agent's
+     * chat (a hand-off sent by tagging one agent from that chat).
+     */
+    origin?: "space" | "agent";
+    /** Root message id of the thread this message belongs to. */
+    threadId?: string;
+    /** Another agent's reply passed along as context. */
+    handoff?: SpaceHandoffRef;
+    /** People @mentioned in the message. */
+    mentionUserIds?: string[];
+    /** Thread root only: nothing in this thread goes into team memory. */
+    offRecord?: boolean;
+}
+/** Validate untrusted client input; drops anything malformed. */
+export declare function sanitizeSpaceMeta(input: unknown): SpaceMessageMeta | undefined;
+export declare function parseSpaceMetaJson(raw: unknown): SpaceMessageMeta | undefined;
+export declare function spaceMetaJson(meta: SpaceMessageMeta | undefined): string | null;