zidane-ui 9.0.4 → 9.1.3

package/src/machines/headless/labels.ts

@@ -1,356 +0,0 @@
-/**
- * The machines components' strings. One flat dictionary, every key prefixed
- * `machines…` so it shares a `<LabelsProvider>` with the other areas' keys;
- * the headless helpers (`./messages`) take it as an argument.
- */
-import { SYNC_CATEGORY_INFO, SYNC_MODE_LABEL, type SyncCategory, type SyncMode } from 'zidane/chat/pure';
-
-import { DEFAULT_CHAT_LABELS } from '../../chat/headless/labels';
-import type { HostCheckError, MachinesError, ServerTokenScope } from './host';
-import type { SyncBlockedReason } from './sync';
-
-/** The default English strings of the machines components. Override any of them through `MachinesProvider` or `LabelsProvider`. */
-export const DEFAULT_MACHINES_LABELS = {
-  /** One word per host status, for dots and chips (the chat area's `hostStatuses`). */
-  machinesHostStatuses: DEFAULT_CHAT_LABELS.hostStatuses,
-  machinesCancel: 'Cancel',
-  machinesSave: 'Save',
-  machinesRemove: 'Remove',
-  machinesDismiss: 'Dismiss',
-  machinesRetry: 'Retry',
-  /** A failed read or action. The default shows the backend's message. */
-  machinesError: (error: MachinesError) => error.detail,
-  /** "5m" → "5m ago"; a date stays as is. */
-  machinesAgo: (short: string) => `${short} ago`,
-
-  // The offline banner, the removed-host notice, the waiting banner.
-  machinesThisServer: 'This server',
-  machinesOfflineRemoved: (name: string) => `${name} was removed from your hosts.`,
-  machinesOfflineAuthRefused: (name: string) =>
-    `${name} refused this computer's token. Remove it in Settings › Accounts › Hosts, then add it again with a new token.`,
-  machinesOfflineIdentity: (name: string) =>
-    `A different server answers at ${name}'s address. If it was reinstalled, remove it and add it again in Settings › Accounts › Hosts.`,
-  machinesOfflineVersion: (name: string, error?: string) =>
-    `${name} speaks another protocol version${error ? ` (${error})` : ''}. This session is read-only until one side is upgraded.`,
-  machinesOfflineConnecting: (name: string) =>
-    `${name} is still connecting. This session is read-only until it is connected.`,
-  machinesOfflineOther: (name: string, status: string) =>
-    `${name} is ${status}. This session is read-only until it reconnects.`,
-  machinesHostRemoved: (notice: string) => `${notice}. Its chat was closed.`,
-  machinesWaiting: (machine: string) => `Waiting for ${machine}… It is offline. The run continues when it reconnects.`,
-
-  // A server's card (Settings › Hosts › a server).
-  machinesCopy: 'Copy',
-  machinesCopyText: (text: string) => `Copy ${text}`,
-  machinesCopiedText: (text: string) => `Copied ${text}`,
-  machinesHostName: 'Host name',
-  machinesTest: 'Test',
-  machinesTesting: 'Testing…',
-  machinesRename: 'Rename',
-  machinesRenaming: 'Renaming…',
-  machinesHostActions: (name: string) => `${name} actions`,
-  machinesChangeUrl: 'Change URL',
-  machinesChangingUrl: 'Connecting…',
-  machinesUrlChanged: (name: string, url: string) => `${name} now connects at ${url}.`,
-  machinesRemoving: 'Removing…',
-  machinesRemoveTitle: (name: string) => `Remove ${name}?`,
-  machinesRemoveMessage: 'This deletes its URL and token from this computer. Its sessions stay on the server.',
-  machinesRemoveFailed: (name: string, detail: string) => `Couldn't remove ${name}: ${detail}`,
-  machinesFactServerName: (name: string) => `server name ${name}`,
-  machinesFactVersion: (version: string) => `Zidane ${version}`,
-  machinesFactConnected: (ago: string) => `connected ${ago}`,
-  machinesFactScope: (scope: string) => `${scope} token`,
-  machinesFactUptime: (uptime: string) => `up ${uptime}`,
-  machinesOkLine: (name: string, version?: string, latencyMs?: number) =>
-    `${name} answered${version ? ` (zidane ${version})` : ''}${latencyMs !== undefined ? ` in ${latencyMs} ms` : ''}.`,
-  /** What to do about a refusal, per registry error code; `message` is the backend's own words. */
-  machinesCheckError: (error: HostCheckError, message: string): string => {
-    switch (error) {
-      case 'invalid-url':
-        return `That URL won't do: ${message}`;
-      case 'invalid-token':
-        return 'Paste the device token (zidane server token create --name <device> on the server).';
-      case 'invalid-name':
-        return 'A host needs a name.';
-      case 'auth':
-        return `The server refused the token. ${message}`;
-      case 'unreachable':
-        return `Nothing answered: ${message} Check the URL, that the server runs, and the network.`;
-      case 'tls':
-        return `The TLS handshake failed (certificate): ${message} A private or self-signed certificate must be trusted by this computer: add it to the system keychain (or set NODE_EXTRA_CA_CERTS).`;
-      case 'protocol':
-        return `Not a zidane-server this app can use: ${message}`;
-      default:
-        return message;
-    }
-  },
-
-  // The add form.
-  machinesAddServer: 'Add a server',
-  machinesServerUrl: 'Server URL',
-  machinesServerUrlPlaceholder: 'wss://zidane.example.com',
-  machinesDeviceToken: 'Device token',
-  machinesDeviceTokenPlaceholder: 'zds_…',
-  machinesNameOptional: "Name (optional, defaults to the server's name)",
-  machinesAdding: 'Checking the server and saving…',
-  machinesAdd: 'Add',
-
-  // Auto-update.
-  machinesUpdateOn: 'Auto-update on',
-  machinesUpdateOff: 'Auto-update off',
-  machinesUpdateVersion: (version: string) => `v${version}`,
-  machinesUpdateFrom: (version: string) => `from v${version}`,
-  machinesUpdateCheck: 'Check now',
-  machinesUpdateChecking: 'Checking…',
-  machinesUpdateInstall: 'Install now',
-  machinesUpdateTurnOn: 'Turn on',
-  machinesUpdateTurnOff: 'Turn off',
-  machinesUpdateUnsupported: (name: string) => `Update ${name} to a release with auto-update.`,
-  machinesUpdateOtherWay: 'This install updates another way.',
-  machinesUpdateStateChecking: 'Checking for a release…',
-  machinesUpdateStateDownloading: (latest?: string) => `Downloading ${latest ?? 'the release'}…`,
-  machinesUpdateStateReady: (latest?: string) => `${latest} is downloaded and verified, ready to install.`,
-  machinesUpdateStateWaiting: (latest?: string) =>
-    `${latest} is ready. Waiting for runs and background tasks to pause.`,
-  machinesUpdateStateInstalling: (latest?: string) => `Installing ${latest}. Runs continue after the restart.`,
-  machinesUpdateStateError: 'The last check failed.',
-  machinesUpdateRolledBack: (version: string) => `${version} did not start: rolled back.`,
-  machinesUpdateOut: (version: string) => `${version} is out.`,
-  machinesUpdateUpToDate: 'Up to date.',
-  machinesUpdateInstallTitle: (latest?: string) => `Install ${latest} now?`,
-  machinesUpdateInstallMessage:
-    'Runs pause at their next step and continue after the restart. Background commands and terminals still running are stopped.',
-
-  // Machines and links.
-  machinesLinkOff: 'Off',
-  machinesShareTitle: (name: string) => `Share this computer with ${name}`,
-  machinesShareHint: (name: string) => `Let ${name} run commands in folders you pick.`,
-  machinesShareStop: 'Stop sharing',
-  machinesShareOpen: 'Share…',
-  machinesShareForm: 'Share this computer',
-  machinesShareName: (name: string) => `Name on ${name}`,
-  machinesShareNamePlaceholder: "Default: this computer's name",
-  machinesShareFolders: 'Folders it can use',
-  machinesShareAddFolder: 'Add a folder…',
-  machinesShareToken: 'Machine token',
-  machinesShareTokenPlaceholder: 'A machine token of the server (zds_…)',
-  machinesShareStart: 'Start sharing',
-  machinesSharing: (name: string) => `Sharing this computer with ${name}…`,
-  machinesShared: (roots: string, name: string) => `Sharing ${roots} with ${name}.`,
-  machinesStopping: 'Stopping…',
-  machinesUseTitle: (name: string) => `Use ${name} as a machine`,
-  machinesUseMachineName: (machine: string) => `local@${machine}`,
-  machinesUseHint: (name: string) => `Run commands on ${name}. Chats stay here.`,
-  machinesUseNotLent: (name: string) => `${name} does not lend itself (allowAsMachine is off).`,
-  machinesUseStop: 'Stop using',
-  machinesUse: 'Use',
-  machinesConnectingTo: (name: string) => `Connecting to ${name}…`,
-  machinesListTitle: (name: string) => `Machines on ${name}`,
-  machinesListEmpty: 'none yet',
-  machinesStatus: (status: 'online' | 'offline') => status,
-  machinesForget: 'Forget',
-  machinesForgetLabel: (machine: string) => `Forget ${machine}`,
-  machinesForgetTitle: (machine: string) => `Forget ${machine}?`,
-  machinesForgetMessage: (name: string) =>
-    `${name} forgets it. Its sessions there stop working. To use it again, add it with a new join code.`,
-  machinesListNotPermitted: 'Listing machines needs a chat token.',
-  /** An offline machine's chip: `when` is "14:05" today, else a date. */
-  machinesOfflineSince: (when: string) => `offline since ${when}`,
-  machinesVersion: (version: string) => `v${version.replace(/^v/, '')}`,
-  machinesVersionDiffers: (version: string, server: string) =>
-    `Runs v${version.replace(/^v/, '')}. The main server runs v${server.replace(/^v/, '')}. Update one of them.`,
-  machinesGpus: 'GPUs',
-  machinesFolders: 'Folders',
-  machinesInviteOpen: 'Add a machine',
-  machinesInviteCreating: 'Creating a join code…',
-  machinesInviteForm: 'New machine',
-  machinesInviteName: 'Machine name',
-  machinesInviteNamePlaceholder: "Optional. Default: the machine's own name",
-  machinesInviteNameRule: 'Letters, digits, dots, dashes or underscores.',
-  machinesInviteCreate: 'Create join command',
-  machinesInviteTitle: (name: string) => `Add a machine to ${name}`,
-  machinesInviteCommand: 'Join command',
-  machinesInviteCopy: 'Copy the join command',
-  machinesInviteExpires: (time: string) => `Works once, until ${time}.`,
-  machinesInviteHint: 'Run it on the machine. It installs a service that joins this server.',
-  machinesInviteDone: 'Done',
-  machinesInviteNeedsAdmin: 'Needs an admin token on this server.',
-
-  // Tokens.
-  machinesTokensName: 'Name',
-  machinesTokensNamePlaceholder: 'The device it is for',
-  machinesTokensScope: 'Scope',
-  machinesTokensScopes: { chat: 'Chat', approve: 'Approve', admin: 'Admin', machine: 'Machine' } as Record<
-    ServerTokenScope,
-    string
-  >,
-  machinesTokensCreate: 'Create token',
-  machinesTokensCreating: 'Creating…',
-  machinesTokensCreated: (name: string) => `Copy the token for ${name} now: it is not shown again.`,
-  machinesTokensRevoke: 'Revoke',
-  machinesTokensRevokeLabel: (name: string) => `Revoke ${name}`,
-  machinesTokensRevokeTitle: (name: string) => `Revoke ${name}?`,
-  machinesTokensRevokeMessage: 'Apps using it are disconnected and cannot connect again with it.',
-  machinesTokensRevoked: 'revoked',
-  machinesTokensExpired: 'expired',
-  machinesTokensExpires: (date: string) => `expires ${date}`,
-  machinesTokensUsed: (ago: string) => `used ${ago}`,
-  machinesTokensNeverUsed: 'never used',
-  machinesTokensCreatedAt: (ago: string) => `created ${ago}`,
-  machinesTokensEmpty: 'No tokens yet.',
-  machinesTokensList: 'Tokens',
-  machinesTokensNotPermitted: 'Managing tokens needs an admin token.',
-
-  // The daemon menu.
-  machinesDaemonMenu: (health: string) => `Daemon menu, ${health}`,
-  machinesDaemon: 'Daemon',
-  machinesDaemonOff: 'Daemon mode is off',
-  machinesDaemonOffDetail: 'Chats run inside this window.',
-  machinesDaemonConnected: 'Connected',
-  machinesDaemonRetiring: 'Daemon shutting down',
-  machinesDaemonRetiringDetail: 'It exits once its runs finish.',
-  machinesDaemonPid: (pid: number) => `pid ${pid}`,
-  machinesDaemonUp: (uptime: string) => `up ${uptime}`,
-  machinesDaemonProtocol: (version: number) => `protocol ${version}`,
-  machinesDaemonVersions: (daemon: number, window: number) => `Daemon protocol ${daemon}, this window ${window}.`,
-  machinesDaemonNewer: 'Daemon runs newer code',
-  machinesDaemonNewerDetail: (versions: string) => `${versions} Relaunch Zidane to attach.`,
-  machinesDaemonOlder: 'Daemon runs older code',
-  machinesDaemonOlderDetail: (versions: string) => `${versions} Restart it to update.`,
-  machinesDaemonRefused: 'Daemon refused this window',
-  machinesDaemonConnecting: 'Connecting…',
-  machinesDaemonUnreachable: "Can't reach the daemon",
-  machinesDaemonRetrying: 'Retrying every 5 s.',
-  machinesDaemonMinutes: (minutes: number) => `${minutes} min`,
-  machinesDaemonHours: (hours: number, minutes: number) => `${hours} h ${minutes} min`,
-  machinesDaemonDays: (days: number) => `${days} d`,
-  machinesDaemonOnIt: 'On the daemon',
-  machinesDaemonActions: 'Actions',
-  machinesDaemonWaitingForYou: 'Waiting for your answer',
-  machinesDaemonRunning: 'Running',
-  machinesDaemonStop: 'Stop',
-  machinesDaemonStopping: 'Stopping…',
-  machinesDaemonStopped: (title: string) => `Stopped "${title}".`,
-  machinesDaemonStopAll: 'Stop all runs',
-  machinesDaemonStoppingAll: 'Stopping all runs…',
-  machinesDaemonStoppedAll: (count: number | void) => `Stopped ${count} runs.`,
-  machinesDaemonRelaunch: 'Relaunch Zidane',
-  machinesDaemonRelaunchHint: "Loads this window's newer code so it can attach.",
-  machinesDaemonReconnect: 'Reconnect now',
-  machinesDaemonReconnectHint: "Don't wait for the next retry.",
-  machinesDaemonReconnecting: 'Reconnecting…',
-  machinesDaemonReconnected: 'Connected.',
-  machinesDaemonRestart: 'Restart daemon',
-  machinesDaemonRestartHint: 'After its runs finish. This window starts a new one.',
-  machinesDaemonRestarting: 'Restarting…',
-  machinesDaemonRestartDeferred: 'The daemon exits once its runs finish.',
-  machinesDaemonRestarted: 'Daemon restarted.',
-  machinesDaemonRestartNow: 'Restart daemon now',
-  machinesDaemonRestartNowHint: 'Stops running work.',
-  machinesDaemonRestartNowConfirm: 'Restart the daemon now? Every running session on it is stopped.',
-  machinesDaemonModeOff: 'Turn daemon mode off',
-  machinesDaemonModeOn: 'Turn daemon mode on',
-  machinesDaemonModeOffHint: 'Run chats inside this window instead.',
-  machinesDaemonModeOnHint: 'Share runs across windows and the TUI.',
-  machinesDaemonCopy: 'Copy diagnostics',
-  machinesDaemonCopying: 'Copying…',
-  machinesDaemonCopied: 'Diagnostics copied.',
-  // Capabilities
-  machinesCapsMore: (count: number) => `+${count}`,
-  machinesCapsOs: { darwin: 'macOS', linux: 'Linux', win32: 'Windows' } as Record<string, string>,
-  machinesCapsFree: (bytes: number) => `${(bytes / 1024 ** 3).toFixed(bytes < 10 * 1024 ** 3 ? 1 : 0)} GB free`,
-  machinesCapsPartial: 'Update the server for the full check.',
-  machinesCapsChecking: 'Checking…',
-  machinesCapsRecheck: 'Re-check',
-  machinesCapsAvailable: 'Available',
-  machinesCapsMissing: 'Missing',
-  machinesCapsAvailableA11y: 'available',
-  machinesCapsMissingA11y: 'missing',
-  machinesCapsTools: 'Tools',
-  machinesCapsFeatures: 'Features',
-  machinesCapsSandbox: 'OS sandbox',
-  machinesCapsNotAvailable: 'Not available',
-  machinesCapsEnvAvailable: 'Sessions can run here',
-  machinesCapsRemoteInstalls: 'Installs from clients',
-  machinesCapsAsMachine: 'Lends itself as a machine',
-  machinesCapsSync: 'Settings sync',
-  machinesCapsClone: 'Clones from clients',
-  machinesCapsCreateFolders: 'New folders from clients',
-
-  // The hosts list and a host's page (Settings › Accounts › Hosts).
-  machinesHostsTitle: 'Hosts',
-  machinesOpenHost: (name: string) => `Open ${name}`,
-  machinesThisApp: 'This app',
-  machinesLocalDescription: 'This app, or the shared background service.',
-  machinesSavedHostsError: (detail: string) => `Couldn't read the saved servers: ${detail}`,
-  machinesCapabilitiesTitle: 'Capabilities',
-  machinesAutoUpdateTitle: 'Auto-update',
-  machinesSyncTitle: 'Settings sync',
-  machinesMachinesTitle: 'Machines',
-
-  // A server's Sync section.
-  machinesSyncModes: SYNC_MODE_LABEL as Record<SyncMode, string>,
-  machinesSyncCategories: SYNC_CATEGORY_INFO as Record<SyncCategory, { label: string; description: string }>,
-  machinesSyncStartsWithHosts: 'Settings sync starts with remote hosts.',
-  machinesSyncOffline: 'Offline. Changes wait here.',
-  machinesSyncTooOld: 'This server is too old to sync.',
-  machinesSyncPushing: 'Pushing…',
-  machinesSyncNotPushed: 'Not pushed yet',
-  /** `ago` is `syncAgo`'s ("5m ago"). */
-  machinesSyncPushed: (ago: string) => `Pushed ${ago}`,
-  machinesSyncMode: 'Mode',
-  machinesSyncModeDescription: (device: string | undefined, name: string) =>
-    `${device ?? 'This computer'} → ${name}. One way.`,
-  machinesSyncWhat: 'What to sync',
-  machinesSyncBlocked: (reason: SyncBlockedReason, name: string) =>
-    reason === 'newer-server'
-      ? 'Needs a newer server'
-      : reason === 'refuses-installs'
-        ? `${name} refuses installs`
-        : `git is missing on ${name}`,
-  machinesSyncWaiting: 'Waiting to push',
-  machinesSyncWaitingList: (categories: string) => `Waiting to push: ${categories}`,
-  machinesSyncStdio: (name: string, list: string) => `May not run on ${name}: ${list}`,
-  machinesSyncNotSyncable: (list: string) => `Not syncable: ${list}`,
-  machinesSyncFrom: (device: string) => `Synced from ${device}`,
-  machinesSyncTakeOver: 'Take over',
-  machinesSyncTakeOverTitle: (name: string) => `Sync ${name} from this computer?`,
-  machinesSyncTakeOverMessage: (name: string, other: string) =>
-    `${name} is synced from ${other}. This computer becomes its source instead, and ${other} stops pushing there.`,
-  machinesSyncEditedOnTitle: (name: string) => `Edited on ${name}. Not synced until you reset it.`,
-  machinesSyncEditedOn: (name: string) => `edited on ${name}`,
-  machinesSyncAgain: 'Sync again',
-  machinesSyncPushNow: 'Push now',
-  machinesSyncEnvTitle: (name: string) => `Copy your cloud sandbox keys to ${name}?`,
-  machinesSyncEnvMessage: (name: string) =>
-    `E2B and Daytona keys are stored on ${name}. Anyone with a token for it can use them.`,
-  machinesSyncEnvConfirm: 'Copy the keys',
-  machinesSyncKeyTitle: (label: string, name: string) => `Copy your ${label} API key to ${name}?`,
-  machinesSyncKeyMessage: (name: string) => `The key is stored on ${name}. Anyone with a token for it can use the key.`,
-  machinesSyncKeyConfirm: 'Copy the key',
-  // The last push's chip.
-  machinesSyncComplete: 'Sync complete',
-  machinesSyncPartial: 'Partial sync',
-  machinesSyncNotSynced: 'Not synced',
-  machinesSyncWarnings: 'Warnings',
-  machinesSyncMoreLines: (count: number) => `and ${count} more`,
-  machinesSyncOutcomeDetails: (label: string) => `${label}: hover for details`,
-  // The accounts list (the API keys tile on).
-  machinesSyncAccounts: 'Accounts',
-  machinesSyncNoAccounts: 'No API key or sign-in on this computer.',
-  machinesSyncSetUpOn: (name: string) => `Set up on ${name}`,
-  machinesSyncOnHost: (name: string) => `on ${name}`,
-  machinesSyncCopyKey: (label: string) => `Copy the ${label} API key`,
-  machinesSyncApiKey: 'API key',
-  /** A sign-in's label; the only one is `Default`. */
-  machinesSyncSignIn: (label: string) => (label === 'Default' ? 'Sign-in' : label),
-  machinesSyncSignedInThere: 'signed in there',
-  machinesSyncSignInThere: 'Sign in there',
-  machinesSyncStaysHere: 'stays here',
-  // The markers in a server's Settings.
-  machinesSyncSyncedFrom: (device: string) => `synced from ${device}`,
-  machinesSyncEditedHere: (device: string) => `edited here, not synced from ${device}`,
-};
-
-/** The machines components' strings: the shape of {@link DEFAULT_MACHINES_LABELS}. */
-export type MachinesLabels = typeof DEFAULT_MACHINES_LABELS;

package/src/machines/headless/messages.ts

@@ -1,197 +0,0 @@
-/**
- * The machines area's wording, React-free: a daemon status's headline, a
- * registry refusal, an update's state line, a link's state, "5m ago". Each
- * takes the labels, so an app's overrides apply.
- */
-import { MACHINE_LINK_STATE_TEXT, type MachineLinkState } from 'zidane/chat/pure';
-
-import { hostStatusLabel } from '../../chat/headless/hosts';
-import { relativeTime } from '../../chat/headless/session-list';
-import type { DaemonStatus, HostCheckResult, HostSummary, ServerUpdateStatus } from './host';
-import { DEFAULT_MACHINES_LABELS, type MachinesLabels } from './labels';
-
-/**
- * How long a process has been up: `12 min`, `3 h 5 min`, `4 d`.
- *
- * @param startedAt - When it started, epoch ms.
- * @param now - The current time, epoch ms. Default: now.
- * @param labels - The label dictionary.
- */
-export function uptimeText(
-  startedAt: number,
-  now: number = Date.now(),
-  labels: MachinesLabels = DEFAULT_MACHINES_LABELS,
-): string {
-  const minutes = Math.max(0, Math.round((now - startedAt) / 60_000));
-  if (minutes < 60) return labels.machinesDaemonMinutes(minutes);
-  const hours = Math.floor(minutes / 60);
-  return hours < 48
-    ? labels.machinesDaemonHours(hours, minutes % 60)
-    : labels.machinesDaemonDays(Math.floor(hours / 24));
-}
-
-/**
- * The daemon menu's headline, detail and badge facts for a status.
- *
- * @param status - The daemon's status.
- * @param now - The current time, epoch ms (for the uptime).
- * @param labels - The label dictionary.
- */
-export function daemonStatusText(
-  status: DaemonStatus,
-  now: number = Date.now(),
-  labels: MachinesLabels = DEFAULT_MACHINES_LABELS,
-): { title: string; detail: string; facts?: string[] } {
-  const daemon = status.daemon;
-  switch (status.state) {
-    case 'disabled':
-      return { title: labels.machinesDaemonOff, detail: labels.machinesDaemonOffDetail };
-    case 'connected':
-      return {
-        title: daemon?.retiring ? labels.machinesDaemonRetiring : labels.machinesDaemonConnected,
-        detail: daemon?.retiring ? labels.machinesDaemonRetiringDetail : '',
-        facts: daemon
-          ? [
-              labels.machinesDaemonPid(daemon.pid),
-              labels.machinesDaemonUp(uptimeText(daemon.startedAt, now, labels)),
-              labels.machinesDaemonProtocol(daemon.protocolVersion),
-            ]
-          : [labels.machinesDaemonProtocol(status.window.protocolVersion)],
-      };
-    case 'refused': {
-      const versions = daemon
-        ? labels.machinesDaemonVersions(daemon.protocolVersion, status.window.protocolVersion)
-        : (status.refused?.message ?? '');
-      if (status.refused?.direction === 'daemon-newer')
-        return { title: labels.machinesDaemonNewer, detail: labels.machinesDaemonNewerDetail(versions) };
-      if (status.refused?.direction === 'daemon-older')
-        return { title: labels.machinesDaemonOlder, detail: labels.machinesDaemonOlderDetail(versions) };
-      return { title: labels.machinesDaemonRefused, detail: status.refused?.message ?? versions };
-    }
-    case 'connecting':
-      return { title: labels.machinesDaemonConnecting, detail: status.socketPath };
-    default:
-      return { title: labels.machinesDaemonUnreachable, detail: status.error ?? labels.machinesDaemonRetrying };
-  }
-}
-
-/**
- * What to do about a refused test, add or rename.
- *
- * @param result - The refusal.
- * @param labels - The label dictionary.
- */
-export function hostCheckMessage(
-  result: Extract<HostCheckResult, { ok: false }>,
-  labels: MachinesLabels = DEFAULT_MACHINES_LABELS,
-): string {
-  return labels.machinesCheckError(result.error, result.message);
-}
-
-/**
- * A successful test: who answered, its version, how fast.
- *
- * @param result - The answer.
- * @param labels - The label dictionary.
- */
-export function hostCheckOkLine(
-  result: Extract<HostCheckResult, { ok: true }>,
-  labels: MachinesLabels = DEFAULT_MACHINES_LABELS,
-): string {
-  return labels.machinesOkLine(result.name, result.serverVersion, result.latencyMs);
-}
-
-/** The tone of a line or chip: plain, good, worth a look, failed. */
-export type MachinesTone = 'muted' | 'success' | 'warn' | 'danger';
-
-/**
- * A host's status as a chip tone: (re)connecting is not a failure.
- *
- * @param host - The host.
- */
-export function hostStatusTone(host: HostSummary): 'muted' | 'warn' | 'danger' {
-  if (host.status === 'connected') return 'muted';
-  return host.status === 'connecting' || host.status === 'reconnecting' ? 'warn' : 'danger';
-}
-
-/**
- * One word for a host's status, through the machines labels.
- *
- * @param host - The host.
- * @param labels - The label dictionary.
- */
-export function hostStatusText(host: HostSummary, labels: MachinesLabels = DEFAULT_MACHINES_LABELS): string {
-  return hostStatusLabel(host, { hostStatuses: labels.machinesHostStatuses });
-}
-
-/** The update states during which the updater is working (the panel follows it). */
-export const UPDATE_BUSY_STATES: ReadonlySet<ServerUpdateStatus['state']> = new Set([
-  'checking',
-  'downloading',
-  'waiting',
-  'installing',
-]);
-
-/**
- * One line for where a server's self-update stands, and its tone.
- *
- * @param status - The update status.
- * @param labels - The label dictionary.
- */
-export function updateStateLine(
-  status: ServerUpdateStatus,
-  labels: MachinesLabels = DEFAULT_MACHINES_LABELS,
-): { text: string; tone: MachinesTone } {
-  if (!status.supported) return { text: status.reason ?? labels.machinesUpdateOtherWay, tone: 'muted' };
-  switch (status.state) {
-    case 'checking':
-      return { text: labels.machinesUpdateStateChecking, tone: 'muted' };
-    case 'downloading':
-      return { text: labels.machinesUpdateStateDownloading(status.latest), tone: 'muted' };
-    case 'ready':
-      return { text: labels.machinesUpdateStateReady(status.latest), tone: 'warn' };
-    case 'waiting':
-      return { text: labels.machinesUpdateStateWaiting(status.latest), tone: 'warn' };
-    case 'installing':
-      return { text: labels.machinesUpdateStateInstalling(status.latest), tone: 'warn' };
-    case 'error':
-      return { text: status.error ?? labels.machinesUpdateStateError, tone: 'danger' };
-    default:
-      if (status.rolledBackFrom)
-        return { text: labels.machinesUpdateRolledBack(status.rolledBackFrom), tone: 'danger' };
-      if (status.latest && status.latest !== status.current && !status.enabled)
-        return { text: labels.machinesUpdateOut(status.latest), tone: 'warn' };
-      return { text: labels.machinesUpdateUpToDate, tone: 'success' };
-  }
-}
-
-/**
- * A machine link's state, with why it is not connected; `Off` without a link.
- *
- * @param link - The link, or `undefined` when there is none.
- * @param labels - The label dictionary.
- */
-export function linkStateText(
-  link: { state: MachineLinkState; detail?: string } | undefined,
-  labels: MachinesLabels = DEFAULT_MACHINES_LABELS,
-): string {
-  return link
-    ? `${MACHINE_LINK_STATE_TEXT[link.state]}${link.detail ? `: ${link.detail}` : ''}`
-    : labels.machinesLinkOff;
-}
-
-/**
- * "just now", "5m ago", "3h ago", "2d ago", then a date.
- *
- * @param at - When it happened, epoch ms.
- * @param now - The current time, epoch ms.
- * @param labels - The label dictionary.
- */
-export function agoText(
-  at: number,
-  now: number = Date.now(),
-  labels: MachinesLabels = DEFAULT_MACHINES_LABELS,
-): string {
-  const short = relativeTime(at, now);
-  return /^\d+[a-z]+$/.test(short) ? labels.machinesAgo(short) : short;
-}

package/src/machines/headless/presence.ts

@@ -1,110 +0,0 @@
-/**
- * Live per-session presence: which sessions have attached windows, a run in
- * flight, or something waiting on you, keyed by session id. Drives the
- * sidebar rows' status dot, the footer and the palette's session order.
- *
- * Each snapshot carries every live session. Entries that did not change
- * keep their identity, and only changed sessions notify their readers, so a
- * snapshot re-renders only the rows whose presence changed.
- */
-import { writable, type Readable } from '../../chat/headless/store';
-import { createKeyedState } from '../../session/headless/keyed';
-
-/** One session's presence. */
-export interface SessionPresence {
-  /** The session the presence is for. */
-  sessionId: string;
-  /** How many windows are attached to (watching) the session. */
-  windows: number;
-  /** A run is executing right now. */
-  running: boolean;
-  /** A pending approval or question: it waits on the user somewhere. */
-  attention: boolean;
-}
-
-/** Every session's presence, and one session's. */
-export interface MachinesPresence {
-  /** Every live session's presence, by session id (for list-level decisions). */
-  sessions: Readable<ReadonlyMap<string, SessionPresence>>;
-  /** One session's presence (`null`: none); the same store for the same id. */
-  session(sessionId: string): Readable<SessionPresence | null>;
-}
-
-/**
- * Starts the feed: hands each snapshot to `apply` (every live session), and returns how to stop.
- * Re-list on a reconnect: the last snapshot predates it.
- */
-export type PresenceFeed = (apply: (sessions: readonly SessionPresence[]) => void) => () => void;
-
-const EMPTY: ReadonlyMap<string, SessionPresence> = new Map();
-
-function samePresence(a: SessionPresence, b: SessionPresence): boolean {
-  return a.windows === b.windows && a.running === b.running && a.attention === b.attention;
-}
-
-/**
- * Creates the presence stores over a feed. The feed starts with the first reader (of the map or of any
- * session) and stops after the last, which forgets the snapshot.
- *
- * @param feed - Starts listening; see {@link PresenceFeed}.
- */
-export function createPresenceStore(feed: PresenceFeed): MachinesPresence {
-  const map = writable<ReadonlyMap<string, SessionPresence>>(EMPTY);
-  const keyed = createKeyedState<SessionPresence>(null);
-  let readers = 0;
-  let stop: (() => void) | null = null;
-
-  const apply = (list: readonly SessionPresence[]) => {
-    const prev = map.get();
-    const next = new Map<string, SessionPresence>();
-    const changed: string[] = [];
-    for (const s of list) {
-      const before = prev.get(s.sessionId);
-      const kept = before && samePresence(before, s) ? before : s;
-      next.set(s.sessionId, kept);
-      if (kept !== before) changed.push(s.sessionId);
-    }
-    for (const id of prev.keys()) if (!next.has(id)) changed.push(id);
-    if (changed.length === 0) return;
-    for (const id of changed) {
-      const value = next.get(id);
-      if (value) keyed.set(id, value);
-      else keyed.delete(id);
-    }
-    map.set(next);
-  };
-
-  /** Counts a reader in, starting the feed on the first; returns the count-out. */
-  const enter = (off: () => void) => {
-    readers += 1;
-    if (!stop) stop = feed(apply);
-    let done = false;
-    return () => {
-      if (done) return;
-      done = true;
-      off();
-      readers -= 1;
-      if (readers > 0 || !stop) return;
-      const halt = stop;
-      stop = null;
-      halt();
-      // The next reader starts from a fresh snapshot.
-      keyed.clear();
-      map.set(EMPTY);
-    };
-  };
-
-  const sessions = new Map<string, Readable<SessionPresence | null>>();
-  return {
-    sessions: { get: map.get, subscribe: (onChange) => enter(map.subscribe(onChange)) },
-    session(sessionId) {
-      let store = sessions.get(sessionId);
-      if (!store) {
-        const inner = keyed.readable(sessionId);
-        store = { get: inner.get, subscribe: (onChange) => enter(inner.subscribe(onChange)) };
-        sessions.set(sessionId, store);
-      }
-      return store;
-    },
-  };
-}