zidane 7.2.4 → 8.0.4

package/dist/ipc/remote.d.ts

@@ -0,0 +1,313 @@
+import { Qh as ProviderDescriptor } from "../index-BGe1fQT7.js";
+import { ir as HostSignal, un as HostRegistry } from "../index-CHABJd-L.js";
+import { It as HostProbeResult, Mt as HostEntry, Rt as HostTestResult } from "../turn-operations-DQX5ZZni.js";
+import { t as HostConnectionStatus } from "../connection-Dr-Js4yZ.js";
+import { c as SyncClaimResult, d as SyncPushResult, l as SyncMode, p as SyncStatus, s as SyncCategory, u as SyncPayload } from "../types-C7ZFOztE.js";
+import { t as IpcClient } from "../client-core-BQSyDALT.js";
+//#region src/chat/sync/local.d.ts
+interface DeviceIdentity {
+  id: string;
+  name: string;
+}
+interface ServerSyncConfig {
+  mode: SyncMode;
+  categories: SyncCategory[];
+  /** Providers whose stored API key goes to this server. */
+  keys: string[];
+  /** Categories changed here and not pushed yet (offline queue). */
+  pending: SyncCategory[];
+  /** Per category, a hash of what was last pushed (a restart finds what changed meanwhile). */
+  sent: Partial<Record<SyncCategory, string>>;
+  lastSyncAt?: number;
+  lastError?: string;
+  /** What the last push of each category did there. */
+  results: Partial<Record<SyncCategory, SyncPushResult>>;
+}
+//#endregion
+//#region src/chat/sync/engine.d.ts
+/** The part of a host connection sync uses (an `IpcClient` is one). */
+interface SyncClient {
+  request: ((method: 'sync.status', params: Record<string, never>) => Promise<SyncStatus>) & ((method: 'sync.claim', params: {
+    deviceId: string;
+    deviceName: string;
+    takeover?: boolean;
+    categories?: SyncCategory[];
+    keys?: string[];
+  }) => Promise<SyncClaimResult>) & ((method: 'sync.push', params: {
+    deviceId: string;
+    category: SyncCategory;
+    payload: SyncPayload;
+  }) => Promise<SyncPushResult>) & ((method: 'sync.reset', params: {
+    field: string;
+  }) => Promise<{
+    reset: boolean;
+  }>) & ((method: 'sync.release', params: {
+    deviceId: string;
+  }) => Promise<{
+    released: boolean;
+  }>);
+  hello: {
+    sync?: boolean;
+  };
+}
+interface SyncEngineOptions {
+  dataDir: string;
+  statePath: string;
+  home: string;
+  prefix: string;
+  providers: () => Readonly<Record<string, ProviderDescriptor>>;
+  /** Default: this computer's host name. */
+  deviceName?: string;
+  /** Wait after a change before checking (a save is often several writes). Default 500 ms. */
+  debounceMs?: number;
+  /** File watchers (default on); off, only `notifyLocalChange` finds changes. */
+  watch?: boolean;
+}
+/** What a UI shows for one server. */
+interface SyncView {
+  config: ServerSyncConfig;
+  connected: boolean;
+  /** The server takes sync (`ipc.hello.sync`); false for an older server. */
+  supported: boolean;
+  /** The server's record, when read. */
+  status: SyncStatus | null;
+  /** Another device syncs to this server: its name. */
+  conflict: string | null;
+  busy: boolean;
+}
+interface SyncEngine {
+  device: DeviceIdentity;
+  view: (key: string) => SyncView;
+  /** Change the mode, categories or opted-in keys; pushes what that calls for. */
+  configure: (key: string, patch: Partial<Pick<ServerSyncConfig, 'mode' | 'categories' | 'keys'>>) => Promise<void>;
+  /** Push every selected category now (whatever the mode, but off). */
+  pushAll: (key: string) => Promise<void>;
+  /** Become the source of a server another device syncs to, then push. */
+  takeOver: (key: string) => Promise<void>;
+  /** Drop an override on the server (the next push writes the field again). */
+  reset: (key: string, field: string) => Promise<void>;
+  /** Read the server's record again. */
+  refresh: (key: string) => Promise<void>;
+  connected: (key: string, client: SyncClient) => void;
+  disconnected: (key: string) => void;
+  /** A server's `sync:changed` signal. */
+  serverChanged: (key: string) => void;
+  /** The server was removed here: forget its sync config (the server keeps what it has). */
+  removed: (key: string) => void;
+  /** This computer changed something (the app's settings stream): check, push if it differs. */
+  notifyLocalChange: (category?: SyncCategory) => void;
+  /** What this computer has that the UIs mention: API keys to opt in, extensions that can't sync, stdio MCP servers. */
+  localInfo: () => SyncLocalInfo;
+  /** File watchers are running (some server keeps in sync). */
+  watching: () => boolean;
+  subscribe: (listener: () => void) => () => void;
+  stop: () => void;
+}
+interface SyncLocalInfo {
+  keyProviders: {
+    key: string;
+    label: string;
+  }[];
+  localExtensions: string[];
+  stdioMcps: string[];
+}
+declare function createSyncEngine(options: SyncEngineOptions): SyncEngine;
+//#endregion
+//#region src/ipc/hosts/connection-loop.d.ts
+/** How a failed connect is handled: retried with backoff, or reported and left alone. */
+type HostFailureKind = 'auth' | 'identity' | 'retry';
+/** What the loop says about its host, applied by the owner to its directory entry. */
+interface HostConnectionPatch {
+  client?: IpcClient | null;
+  status?: HostConnectionStatus;
+  /** Why the last connect failed; `undefined` once connected. */
+  error?: string | undefined;
+  /** The host's own name, from its `ipc.hello`. */
+  serverName?: string;
+}
+interface HostConnectionLoopOptions {
+  /** One connect attempt. `onClose` fires when that connection drops (not on `close()`). */
+  connect: (options: {
+    signal: AbortSignal;
+    onClose: () => void;
+  }) => Promise<IpcClient>;
+  update: (patch: HostConnectionPatch) => void;
+  /**
+   * `auth`: the token was refused; `identity`: another host answered. Both
+   * are for good (no retry until `retry()`). Default: every failure retries.
+   */
+  classify?: (err: unknown) => HostFailureKind;
+  /** Connected (also after a reconnect). */
+  onConnected?: (client: IpcClient) => void;
+  /** Every signal of the live connection. */
+  onSignal?: (signal: HostSignal) => void;
+  /** The live connection dropped (a reconnect is scheduled). */
+  onDisconnected?: () => void;
+  /** Backoff bounds, ms (tests shrink them). */
+  minDelayMs?: number;
+  maxDelayMs?: number;
+}
+interface HostConnectionLoop {
+  stop: () => void;
+  /** Try now (a manual retry, or after an auth fix). */
+  retry: () => void;
+}
+declare function keepHostConnected(options: HostConnectionLoopOptions): HostConnectionLoop;
+//#endregion
+//#region src/ipc/hosts/probe.d.ts
+/** Bound on one probe: the upgrade, the handshake and `daemon.info`. */
+declare const HOST_PROBE_TIMEOUT_MS = 10000;
+/** Connect, read the host's identity and `daemon.info`, disconnect. Never throws. */
+declare function probeWsHost(target: {
+  url: string;
+  token: string;
+  timeoutMs?: number;
+}): Promise<HostProbeResult>;
+/** The registry in `dataDir`, connecting over WebSocket. */
+declare function createWsHostRegistry(options: {
+  dataDir: string;
+}): HostRegistry;
+//#endregion
+//#region src/ipc/hosts/saved-hosts.d.ts
+/** The client's host directory, as the saved servers see it. Keys are host ids. */
+interface SavedHostsDirectory {
+  /** The saved servers it holds now, with their URL (a `--host` server excluded). */
+  saved: () => {
+    key: string;
+    url: string;
+  }[];
+  /** Add the entry, or reconfigure the one under its key in place (status `connecting`). */
+  upsert: (entry: HostEntry, token: string | undefined) => void;
+  update: (key: string, patch: HostConnectionPatch & {
+    name?: string;
+    serverVersion?: string;
+  }) => void;
+  /** The server left the registry, or the saved servers stopped. */
+  remove: (key: string) => void;
+}
+/** No token is saved for this server (removed by hand, or another window removed it). */
+declare class MissingHostTokenError extends Error {
+  constructor();
+}
+interface SavedHostsOptions {
+  registry: HostRegistry;
+  directory: SavedHostsDirectory;
+  /** One connect attempt to a saved server, with its token read fresh. */
+  connect: (entry: HostEntry, token: string, options: {
+    signal: AbortSignal;
+    onClose: () => void;
+  }) => Promise<IpcClient>;
+  /** `auth`: refused for good. A missing token is always `auth`, another host answering always `identity`. */
+  classify?: (err: unknown) => HostFailureKind;
+  /** The add form's test of an unsaved URL + token (`probeUnsavedHost`). */
+  probeUnsaved?: (target: {
+    url: string;
+    token: string;
+  }) => Promise<HostProbeResult>;
+  /** Saved entries the directory already reaches another way (the TUI's `--host` server). */
+  skip?: (entry: HostEntry) => boolean;
+  onSignal?: (key: string, signal: HostSignal) => void;
+  onConnected?: (key: string, client: IpcClient) => void;
+  onDisconnected?: (key: string) => void;
+  minDelayMs?: number;
+  maxDelayMs?: number;
+}
+interface SavedHostsController {
+  /** The saved hosts, read fresh (other windows share the file). */
+  list: () => HostEntry[];
+  /** Verify, save, connect (in place when already saved). Throws a `HostRegistryError`. */
+  add: (input: {
+    url: string;
+    token: string;
+    name?: string;
+  }) => Promise<HostEntry>;
+  remove: (id: string) => boolean;
+  rename: (id: string, name: string) => HostEntry;
+  /** A saved server (by id), or an unsaved URL + token (the add form's test). */
+  test: (target: string | {
+    id: string;
+  } | {
+    url: string;
+    token: string;
+  }) => Promise<HostTestResult>;
+  /** Reconnect now (after an outage or a token fix). */
+  retry: (id: string) => void;
+  stop: () => void;
+}
+declare function startSavedHosts(options: SavedHostsOptions): SavedHostsController;
+//#endregion
+//#region src/ipc/hosts/ws.d.ts
+/** A refused token stays refused until the user changes something: no retry loop. */
+declare function classifyWsFailure(err: unknown): HostFailureKind;
+/** The add form's "test": the registry's own checks and probe over WebSocket, saving nothing. */
+declare function probeUnsavedWsHost(target: {
+  url: string;
+  token: string;
+}): Promise<HostProbeResult>;
+type WsSavedHostsOptions = Omit<SavedHostsOptions, 'registry' | 'connect' | 'classify' | 'probeUnsaved'> & {
+  dataDir: string;
+  /** Client version in the server's diagnostics (default dial only). */
+  appVersion?: string;
+  /** Dial another way (the TUI goes through its directory entry's transport). Default: `connectWsClient`. */
+  connect?: SavedHostsOptions['connect'];
+  registry?: SavedHostsOptions['registry'];
+};
+declare function startWsSavedHosts(options: WsSavedHostsOptions): SavedHostsController;
+//#endregion
+//#region src/ipc/transports/ws-auth.d.ts
+type WsTokenCarrier = 'header' | 'subprotocol';
+declare const WS_REFUSAL_REASONS: readonly ["origin", "insecure-transport", "untrusted-proxy", "scope"];
+type WsRefusalReason = typeof WS_REFUSAL_REASONS[number];
+//#endregion
+//#region src/ipc/transports/ws-client.d.ts
+interface WsClientOptions {
+  /** `ws://` or `wss://` URL of the server. */
+  url: string;
+  /** Bearer token for the server, see `./ws-auth`. */
+  token?: string;
+  /**
+   * How the token travels. Default: the `Authorization` header where the
+   * runtime's WebSocket can set one (Bun), else the subprotocol fallback.
+   */
+  tokenCarrier?: WsTokenCarrier;
+  /** Client zidane version, surfaced in the host's diagnostics. */
+  appVersion?: string;
+  /** The connection dropped (server exit, network error, a missed deadline or heartbeat). Not called for `close()`. */
+  onClose?: () => void;
+  /** `$/ping` interval (`./client-core`). Default {@link WS_HEARTBEAT_MS}; `0` disables. */
+  heartbeatMs?: number;
+  /** Bound on the upgrade (not the handshake, which has its own). Default {@link WS_OPEN_TIMEOUT_MS}. */
+  openTimeoutMs?: number;
+  /** Abandon the connect (upgrade and handshake): it rejects with the signal's reason. */
+  signal?: AbortSignal;
+  /**
+   * The host id a saved host answered with when it was added: a hello with
+   * any other id closes the connection and rejects with a
+   * {@link HostIdentityError} (nothing is read from that host).
+   */
+  expectHostId?: string;
+  /**
+   * Answer the host's requests and notifications on this connection: a
+   * machine serving its host (`docs/MACHINES.md`). A throw becomes a
+   * JSON-RPC error (its `code` when it carries one). Default: a client
+   * refuses requests and reads only `ipc.signal`.
+   */
+  serve?: {
+    request: (method: string, params: unknown) => Promise<unknown>;
+    notification?: (method: string, params: unknown) => void;
+  };
+}
+/**
+ * The server refused this client's credential: 401 (no valid token) or 403
+ * (not allowed here). `reason` only when the server sent a code clients know.
+ */
+declare class HostAuthError extends Error {
+  readonly status: 401 | 403;
+  readonly reason?: WsRefusalReason | undefined;
+  readonly url: string;
+  constructor(url: string, status: 401 | 403, reason?: WsRefusalReason | undefined);
+}
+declare function connectWsClient(options: WsClientOptions): Promise<IpcClient>;
+//#endregion
+export { HOST_PROBE_TIMEOUT_MS, HostAuthError, type HostConnectionLoop, type HostConnectionLoopOptions, type HostConnectionPatch, MissingHostTokenError, type SavedHostsController, type SavedHostsDirectory, type SavedHostsOptions, type ServerSyncConfig, type SyncClient, type SyncEngine, type SyncEngineOptions, type SyncLocalInfo, type SyncView, type WsClientOptions, type WsSavedHostsOptions, classifyWsFailure, connectWsClient, createSyncEngine, createWsHostRegistry, keepHostConnected, probeUnsavedWsHost, probeWsHost, startSavedHosts, startWsSavedHosts };
+//# sourceMappingURL=remote.d.ts.map

package/dist/ipc/remote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote.d.ts","names":[],"sources":["../../src/chat/sync/local.ts","../../src/chat/sync/engine.ts","../../src/ipc/hosts/connection-loop.ts","../../src/ipc/hosts/probe.ts","../../src/ipc/hosts/saved-hosts.ts","../../src/ipc/hosts/ws.ts","../../src/ipc/transports/ws-auth.ts","../../src/ipc/transports/ws-client.ts"],"mappings":";;;;;;;UAmBiB;EACf;EACA;;UAGe;EACf,MAAM;EACN,YAAY;;EAEZ;;EAEA,SAAS;;EAET,MAAM,QAAQ,OAAO;EACrB;EACA;;EAEA,SAAS,QAAQ,OAAO,cAAc;;;;;UCTvB;EACf,WAAW,uBAAuB,QAAQ,0BAA0B,QAAQ,iBACtE,sBAAsB;IAAU;IAAkB;IAAoB;IAAoB,aAAa;IAAgB;QAAsB,QAAQ,sBACrJ,qBAAqB;IAAU;IAAkB,UAAU;IAAc,SAAS;QAAkB,QAAQ,qBAC5G,sBAAsB;IAAU;QAAoB;IAAU;UAC9D,wBAAwB;IAAU;QAAuB;IAAU;;EACzE;IAAS;;;UAGM;EACf;EACA;EACA;EACA;EACA,iBAAiB,SAAS,eAAe;;EAEzC;;EAEA;;EAEA;;;UAIe;EACf,QAAQ;EACR;;EAEA;;EAEA,QAAQ;;EAER;EACA;;UAGe;EACf,QAAQ;EACR,OAAO,gBAAgB;;EAEvB,YAAY,aAAa,OAAO,QAAQ,KAAK,uDAAuD;;EAEpG,UAAU,gBAAgB;;EAE1B,WAAW,gBAAgB;;EAE3B,QAAQ,aAAa,kBAAkB;;EAEvC,UAAU,gBAAgB;EAC1B,YAAY,aAAa,QAAQ;EACjC,eAAe;;EAEf,gBAAgB;;EAEhB,UAAU;;EAEV,oBAAoB,WAAW;;EAE/B,iBAAiB;;EAEjB;EACA,YAAY;EACZ;;UAGe;EACf;IAAgB;IAAa;;EAC7B;EACA;;iBAac,iBAAiB,SAAS,oBAAoB;;;;KC1FlD;;UAKK;EACf,SAAS;EACT,SAAS;;EAET;;EAEA;;UAGe;;EAEf,UAAU;IAAW,QAAQ;IAAa;QAA0B,QAAQ;EAC5E,SAAS,OAAO;;;;;EAKhB,YAAY,iBAAiB;;EAE7B,eAAe,QAAQ;;EAEvB,YAAY,QAAQ;;EAEpB;;EAEA;EACA;;UAGe;EACf;;EAEA;;iBAOc,kBAAkB,SAAS,4BAA4B;;;;cCnD1D;;iBAwCS,YAAY;EAAU;EAAa;EAAe;IAAuB,QAAQ;;iBA8BvF,qBAAqB;EAAW;IAAoB;;;;UCrDnD;;EAEf;IAAe;IAAa;;;EAE5B,SAAS,OAAO,WAAW;EAC3B,SAAS,aAAa,OAAO;IAAwB;IAAe;;;EAEpE,SAAS;;;cAIE,8BAA8B;EAAA;;UAO1B;EACf,UAAU;EACV,WAAW;;EAEX,UAAU,OAAO,WAAW,eAAe;IAAW,QAAQ;IAAa;QAA0B,QAAQ;;EAE7G,YAAY,iBAAiB;;EAE7B,gBAAgB;IAAU;IAAa;QAAoB,QAAQ;;EAEnE,QAAQ,OAAO;EACf,YAAY,aAAa,QAAQ;EACjC,eAAe,aAAa,QAAQ;EACpC,kBAAkB;EAClB;EACA;;UAGe;;EAEf,YAAY;;EAEZ,MAAM;IAAS;IAAa;IAAe;QAAoB,QAAQ;EACvE,SAAS;EACT,SAAS,YAAY,iBAAiB;;EAEtC,OAAO;IAAmB;;IAAiB;IAAa;QAAoB,QAAQ;;EAEpF,QAAQ;EACR;;iBAGc,gBAAgB,SAAS,oBAAoB;;;;iBChE7C,kBAAkB,eAAe;;iBAKjC,mBAAmB;EAAU;EAAa;IAAkB,QAAQ;KAIxE,sBAAsB,KAAK;EACrC;;EAEA;;EAEA,UAAU;EACV,WAAW;;iBAGG,kBAAkB,SAAS,sBAAsB;;;KChBrD;cA0BN;KACM,yBAAyB;;;UCZpB;;EAEf;;EAEA;;;;;EAKA,eAAe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA,SAAS;;;;;;EAMT;;;;;;;EAOA;IACE,UAAU,gBAAgB,oBAAoB;IAC9C,gBAAgB,gBAAgB;;;;;;;cAoBvB,sBAAsB;WAEC;WAA4B,SAAS;WAD9D;EACG,YAAA,aAAsB,mBAA4B,SAAS;;iBAyGnD,gBAAgB,SAAS,kBAAkB,QAAQ"}

package/dist/ipc/remote.js

@@ -0,0 +1,4 @@
+import { a as startSavedHosts, c as probeWsHost, i as MissingHostTokenError, l as createSyncEngine, n as probeUnsavedWsHost, o as HOST_PROBE_TIMEOUT_MS, r as startWsSavedHosts, s as createWsHostRegistry, t as classifyWsFailure } from "../ws-CIHMvlSh.js";
+import { t as keepHostConnected } from "../connection-loop-gdh22LTI.js";
+import { n as connectWsClient, t as HostAuthError } from "../ws-client-N7NxzvQp.js";
+export { HOST_PROBE_TIMEOUT_MS, HostAuthError, MissingHostTokenError, classifyWsFailure, connectWsClient, createSyncEngine, createWsHostRegistry, keepHostConnected, probeUnsavedWsHost, probeWsHost, startSavedHosts, startWsSavedHosts };