zidane-ui 0.0.0-stage → 9.0.2

package/dist/machines/headless/fixtures.js

@@ -0,0 +1,258 @@
+import { FIXTURE_LOCAL_HOST } from "./fixture-host.js";
+//#region src/machines/headless/fixtures.ts
+const DAY = 864e5;
+/** A fixed "now" for the demo data, so screenshots don't drift. */
+const DEMO_NOW = Date.UTC(2025, 5, 2, 10, 0, 0);
+/** A desktop's hosts: This computer, then three saved servers. */
+const DEMO_HOSTS = [
+	FIXTURE_LOCAL_HOST,
+	{
+		id: "box",
+		kind: "server",
+		name: "Box",
+		status: "connected",
+		url: "wss://box.example.com",
+		serverName: "box-1",
+		serverVersion: "1.4.2",
+		addedAt: DEMO_NOW - 30 * DAY,
+		lastConnectedAt: DEMO_NOW - 3e5,
+		machineServe: true
+	},
+	{
+		id: "attic",
+		kind: "server",
+		name: "Attic",
+		status: "auth-refused",
+		url: "wss://attic.example.com",
+		error: "token refused (401)"
+	},
+	{
+		id: "lab",
+		kind: "server",
+		name: "Lab",
+		status: "offline",
+		url: "wss://lab.example.com",
+		error: "connect ECONNREFUSED"
+	}
+];
+/** The machines Box holds. */
+const DEMO_MACHINES = [{
+	id: "m-laptop",
+	name: "laptop",
+	roots: [{ path: "/Users/me/code" }],
+	status: "online",
+	lastSeen: DEMO_NOW - 6e4
+}, {
+	id: "m-desk",
+	name: "desk",
+	roots: [{ path: "/home/me/src" }],
+	status: "offline",
+	lastSeen: DEMO_NOW - 2 * DAY
+}];
+/** Box's self-update, a release waiting for runs to pause. */
+const DEMO_UPDATE_WAITING = {
+	enabled: true,
+	supported: true,
+	current: "1.4.2",
+	latest: "1.5.0",
+	state: "waiting",
+	updatedFrom: "1.4.1"
+};
+/** Box's client tokens. */
+const DEMO_TOKENS = [
+	{
+		id: "tok_phone",
+		name: "phone",
+		scope: "chat",
+		createdAt: DEMO_NOW - 10 * DAY,
+		lastUsedAt: DEMO_NOW - 36e5
+	},
+	{
+		id: "tok_laptop",
+		name: "laptop",
+		scope: "admin",
+		createdAt: DEMO_NOW - 40 * DAY,
+		lastUsedAt: DEMO_NOW - 6e4
+	},
+	{
+		id: "tok_old",
+		name: "old tablet",
+		scope: "approve",
+		createdAt: DEMO_NOW - 90 * DAY,
+		revokedAt: DEMO_NOW - 20 * DAY
+	}
+];
+/** What a demo server can do: git and docker found, gh missing, the OS sandbox, Docker and E2B environments. */
+const DEMO_CAPABILITIES = {
+	os: {
+		platform: "linux",
+		arch: "x64",
+		release: "6.8"
+	},
+	tools: [
+		{
+			name: "git",
+			found: true,
+			version: "git version 2.45.0"
+		},
+		{
+			name: "gh",
+			found: false
+		},
+		{
+			name: "docker",
+			found: true,
+			version: "Docker 27.1"
+		}
+	],
+	sandbox: {
+		ok: true,
+		backend: "bwrap"
+	},
+	environments: [
+		{
+			kind: "local",
+			label: "Local",
+			available: true
+		},
+		{
+			kind: "docker",
+			label: "Docker",
+			available: true
+		},
+		{
+			kind: "e2b",
+			label: "E2B",
+			available: false,
+			reason: "no API key"
+		}
+	],
+	allows: {
+		remoteInstalls: true,
+		asMachine: true,
+		sync: false,
+		clone: true,
+		createFolders: true
+	},
+	workspace: {
+		roots: ["/data/workspaces"],
+		freeBytes: 42 * 1024 ** 3
+	},
+	probedAt: 17e11
+};
+/** A connected daemon holding a running session and one waiting for an answer. */
+const DEMO_DAEMON = {
+	enabled: true,
+	state: "connected",
+	socketPath: "/tmp/zidane/daemon.sock",
+	window: {
+		protocolVersion: 12,
+		buildId: "demo"
+	},
+	daemon: {
+		pid: 4242,
+		protocolVersion: 12,
+		startedAt: DEMO_NOW - 108e5
+	},
+	sessions: [{
+		sessionId: "local:s-refactor",
+		running: true,
+		waitingForYou: false,
+		windows: 1
+	}, {
+		sessionId: "local:s-deploy",
+		running: true,
+		waitingForYou: true,
+		windows: 0
+	}]
+};
+/** This computer keeping Box in sync: settings, instructions and API keys (Anthropic's opted in), a field edited on Box since, a skipped MCP server. */
+const DEMO_SYNC = {
+	enabled: true,
+	device: {
+		id: "dev-laptop",
+		name: "laptop"
+	},
+	config: {
+		mode: "keep",
+		categories: [
+			"settings",
+			"files",
+			"mcps",
+			"keys"
+		],
+		keys: ["anthropic"],
+		pending: [],
+		lastSyncAt: DEMO_NOW - 24e4,
+		results: { mcps: {
+			applied: [],
+			unchanged: [],
+			skipped: [{
+				field: "mcp:local-db",
+				reason: "stdio servers stay here"
+			}],
+			warnings: []
+		} }
+	},
+	connected: true,
+	supported: true,
+	status: {
+		source: {
+			deviceId: "dev-laptop",
+			deviceName: "laptop",
+			claimedAt: DEMO_NOW - 30 * DAY
+		},
+		categories: [
+			"settings",
+			"files",
+			"mcps",
+			"keys"
+		],
+		keys: ["anthropic"],
+		fields: { "setting:approvalMode": {
+			category: "settings",
+			syncedAt: DEMO_NOW - DAY
+		} },
+		overrides: { "setting:maxTurns": { at: DEMO_NOW - 2 * DAY } }
+	},
+	conflict: null,
+	busy: false,
+	local: {
+		keyProviders: [{
+			key: "anthropic",
+			label: "Anthropic"
+		}, {
+			key: "openai",
+			label: "OpenAI"
+		}],
+		accounts: [{
+			key: "anthropic",
+			label: "Anthropic",
+			apiKey: true,
+			signIns: []
+		}, {
+			key: "openai",
+			label: "OpenAI",
+			apiKey: true,
+			signIns: ["Default"]
+		}],
+		localExtensions: [],
+		stdioMcps: ["local-db"]
+	}
+};
+/** Box's providers: Anthropic set up, OpenAI signs in with OAuth there. */
+const DEMO_SERVER_PROVIDERS = [{
+	key: "anthropic",
+	label: "Anthropic",
+	configured: true,
+	oauth: false,
+	methods: []
+}, {
+	key: "openai",
+	label: "OpenAI",
+	configured: false,
+	oauth: true,
+	methods: []
+}];
+//#endregion
+export { DEMO_CAPABILITIES, DEMO_DAEMON, DEMO_HOSTS, DEMO_MACHINES, DEMO_NOW, DEMO_SERVER_PROVIDERS, DEMO_SYNC, DEMO_TOKENS, DEMO_UPDATE_WAITING };

package/dist/machines/headless/host.d.ts

@@ -0,0 +1,343 @@
+import { Readable } from "../../chat/headless/store.js";
+import { HostView } from "../../chat/headless/hosts.js";
+import { SignInFlow } from "../../onboarding/headless/host.js";
+import { MachinesPresence } from "./presence.js";
+import { HostSyncPatch, HostSyncRead, HostSyncState, SyncStatus } from "./sync.js";
+import { DaemonHealth, HostCapabilities, MachineInfo, MachineLinksStatus, ServerUpdateStatus } from "zidane/chat/pure";
+import { ClientScope, HostProviderAuth } from "zidane/ipc";
+//#region src/machines/headless/host.d.ts
+/** One agent host as the machines components show it: This computer or a server. */
+interface HostSummary extends HostView {
+  /** The server's own name, when it differs from the saved one. */
+  serverName?: string;
+  /** The zidane version the server runs. */
+  serverVersion?: string;
+  /** When the server was saved, epoch ms. */
+  addedAt?: number;
+  /** When the app last connected to it, epoch ms. */
+  lastConnectedAt?: number;
+  /** The server lends itself as a machine (`allowAsMachine`). */
+  machineServe?: boolean;
+  /** The scope this app's token has there. Absent: every method (the user's own computer). */
+  scope?: ClientScope;
+  /** When the server process started, epoch ms. */
+  startedAt?: number;
+}
+/** The hosts the app knows. */
+interface HostsState {
+  /** More than This computer may show (the desktop app's Remote hosts setting). `false`: the single-host view. */
+  enabled: boolean;
+  /** This computer first (when the app has one), then the servers. */
+  hosts: readonly HostSummary[];
+}
+/** A registry refusal's code: what is wrong with a server's URL, token or name, or why it did not answer. */
+type HostCheckError = 'invalid-url' | 'invalid-token' | 'invalid-name' | 'auth' | 'unreachable' | 'tls' | 'protocol' | 'identity' | 'unknown-host' | 'disabled' | 'unknown';
+/** A test, an add or a rename, answered as data. `message` is the backend's own words. */
+type HostCheckResult = {
+  ok: true;
+  name: string;
+  serverVersion?: string;
+  latencyMs?: number;
+  host?: HostSummary;
+} | {
+  ok: false;
+  error: HostCheckError;
+  message: string;
+};
+/** A machine link action's outcome. `needsToken`: the server could not mint a machine token, paste one. */
+type MachineActionResult = {
+  ok: true;
+  links: MachineLinksStatus;
+} | {
+  ok: false;
+  message: string;
+  needsToken?: boolean;
+};
+/** What went wrong, for the UI to word through its labels. `detail` is the backend's own message. */
+interface MachinesError {
+  /** Which action failed. */
+  kind: 'read' | 'update' | 'forget' | 'remove' | 'tokens' | 'daemon' | 'sync' | 'invite';
+  /** The backend's message, shown as is by the default labels. */
+  detail: string;
+  /** The token's scope does not reach the action (the server answered Forbidden). */
+  forbidden?: boolean;
+}
+/** A one-time machine join code (`tokens.machineInvite`): a new machine runs `zidane machine setup --join <join>`. */
+interface MachineInvite {
+  /** The join code (`K7Q2-9XPM`). */
+  code: string;
+  /** When the code stops working, epoch ms. It works once before then. */
+  expiresAt: number;
+  /** The join string: the main server's URL and the code (`wss://box.example#K7Q2-9XPM`). */
+  join: string;
+}
+/** One server's machines as last read. */
+interface MachineListState {
+  /** `idle` before the first read; `loading` while one is in flight; `ready` or `error` after. */
+  status: 'idle' | 'loading' | 'ready' | 'error';
+  /** The machines from the last read that succeeded (empty until one did). */
+  machines: readonly MachineInfo[];
+  /** Why the last read failed. */
+  error: MachinesError | null;
+}
+/** One server's machines, kept current while subscribed (a machine coming online or going offline re-reads). */
+interface MachineList {
+  /** The list as last read. */
+  state: Readable<MachineListState>;
+  /** Reads it again. Never rejects: a failure lands in `state.error`. */
+  refresh(): Promise<void>;
+}
+/** The saved servers as the registry lists them, with the dates the live statuses lack. */
+interface SavedHostsState {
+  /** `idle` before the first read; `loading` while one is in flight; `ready` or `error` after. */
+  status: 'idle' | 'loading' | 'ready' | 'error';
+  /** The hosts from the last read that succeeded (`addedAt`, `lastConnectedAt`); empty until one did. */
+  hosts: readonly HostSummary[];
+  /** Why the last read failed. */
+  error: MachinesError | null;
+}
+/** The saved-server registry, kept current while subscribed. */
+interface SavedHosts {
+  /** The registry as last read. */
+  state: Readable<SavedHostsState>;
+  /** Reads it again (after an add, rename or remove). Never rejects. */
+  refresh(): Promise<void>;
+}
+/**
+ * Settings sync from this computer to a server, and the server's own record. Every action rejects with a
+ * {@link MachinesError} (`sync`).
+ */
+interface HostSync {
+  /** This computer's sync to `hostId`, kept current. Absent: no Sync section (the app is not a syncing device). */
+  state?(hostId: string): HostSyncRead<HostSyncState>;
+  /** Changes the mode, the categories or the opted-in keys. Absent: the section is read-only. */
+  configure?(hostId: string, patch: HostSyncPatch): Promise<void>;
+  /** Pushes now. Absent: no Push now. */
+  push?(hostId: string): Promise<void>;
+  /** Makes this computer the server's source instead of another device. Absent: no Take over. */
+  takeOver?(hostId: string): Promise<void>;
+  /** The server's sync record (who syncs there, overrides), kept current: the markers in its Settings. */
+  status(hostId: string): HostSyncRead<SyncStatus>;
+  /** Drops an override on the server, so sync writes that field again. Absent: no Sync again. */
+  reset?(hostId: string, field: string): Promise<void>;
+  /** The server's providers (`auth.status`), never a secret. Absent: the accounts list shows this computer's side alone. */
+  providers?(hostId: string): Promise<readonly HostProviderAuth[]>;
+}
+/** What a sign-in on a server is for: a provider, or an MCP server of its catalog (in `cwd`'s project). */
+type HostSignInTarget = {
+  provider: string;
+} | {
+  mcpServer: string;
+  cwd?: string;
+};
+/** The machines servers hold. */
+interface MachinesDirectory {
+  /** `hostId`'s machines. The same id answers the same list. */
+  list(hostId: string): MachineList;
+  /** The names of the machines last heard online, from every host (a session paused on one shows a banner until it is back). */
+  online: Readable<ReadonlySet<string>>;
+  /** Makes `hostId` forget a machine. Rejects with a {@link MachinesError}. Absent: no forget button. */
+  forget?(hostId: string, machineId: string): Promise<void>;
+  /**
+   * Creates a one-time join code on `hostId` for a new machine (`name`: the machine's name there). Rejects with a
+   * {@link MachinesError} (`invite`, `forbidden` below an admin token). Absent: no Add a machine.
+   */
+  invite?(hostId: string, options?: {
+    name?: string;
+    ttlMs?: number;
+  }): Promise<MachineInvite>;
+}
+/** This computer's machine links: shared with servers (it is their machine), and servers used as machines. */
+interface MachineLinks {
+  /** The links as last heard. */
+  state: Readable<MachineLinksStatus>;
+  /** Reads them again. Never rejects. */
+  refresh(): Promise<void>;
+  /** Shares this computer with `hostId` under `name`, in `roots`; `token` when the server asked for one. Absent: no share. */
+  shareStart?(hostId: string, name: string, roots: readonly string[], token?: string): Promise<MachineActionResult>;
+  /** Stops sharing this computer with `hostId`. */
+  shareStop?(hostId: string): Promise<MachineActionResult>;
+  /** Starts or stops using `hostId` as a machine. Absent: no use button. */
+  useServer?(hostId: string, enabled: boolean): Promise<MachineActionResult>;
+}
+/** A server's self-update. Every method rejects with a {@link MachinesError}. */
+interface ServerUpdates {
+  /** Where `hostId`'s self-update stands; `null` from a server that predates it. */
+  status(hostId: string): Promise<ServerUpdateStatus | null>;
+  /** Checks for a release now. Absent: no Check now. */
+  check?(hostId: string): Promise<ServerUpdateStatus>;
+  /** Installs the ready or waiting release now. Absent: no Install now. */
+  install?(hostId: string): Promise<ServerUpdateStatus>;
+  /** Turns the self-update on or off. Absent: no Turn on / off. */
+  configure?(hostId: string, enabled: boolean): Promise<ServerUpdateStatus>;
+}
+/** A token's scope on a server: a client scope, or `machine` (it lends a computer). */
+type ServerTokenScope = ClientScope | 'machine';
+/** A server's client token as listed: never its secret. */
+interface ServerToken {
+  /** Stable id (`tok_…`). */
+  id: string;
+  /** The name it was created with, such as the device it is for. */
+  name: string;
+  /** What it may do. */
+  scope: ServerTokenScope;
+  /** When it was created, epoch ms. */
+  createdAt: number;
+  /** When it last opened a connection, epoch ms. */
+  lastUsedAt?: number;
+  /** When it was revoked, epoch ms. Absent: live. */
+  revokedAt?: number;
+  /** When it stops working, epoch ms. Absent: never. */
+  expiresAt?: number;
+}
+/** A server's client tokens. Every method rejects with a {@link MachinesError}. */
+interface ServerTokens {
+  /** `hostId`'s tokens, revoked ones included. */
+  list(hostId: string): Promise<readonly ServerToken[]>;
+  /** Creates a token; the answer carries its secret, shown once. Absent: no create form. */
+  create?(hostId: string, name: string, scope: ServerTokenScope): Promise<ServerToken & {
+    token: string;
+  }>;
+  /** Revokes a token. Absent: no revoke buttons. */
+  revoke?(hostId: string, id: string): Promise<void>;
+  /** Calls `listener` when `hostId`'s tokens changed elsewhere (another page, a pairing, the CLI). Returns the unsubscribe. Absent: the list is read when shown and after its own changes. */
+  onChanged?(hostId: string, listener: () => void): () => void;
+}
+/** The desktop app's local daemon, as `daemon:status` reports it. */
+interface DaemonStatus {
+  /** Daemon mode is on. */
+  enabled: boolean;
+  /** Where the connection is. */
+  state: 'connected' | 'connecting' | 'refused' | 'unreachable' | 'disabled';
+  /** The daemon's socket. */
+  socketPath: string;
+  /** This window's side of the handshake. */
+  window: {
+    protocolVersion: number;
+    buildId: string;
+  };
+  /** From the handshake, also reported by a daemon that refused it. */
+  daemon?: {
+    pid: number;
+    protocolVersion: number;
+    codeVersion?: string;
+    buildId?: string;
+    startedAt: number;
+    retiring?: boolean;
+  };
+  /** Why the daemon refused this window. */
+  refused?: {
+    message: string;
+    direction: 'daemon-newer' | 'daemon-older' | 'unknown';
+  };
+  /** Why it is unreachable. */
+  error?: string;
+  /** The sessions the daemon holds (connected only). */
+  sessions?: ReadonlyArray<{
+    sessionId: string;
+    running: boolean;
+    waitingForYou: boolean;
+    windows: number;
+  }>;
+}
+/** The desktop app's local daemon: its health, status and recovery actions. */
+interface DaemonControl {
+  /** The connection's health, for the orb. */
+  health: Readable<DaemonHealth>;
+  /** Reads the status; `null` when it can't be read. */
+  status(): Promise<DaemonStatus | null>;
+  /** Reconnects now. Absent: no Reconnect now. */
+  reconnect?(): Promise<DaemonStatus>;
+  /** Restarts the daemon after its runs (`force`: now). Absent: no restart. */
+  restart?(force: boolean): Promise<{
+    deferred?: boolean;
+  }>;
+  /** Stops a session's run, or `'all'` of them (answers how many). Absent: no Stop. */
+  stopRun?(target: string): Promise<number | void>;
+  /** Relaunches the app (the daemon runs newer code). Absent: no Relaunch. */
+  relaunchApp?(): Promise<void>;
+}
+/** An action `permitted` may withhold. */
+type MachinesAction = 'machines.list' | 'machines.forget' | 'machines.invite' | 'update.status' | 'update.manage' | 'tokens.list' | 'tokens.manage';
+/** What the machines components read and the actions they send. */
+interface MachinesHost {
+  /** The hosts the app knows and their connection. Absent: no host list. */
+  hosts?: Readable<HostsState>;
+  /** Reads the hosts again (after a setting changed). */
+  refreshHosts?(): Promise<void>;
+  /** Reconnects to a server now instead of at the next backoff. Absent: no Retry. */
+  retry?(hostId: string): Promise<void>;
+  /** Tests a saved server, or a URL and token before saving. Absent: no Test. */
+  testHost?(target: {
+    id: string;
+  } | {
+    url: string;
+    token: string;
+  }): Promise<HostCheckResult>;
+  /** Saves a server after checking it. Absent: no add form. */
+  addHost?(input: {
+    url: string;
+    token: string;
+    name?: string;
+  }): Promise<HostCheckResult>;
+  /** Renames a saved server. Absent: no Rename. */
+  renameHost?(id: string, name: string): Promise<HostCheckResult>;
+  /** Moves a saved server to a new URL with its saved token, once the same server answers there. Absent: no Change URL. */
+  setHostUrl?(id: string, url: string): Promise<HostCheckResult>;
+  /** Removes a saved server and its token. Rejects with a {@link MachinesError}. Absent: no Remove. */
+  removeHost?(id: string): Promise<void>;
+  /** The saved-server registry with its dates. Absent: the hosts list shows the live statuses alone. */
+  savedHosts?: SavedHosts;
+  /** Settings sync to a server and the server's record. Absent: no Sync section, no markers. */
+  sync?: HostSync;
+  /**
+   * Starts a browser sign-in whose tokens stay on `hostId` (the browser opens here); `onDone` runs once the server
+   * stored them. Absent: no "Sign in there".
+   */
+  signIn?(hostId: string, target: HostSignInTarget, onDone?: () => void): SignInFlow;
+  /** The machines servers hold. Absent: no machine list. */
+  machines?: MachinesDirectory;
+  /** This computer's machine links. Absent: no share or use rows. */
+  links?: MachineLinks;
+  /** Picks a folder to share (the native dialog). Absent: no Add a folder. */
+  pickFolder?(): Promise<string | null>;
+  /** A server's self-update. Absent: no update section. */
+  updates?: ServerUpdates;
+  /** A server's client tokens. Absent: no token list. */
+  tokens?: ServerTokens;
+  /** The local daemon. Absent: no daemon menu. */
+  daemon?: DaemonControl;
+  /**
+   * What a host can do (OS, tools on PATH, sandbox, environment kinds, what it allows, disk); `refresh` probes again
+   * instead of the backend's short cache. Rejects with a {@link MachinesError} (`read`). Absent: no capabilities.
+   */
+  capabilities?(hostId: string, options?: {
+    refresh?: boolean;
+  }): Promise<HostCapabilities>;
+  /** Live per-session presence (attached windows, runs, waiting on you). Absent: no presence on the rows. */
+  presence?: MachinesPresence;
+  /** What the members may do right now; `null` while that is not known (not connected). Absent: everything they offer. */
+  permitted?: Readable<ReadonlySet<MachinesAction> | null>;
+}
+/**
+ * A {@link MachinesError} from whatever a backend threw.
+ *
+ * @param kind - The action that failed.
+ * @param error - What the backend threw or rejected with.
+ */
+declare function machinesError(kind: MachinesError['kind'], error: unknown): MachinesError;
+/**
+ * Whether a value is a {@link MachinesError}.
+ *
+ * @param value - Anything a host rejected with.
+ */
+declare function isMachinesError(value: unknown): value is MachinesError;
+/**
+ * Whether `permitted` lets an action through: always without the store (`undefined`), never while it is not known (`null`).
+ *
+ * @param permitted - The host's `permitted` value (`undefined` when the host has no such store).
+ * @param action - The action.
+ */
+declare function isPermitted(permitted: ReadonlySet<MachinesAction> | null | undefined, action: MachinesAction): boolean;
+//#endregion
+export { DaemonControl, type DaemonHealth, DaemonStatus, type HostCapabilities, HostCheckError, HostCheckResult, type HostProviderAuth, HostSignInTarget, HostSummary, HostSync, HostsState, MachineActionResult, type MachineInfo, MachineInvite, MachineLinks, type MachineLinksStatus, MachineList, MachineListState, MachinesAction, MachinesDirectory, MachinesError, MachinesHost, SavedHosts, SavedHostsState, ServerToken, ServerTokenScope, ServerTokens, type ServerUpdateStatus, ServerUpdates, isMachinesError, isPermitted, machinesError };

package/dist/machines/headless/host.js

@@ -0,0 +1,34 @@
+//#region src/machines/headless/host.ts
+/**
+* A {@link MachinesError} from whatever a backend threw.
+*
+* @param kind - The action that failed.
+* @param error - What the backend threw or rejected with.
+*/
+function machinesError(kind, error) {
+	if (isMachinesError(error)) return error;
+	return {
+		kind,
+		detail: error instanceof Error ? error.message : typeof error === "string" ? error : String(error)
+	};
+}
+/**
+* Whether a value is a {@link MachinesError}.
+*
+* @param value - Anything a host rejected with.
+*/
+function isMachinesError(value) {
+	return typeof value === "object" && value !== null && typeof value.kind === "string" && typeof value.detail === "string";
+}
+/**
+* Whether `permitted` lets an action through: always without the store (`undefined`), never while it is not known (`null`).
+*
+* @param permitted - The host's `permitted` value (`undefined` when the host has no such store).
+* @param action - The action.
+*/
+function isPermitted(permitted, action) {
+	if (permitted === void 0) return true;
+	return permitted !== null && permitted.has(action);
+}
+//#endregion
+export { isMachinesError, isPermitted, machinesError };

package/dist/machines/headless/index.d.ts

@@ -0,0 +1,8 @@
+import { MachinesPresence, PresenceFeed, SessionPresence, createPresenceStore } from "./presence.js";
+import { DEFAULT_MACHINES_LABELS, MachinesLabels } from "./labels.js";
+import { HostSyncAccount, HostSyncConfig, HostSyncPatch, HostSyncRead, HostSyncState, SyncBlockedReason, SyncCategory, SyncMode, SyncOutcome, SyncPushResult, SyncStatus, createHostSyncReads, shortList, syncBlockedReason, syncOutcome } from "./sync.js";
+import { DaemonControl, DaemonHealth, DaemonStatus, HostCapabilities, HostCheckError, HostCheckResult, HostProviderAuth, HostSignInTarget, HostSummary, HostSync, HostsState, MachineActionResult, MachineInfo, MachineInvite, MachineLinks, MachineLinksStatus, MachineList, MachineListState, MachinesAction, MachinesDirectory, MachinesError, MachinesHost, SavedHosts, SavedHostsState, ServerToken, ServerTokenScope, ServerTokens, ServerUpdateStatus, ServerUpdates, isMachinesError, isPermitted, machinesError } from "./host.js";
+import { LazyReadableOptions, LazySink, createMachineLists, createOnlineMachines, lazyReadable } from "./stores.js";
+import { MachinesTone, UPDATE_BUSY_STATES, agoText, daemonStatusText, hostCheckMessage, hostCheckOkLine, hostStatusText, hostStatusTone, linkStateText, updateStateLine, uptimeText } from "./messages.js";
+import { hostOfSettingsFocus, hostSettingsFocus } from "./settings-focus.js";
+export { DEFAULT_MACHINES_LABELS, DaemonControl, type DaemonHealth, DaemonStatus, type HostCapabilities, HostCheckError, HostCheckResult, type HostProviderAuth, HostSignInTarget, HostSummary, HostSync, HostSyncAccount, HostSyncConfig, HostSyncPatch, HostSyncRead, HostSyncState, HostsState, LazyReadableOptions, LazySink, MachineActionResult, type MachineInfo, MachineInvite, MachineLinks, type MachineLinksStatus, MachineList, MachineListState, MachinesAction, MachinesDirectory, MachinesError, MachinesHost, MachinesLabels, MachinesPresence, MachinesTone, PresenceFeed, SavedHosts, SavedHostsState, ServerToken, ServerTokenScope, ServerTokens, type ServerUpdateStatus, ServerUpdates, SessionPresence, SyncBlockedReason, type SyncCategory, type SyncMode, SyncOutcome, type SyncPushResult, type SyncStatus, UPDATE_BUSY_STATES, agoText, createHostSyncReads, createMachineLists, createOnlineMachines, createPresenceStore, daemonStatusText, hostCheckMessage, hostCheckOkLine, hostOfSettingsFocus, hostSettingsFocus, hostStatusText, hostStatusTone, isMachinesError, isPermitted, lazyReadable, linkStateText, machinesError, shortList, syncBlockedReason, syncOutcome, updateStateLine, uptimeText };

package/dist/machines/headless/index.js

@@ -0,0 +1,8 @@
+import { isMachinesError, isPermitted, machinesError } from "./host.js";
+import { createPresenceStore } from "./presence.js";
+import { createMachineLists, createOnlineMachines, lazyReadable } from "./stores.js";
+import { createHostSyncReads, shortList, syncBlockedReason, syncOutcome } from "./sync.js";
+import { DEFAULT_MACHINES_LABELS } from "./labels.js";
+import { UPDATE_BUSY_STATES, agoText, daemonStatusText, hostCheckMessage, hostCheckOkLine, hostStatusText, hostStatusTone, linkStateText, updateStateLine, uptimeText } from "./messages.js";
+import { hostOfSettingsFocus, hostSettingsFocus } from "./settings-focus.js";
+export { DEFAULT_MACHINES_LABELS, UPDATE_BUSY_STATES, agoText, createHostSyncReads, createMachineLists, createOnlineMachines, createPresenceStore, daemonStatusText, hostCheckMessage, hostCheckOkLine, hostOfSettingsFocus, hostSettingsFocus, hostStatusText, hostStatusTone, isMachinesError, isPermitted, lazyReadable, linkStateText, machinesError, shortList, syncBlockedReason, syncOutcome, updateStateLine, uptimeText };