aimux-cli 0.1.16 → 0.1.19

package/dist/pending-actions.js

@@ -0,0 +1,13 @@
+const BLOCKING_PENDING_DASHBOARD_ACTIONS = new Set([
+    "creating",
+    "forking",
+    "migrating",
+    "starting",
+    "stopping",
+    "graveyarding",
+    "renaming",
+    "removing",
+]);
+export function isBlockingPendingDashboardActionKind(kind) {
+    return Boolean(kind && BLOCKING_PENDING_DASHBOARD_ACTIONS.has(kind));
+}

package/dist/plugin-runtime.js

@@ -6,6 +6,8 @@ import { updateSessionMetadata, clearSessionLogs, loadMetadataState, } from "./m
 import { debug } from "./debug.js";
 import { createBuiltinMetadataWatchers } from "./builtin-metadata-watchers.js";
 import { AgentTracker } from "./agent-tracker.js";
+import { listTopologySessionStates } from "./runtime-core/topology-sessions.js";
+import { contextualizeAlertInput, metadataDisplayContext } from "./alert-display.js";
 function listPluginFiles(dir) {
     if (!existsSync(dir))
         return [];
@@ -122,7 +124,12 @@ export class PluginRuntime {
         const alert = deriveAlertFromAgentEvent(sessionId, event);
         if (!alert)
             return;
-        this.eventBus.publishAlert(alert);
+        let context;
+        try {
+            context = metadataDisplayContext(loadMetadataState().sessions[sessionId]);
+        }
+        catch { }
+        this.eventBus.publishAlert(contextualizeAlertInput(alert, context));
     }
     async start() {
         const tracker = new AgentTracker();
@@ -226,7 +233,7 @@ export class PluginRuntime {
                 },
             },
             sessions: {
-                list: () => Object.keys(loadMetadataState().sessions).map((id) => ({ id })),
+                list: () => listTopologySessionStates().map((session) => ({ id: session.id })),
             },
         };
         for (const watcher of createBuiltinMetadataWatchers(api)) {
@@ -316,4 +323,3 @@ export function deriveAlertFromAgentEvent(sessionId, event) {
         cooldownMs: kind === "task_done" ? 10_000 : 15_000,
     };
 }
-//# sourceMappingURL=plugin-runtime.js.map

package/dist/project-events.d.ts

@@ -13,22 +13,13 @@ export interface AlertEvent {
     dedupeKey?: string;
     forceNotify?: boolean;
 }
-export interface HistoryUpdateEvent {
-    type: "history_update";
-    projectId: string;
-    sessionId: string;
-    ts: string;
-    messages: unknown[];
-    lastN?: number;
-}
-export type ProjectStreamEvent = AlertEvent | HistoryUpdateEvent;
+export type ProjectStreamEvent = AlertEvent;
 type ProjectEventListener = (event: ProjectStreamEvent) => void;
 export declare class ProjectEventBus {
     private listeners;
     private alertCooldowns;
     subscribe(listener: ProjectEventListener): () => void;
     publish(event: ProjectStreamEvent): void;
-    publishHistoryUpdate(input: Omit<HistoryUpdateEvent, "type" | "projectId" | "ts">): void;
     publishAlert(alert: Omit<AlertEvent, "type" | "projectId" | "ts"> & {
         dedupeKey?: string;
         cooldownMs?: number;

package/dist/project-events.js

@@ -15,16 +15,6 @@ export class ProjectEventBus {
             listener(event);
         }
     }
-    publishHistoryUpdate(input) {
-        this.publish({
-            type: "history_update",
-            projectId: getProjectId(),
-            ts: new Date().toISOString(),
-            sessionId: input.sessionId,
-            messages: input.messages,
-            lastN: input.lastN,
-        });
-    }
     publishAlert(alert) {
         const cooldownMs = alert.cooldownMs ?? 15_000;
         const dedupeKey = alert.dedupeKey?.trim() || undefined;
@@ -63,4 +53,3 @@ export class ProjectEventBus {
         return true;
     }
 }
-//# sourceMappingURL=project-events.js.map

package/dist/project-scanner.d.ts

@@ -7,7 +7,6 @@ export interface GlobalSession {
     headline?: string;
     role?: string;
     worktreePath?: string;
-    ownerPid?: number;
 }
 export interface ProjectInfo {
     name: string;
@@ -20,11 +19,11 @@ export interface DesktopProjectInfo {
     path: string;
     lastSeen?: string;
     dashboardSessionName: string;
-    sessions: GlobalSession[];
 }
 /**
  * Discover local projects with aimux state.
- * Uses the global projects registry plus filesystem scanning as fallback.
+ * Uses the global projects registry. Runtime topology lives in the
+ * registry-owned project state directory, not in legacy presence files.
  */
 export declare function discoverProjects(): string[];
 /**

package/dist/project-scanner.js

@@ -1,11 +1,19 @@
-import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { join, basename } from "node:path";
-import { homedir, tmpdir } from "node:os";
+import { tmpdir } from "node:os";
 import { getAimuxDirFor, getProjectStateDirById, listProjects } from "./paths.js";
 import { TmuxRuntimeManager } from "./tmux/runtime-manager.js";
+import { RuntimeTopologyStore } from "./runtime-core/topology-store.js";
+import { topologySessionToSessionState } from "./runtime-core/topology-sessions.js";
+function topologyStatusToGlobalStatus(status) {
+    if (status === "running" || status === "idle" || status === "waiting" || status === "offline")
+        return status;
+    return "offline";
+}
 /**
  * Discover local projects with aimux state.
- * Uses the global projects registry plus filesystem scanning as fallback.
+ * Uses the global projects registry. Runtime topology lives in the
+ * registry-owned project state directory, not in legacy presence files.
  */
 export function discoverProjects() {
     const found = new Set();
@@ -15,34 +23,6 @@ export function discoverProjects() {
             found.add(entry.repoRoot);
         }
     }
-    // Fallback: scan common dev directories for old-style in-repo .aimux/
-    const home = homedir();
-    const scanDirs = [
-        join(home, "cs"),
-        join(home, "projects"),
-        join(home, "dev"),
-        join(home, "src"),
-        join(home, "code"),
-        join(home, "work"),
-    ];
-    for (const scanDir of scanDirs) {
-        try {
-            const entries = readdirSync(scanDir);
-            for (const entry of entries) {
-                const projectPath = join(scanDir, entry);
-                try {
-                    if (!statSync(projectPath).isDirectory())
-                        continue;
-                    const aimuxDir = join(projectPath, ".aimux");
-                    if (existsSync(join(aimuxDir, "instances.json")) || existsSync(join(aimuxDir, "state.json"))) {
-                        found.add(projectPath);
-                    }
-                }
-                catch { }
-            }
-        }
-        catch { }
-    }
     return [...found];
 }
 /**
@@ -53,133 +33,85 @@ export function scanProject(projectPath) {
     const seenIds = new Set();
     const registryEntry = listProjects().find((entry) => entry.repoRoot === projectPath);
     const sessionById = new Map();
-    // Check both global state dir and in-repo .aimux/ for instances
-    const instancesPaths = [join(getAimuxDirFor(projectPath), "instances.json")];
     const statusDirs = [join(getAimuxDirFor(projectPath), "status")];
     // Also check global project state dirs for registered projects
     if (registryEntry) {
         const projectStateDir = getProjectStateDirById(registryEntry.id);
-        const globalInstances = join(projectStateDir, "instances.json");
-        if (!instancesPaths.includes(globalInstances)) {
-            instancesPaths.unshift(globalInstances);
-        }
         statusDirs.unshift(join(projectStateDir, "status"));
     }
-    for (const instancesPath of instancesPaths) {
-        if (!existsSync(instancesPath))
-            continue;
-        try {
-            const instances = JSON.parse(readFileSync(instancesPath, "utf-8"));
-            for (const inst of instances) {
-                // Check PID alive
-                try {
-                    process.kill(inst.pid, 0);
-                }
-                catch {
-                    continue;
-                }
-                for (const s of inst.sessions) {
-                    if (seenIds.has(s.id))
-                        continue;
-                    seenIds.add(s.id);
-                    let headline;
-                    for (const statusDir of statusDirs) {
-                        try {
-                            const statusPath = join(statusDir, `${s.id}.md`);
-                            if (existsSync(statusPath)) {
-                                const content = readFileSync(statusPath, "utf-8").trim();
-                                if (content) {
-                                    headline = content.split("\n")[0].slice(0, 80);
-                                    break;
-                                }
-                            }
-                        }
-                        catch {
-                            // Try the next candidate directory.
-                        }
+    function readStatusHeadline(sessionId) {
+        for (const statusDir of statusDirs) {
+            try {
+                const statusPath = join(statusDir, `${sessionId}.md`);
+                if (existsSync(statusPath)) {
+                    const content = readFileSync(statusPath, "utf-8").trim();
+                    if (content) {
+                        return content.split("\n")[0].slice(0, 80);
                     }
-                    sessions.push({
-                        id: s.id,
-                        tool: s.tool,
-                        status: "running",
-                        headline,
-                        worktreePath: s.worktreePath,
-                        ownerPid: inst.pid,
-                    });
-                    sessionById.set(s.id, sessions[sessions.length - 1]);
                 }
             }
+            catch {
+                // Try the next candidate directory.
+            }
         }
-        catch { }
+        return undefined;
     }
-    // Enrich live sessions with statusline.json when available.
-    const statuslinePaths = [join(getAimuxDirFor(projectPath), "statusline.json")];
+    const topologyPaths = [];
     if (registryEntry) {
-        const globalStatusline = join(getProjectStateDirById(registryEntry.id), "statusline.json");
-        if (!statuslinePaths.includes(globalStatusline)) {
-            statuslinePaths.unshift(globalStatusline);
-        }
+        topologyPaths.push(join(getProjectStateDirById(registryEntry.id), "runtime-topology.yaml"));
     }
-    for (const statuslinePath of statuslinePaths) {
-        if (!existsSync(statuslinePath))
+    for (const topologyPath of topologyPaths) {
+        if (!existsSync(topologyPath))
             continue;
         try {
-            const stat = statSync(statuslinePath);
-            if (Date.now() - stat.mtimeMs > 10_000)
-                continue;
-            const statusline = JSON.parse(readFileSync(statuslinePath, "utf-8"));
-            for (const s of statusline.sessions ?? []) {
-                const existing = sessionById.get(s.id);
-                if (existing) {
-                    existing.tool = s.tool ?? existing.tool;
-                    existing.label = s.label ?? existing.label;
-                    existing.headline = s.headline ?? existing.headline;
-                    existing.status = s.status ?? existing.status;
-                    existing.role = s.role ?? existing.role;
+            const topology = new RuntimeTopologyStore(topologyPath).read();
+            for (const topologySession of topology.sessions.filter((session) => session.status !== "graveyard")) {
+                const s = topologySessionToSessionState(topologySession, topology);
+                if (seenIds.has(s.id)) {
+                    const existing = sessionById.get(s.id);
+                    if (existing) {
+                        existing.status = topologyStatusToGlobalStatus(topologySession.status);
+                        existing.label = s.label ?? existing.label;
+                        existing.headline = s.headline ?? existing.headline ?? readStatusHeadline(s.id);
+                        existing.worktreePath = s.worktreePath ?? existing.worktreePath;
+                    }
                     continue;
                 }
                 const session = {
                     id: s.id,
-                    tool: s.tool ?? "unknown",
+                    tool: s.command ?? s.tool ?? "unknown",
+                    status: topologyStatusToGlobalStatus(topologySession.status),
                     label: s.label,
-                    headline: s.headline,
-                    status: s.status ?? "idle",
-                    role: s.role,
+                    headline: s.headline ?? readStatusHeadline(s.id),
+                    worktreePath: s.worktreePath,
                 };
                 sessions.push(session);
                 sessionById.set(s.id, session);
                 seenIds.add(s.id);
             }
-            break;
         }
         catch { }
     }
-    // Offline sessions — check both global state and in-repo
-    const statePaths = [join(getAimuxDirFor(projectPath), "state.json")];
-    if (registryEntry) {
-        const globalState = join(getProjectStateDirById(registryEntry.id), "state.json");
-        if (!statePaths.includes(globalState)) {
-            statePaths.unshift(globalState);
-        }
-    }
-    for (const statePath of statePaths) {
-        if (!existsSync(statePath))
+    // Enrich known sessions with the global statusline projection when available.
+    const statuslinePaths = registryEntry ? [join(getProjectStateDirById(registryEntry.id), "statusline.json")] : [];
+    for (const statuslinePath of statuslinePaths) {
+        if (!existsSync(statuslinePath))
             continue;
         try {
-            const state = JSON.parse(readFileSync(statePath, "utf-8"));
-            for (const s of state.sessions) {
-                if (seenIds.has(s.id))
+            const stat = statSync(statuslinePath);
+            if (Date.now() - stat.mtimeMs > 10_000)
+                continue;
+            const statusline = JSON.parse(readFileSync(statuslinePath, "utf-8"));
+            for (const s of statusline.sessions ?? []) {
+                const existing = sessionById.get(s.id);
+                if (!existing)
                     continue;
-                seenIds.add(s.id);
-                sessions.push({
-                    id: s.id,
-                    tool: s.command ?? s.tool ?? "unknown",
-                    status: "offline",
-                    label: s.label,
-                    headline: s.headline,
-                    worktreePath: s.worktreePath,
-                });
+                existing.tool = s.tool ?? existing.tool;
+                existing.label = s.label ?? existing.label;
+                existing.headline = s.headline ?? existing.headline;
+                existing.role = s.role ?? existing.role;
             }
+            break;
         }
         catch { }
     }
@@ -224,7 +156,6 @@ export function listDesktopProjects(tmux = new TmuxRuntimeManager()) {
     for (const entry of listProjects()) {
         if (shouldHideDesktopProject(entry.repoRoot))
             continue;
-        const scanned = scannedByPath.get(entry.repoRoot);
         const tmuxSession = tmux.getProjectSession(entry.repoRoot);
         projects.set(entry.repoRoot, {
             id: entry.id,
@@ -232,7 +163,6 @@ export function listDesktopProjects(tmux = new TmuxRuntimeManager()) {
             path: entry.repoRoot,
             lastSeen: entry.lastSeen,
             dashboardSessionName: tmuxSession.sessionName,
-            sessions: scanned?.sessions ?? [],
         });
     }
     for (const scanned of scannedByPath.values()) {
@@ -246,9 +176,7 @@ export function listDesktopProjects(tmux = new TmuxRuntimeManager()) {
             name: scanned.name,
             path: scanned.path,
             dashboardSessionName: tmuxSession.sessionName,
-            sessions: scanned.sessions,
         });
     }
     return [...projects.values()].sort((a, b) => a.name.localeCompare(b.name) || a.path.localeCompare(b.path));
 }
-//# sourceMappingURL=project-scanner.js.map

package/dist/project-service-manifest.d.ts

@@ -1,9 +1,7 @@
 export declare const PROJECT_SERVICE_API_VERSION = 4;
 export declare const PROJECT_SERVICE_CAPABILITIES: {
-    readonly structuredAgentInput: true;
     readonly parsedAgentOutput: true;
-    readonly attachments: true;
-    readonly agentHistory: true;
+    readonly attachmentRead: true;
     readonly chatEventStream: true;
 };
 export interface ProjectServiceManifest {

package/dist/project-service-manifest.js

@@ -3,10 +3,8 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 export const PROJECT_SERVICE_API_VERSION = 4;
 export const PROJECT_SERVICE_CAPABILITIES = {
-    structuredAgentInput: true,
     parsedAgentOutput: true,
-    attachments: true,
-    agentHistory: true,
+    attachmentRead: true,
     chatEventStream: true,
 };
 function computeBuildStamp() {
@@ -53,4 +51,3 @@ export function manifestsMatch(expected, actual) {
     const actualCapabilities = actual.capabilities || {};
     return Object.entries(expected.capabilities).every(([key, value]) => actualCapabilities[key] === value);
 }
-//# sourceMappingURL=project-service-manifest.js.map

package/dist/recency.js

@@ -31,4 +31,3 @@ export function formatRelativeRecency(value, now = Date.now()) {
     const years = Math.floor(days / 365);
     return `${years}y ago`;
 }
-//# sourceMappingURL=recency.js.map

package/dist/recorder.js

@@ -127,4 +127,3 @@ export class Recorder {
         this.txtStream.end();
     }
 }
-//# sourceMappingURL=recorder.js.map

package/dist/relay-client.d.ts

@@ -0,0 +1,30 @@
+import type { AimuxDaemon } from "./daemon.js";
+export type RelayConnectionStatus = "connected" | "connecting" | "reconnecting" | "disconnected" | "auth_failed";
+export interface RelayStatusSnapshot {
+    status: RelayConnectionStatus;
+    relayUrl: string;
+    lastConnectedAt: string | null;
+    lastError: string | null;
+}
+export declare class RelayClient {
+    private readonly token;
+    private readonly daemon;
+    private ws;
+    private retryMs;
+    private stopped;
+    private retryTimer;
+    private status;
+    private lastConnectedAt;
+    private lastError;
+    private readonly relayUrl;
+    private handshakeFailures;
+    private readonly recentRemoteClientNotifications;
+    constructor(relayUrl: string, token: string, daemon: AimuxDaemon);
+    getStatus(): RelayStatusSnapshot;
+    connect(): void;
+    disconnect(): void;
+    private handleMessage;
+    private sendRaw;
+    private shouldNotifyRemoteClientConnected;
+    private scheduleRetry;
+}

package/dist/relay-client.js

@@ -0,0 +1,190 @@
+import { notifyRemoteClientConnected } from "./notify.js";
+const INITIAL_RETRY_MS = 1_000;
+const MAX_RETRY_MS = 30_000;
+const MAX_HANDSHAKE_FAILURES = 5;
+const REMOTE_CLIENT_NOTIFICATION_DEDUPE_MS = 5 * 60 * 1000;
+const TOKEN_PROTOCOL_PREFIX = "aimux-token.";
+export class RelayClient {
+    token;
+    daemon;
+    ws = null;
+    retryMs = INITIAL_RETRY_MS;
+    stopped = false;
+    retryTimer = null;
+    status = "disconnected";
+    lastConnectedAt = null;
+    lastError = null;
+    relayUrl;
+    handshakeFailures = 0;
+    recentRemoteClientNotifications = new Map();
+    constructor(relayUrl, token, daemon) {
+        this.token = token;
+        this.daemon = daemon;
+        this.relayUrl = relayUrl.replace(/\/+$/, "");
+    }
+    getStatus() {
+        return {
+            status: this.status,
+            relayUrl: this.relayUrl,
+            lastConnectedAt: this.lastConnectedAt,
+            lastError: this.lastError,
+        };
+    }
+    connect() {
+        if (this.stopped)
+            return;
+        // Aimux targets Node 24+; fail fast when an older runtime lacks WebSocket.
+        // clear error so the user doesn't see an endless reconnect loop full of
+        // ReferenceErrors when running on an older runtime.
+        if (typeof globalThis.WebSocket !== "function") {
+            this.status = "disconnected";
+            this.lastError = "Node runtime is missing globalThis.WebSocket — upgrade to Node 24+ to use the aimux relay";
+            this.stopped = true;
+            return;
+        }
+        this.status = this.lastConnectedAt ? "reconnecting" : "connecting";
+        const url = `${this.relayUrl}/daemon/connect`;
+        try {
+            this.ws = new WebSocket(url, ["aimux", `${TOKEN_PROTOCOL_PREFIX}${this.token}`]);
+        }
+        catch (err) {
+            this.lastError = err instanceof Error ? err.message : String(err);
+            this.scheduleRetry();
+            return;
+        }
+        this.ws.addEventListener("open", () => {
+            this.retryMs = INITIAL_RETRY_MS;
+            this.handshakeFailures = 0;
+            this.status = "connected";
+            this.lastConnectedAt = new Date().toISOString();
+            this.lastError = null;
+            console.log("[relay] Connected to relay server");
+        });
+        this.ws.addEventListener("message", (event) => {
+            void this.handleMessage(String(event.data));
+        });
+        this.ws.addEventListener("close", (event) => {
+            this.ws = null;
+            const code = event.code;
+            // 1008/4001 = auth rejected by relay; don't hammer with retries.
+            if (code === 1008 || code === 4001) {
+                this.status = "auth_failed";
+                this.lastError = "Relay rejected credentials — run `aimux login` again";
+                console.warn(`[relay] Auth failed (code ${code}). Stopping reconnect.`);
+                return;
+            }
+            // 1006 = abnormal close, often a failed HTTP upgrade (e.g. 401).
+            // Stop after repeated handshake failures to avoid infinite retry spam.
+            if (code === 1006) {
+                this.handshakeFailures++;
+                if (this.handshakeFailures >= MAX_HANDSHAKE_FAILURES) {
+                    this.status = "auth_failed";
+                    this.lastError = "Too many handshake failures — token may be expired, run `aimux login` again";
+                    console.warn(`[relay] ${MAX_HANDSHAKE_FAILURES} consecutive handshake failures. Stopping reconnect.`);
+                    return;
+                }
+            }
+            if (!this.stopped) {
+                this.status = "reconnecting";
+                console.log(`[relay] Disconnected, retrying in ${this.retryMs}ms`);
+                this.scheduleRetry();
+            }
+            else {
+                this.status = "disconnected";
+            }
+        });
+        this.ws.addEventListener("error", () => {
+            try {
+                this.ws?.close();
+            }
+            catch { }
+        });
+    }
+    disconnect() {
+        this.stopped = true;
+        this.status = "disconnected";
+        if (this.retryTimer)
+            clearTimeout(this.retryTimer);
+        if (this.ws) {
+            try {
+                this.ws.close(1000, "Daemon shutting down");
+            }
+            catch { }
+            this.ws = null;
+        }
+    }
+    async handleMessage(data) {
+        let msg;
+        try {
+            msg = JSON.parse(data);
+        }
+        catch {
+            return;
+        }
+        if (msg.type === "ping") {
+            this.sendRaw(JSON.stringify({ type: "pong" }));
+            return;
+        }
+        if (msg.type === "connected") {
+            console.log("[relay] Registered as daemon");
+            return;
+        }
+        if (msg.type === "error") {
+            console.warn("[relay] Server error:", msg.message);
+            return;
+        }
+        if (msg.type === "security_event") {
+            if (msg.event?.kind === "client_connected") {
+                const dedupeKey = msg.event.deviceId ?? `${msg.event.title}:${msg.event.body}`;
+                if (this.shouldNotifyRemoteClientConnected(dedupeKey)) {
+                    notifyRemoteClientConnected({
+                        title: msg.event.title,
+                        body: msg.event.body,
+                    });
+                }
+            }
+            return;
+        }
+        if (msg.type === "request") {
+            try {
+                const result = await this.daemon.routeRequest(msg.method, msg.path, msg.body, msg.headers);
+                this.sendRaw(JSON.stringify({ id: msg.id, type: "response", status: result.status, body: result.body }));
+            }
+            catch (err) {
+                this.sendRaw(JSON.stringify({
+                    id: msg.id,
+                    type: "response",
+                    status: 500,
+                    body: { ok: false, error: err instanceof Error ? err.message : "Internal error" },
+                }));
+            }
+        }
+    }
+    sendRaw(data) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(data);
+        }
+    }
+    shouldNotifyRemoteClientConnected(key) {
+        const now = Date.now();
+        for (const [existingKey, lastNotifiedAt] of this.recentRemoteClientNotifications) {
+            if (now - lastNotifiedAt > REMOTE_CLIENT_NOTIFICATION_DEDUPE_MS) {
+                this.recentRemoteClientNotifications.delete(existingKey);
+            }
+        }
+        const previous = this.recentRemoteClientNotifications.get(key);
+        if (previous && now - previous <= REMOTE_CLIENT_NOTIFICATION_DEDUPE_MS)
+            return false;
+        this.recentRemoteClientNotifications.set(key, now);
+        return true;
+    }
+    scheduleRetry() {
+        if (this.stopped)
+            return;
+        this.retryTimer = setTimeout(() => {
+            this.retryTimer = null;
+            this.connect();
+        }, this.retryMs);
+        this.retryMs = Math.min(this.retryMs * 2, MAX_RETRY_MS);
+    }
+}

package/dist/remote-access.d.ts

@@ -0,0 +1,16 @@
+export type RemoteActorRole = "owner" | "guest";
+export interface RemoteActor {
+    role: RemoteActorRole;
+    userId?: string;
+    displayName?: string;
+    email?: string;
+    shareId?: string;
+    shareSessionId?: string;
+}
+export interface RemoteAccessDecision {
+    ok: boolean;
+    status?: number;
+    error?: string;
+}
+export declare function parseRemoteActor(headers: Record<string, string> | undefined): RemoteActor | null;
+export declare function assertRemoteAccessAllowed(actor: RemoteActor | null, method: string, pathname: string, searchParams: URLSearchParams): RemoteAccessDecision;