@stim-cli/server 0.0.0 → 1.10.0

package/dist/protocol.d.mts

@@ -0,0 +1,187 @@
+import { NdjsonRecord, StatusPayload } from "@stim-cli/core/state";
+//#region src/protocol.d.ts
+declare const PROTOCOL_VERSION = 1;
+declare const PROTOCOL_SCHEMA_FILE = "protocol.schema.json";
+declare const CAPABILITIES: readonly ["read"];
+type Capability = (typeof CAPABILITIES)[number];
+declare const METHODS: readonly ["hello", "status.subscribe", "logs.query", "logs.subscribe", "stats.get", "settings.get", "frames.subscribe", "unsubscribe"];
+type Method = (typeof METHODS)[number];
+/**
+ * `unauthorized`, `pairing-expired` and `protocol-unsupported` refuse the client until it pairs again or
+ * updates; clients retry the others.
+ */
+declare const ERROR_CODES: readonly ["unauthorized", "pairing-expired", "protocol-unsupported", "identity-unavailable", "bad-request", "unknown-method", "already-authenticated", "unknown-subscription", "unknown-workspace", "limit-exceeded", "slow-client", "status-failed", "logs-failed", "stim-failed", "frames-failed"];
+type ErrorCode = (typeof ERROR_CODES)[number];
+type RequestId = number | string;
+/** Spends a single-use pairing token; the result carries the new device token. */
+interface PairingAuth {
+  pairingToken: string;
+  deviceName: string;
+}
+/** Presents the device token a previous pairing returned. */
+interface DeviceAuth {
+  deviceToken: string;
+}
+interface HelloParams {
+  protocol: number;
+  client: {
+    name: string;
+    version: string;
+  };
+  auth: PairingAuth | DeviceAuth;
+}
+interface HelloResult {
+  protocol: number;
+  /** The Mac's name, this package's version, and the version of the `stim` it runs. */
+  server: {
+    name: string;
+    version: string;
+    stim: string;
+  };
+  capabilities: Capability[];
+  /** The paired device this connection authenticated as, as `stim-server devices` lists it. */
+  device: {
+    id: string;
+    name: string;
+  };
+  /** Present only when the hello spent a pairing token. The server keeps only its hash. */
+  deviceToken?: string;
+}
+interface SubscribeResult {
+  subscription: string;
+}
+interface UnsubscribeParams {
+  subscription: string;
+}
+declare const LOG_SOURCES: readonly ["metro", "client", "device", "build"];
+type LogSource = (typeof LOG_SOURCES)[number];
+declare const LOG_LEVELS: readonly ["debug", "info", "warn", "error", "fatal"];
+type LogLevel = (typeof LOG_LEVELS)[number];
+declare const MAX_LOG_TAIL = 5e3;
+/**
+ * The Stim Desktop log viewer's filters, passed to `stim logs`. `workspace` is an environment `path` from a
+ * status payload. Without `sources`, `errors` keeps the CLI's default error scope. `tail` defaults to
+ * {@link MAX_LOG_TAIL}, which is also its maximum.
+ */
+interface LogFilter {
+  workspace: string;
+  sources?: LogSource[];
+  level?: LogLevel;
+  slot?: string;
+  grep?: string;
+  errors?: boolean;
+  tail?: number;
+}
+/** One record as `stim logs --json` prints it. */
+type LogRecord = NdjsonRecord;
+interface LogsQueryResult {
+  records: LogRecord[];
+}
+/** Without `workspace`, stats and settings cover the machine only. */
+interface WorkspaceParams {
+  workspace?: string;
+}
+/** `stim stats --json`. */
+type StatsResult = Record<string, unknown>;
+/** `stim settings --json`; the CLI masks sensitive values. */
+type SettingsResult = Record<string, unknown>;
+type Platform = "ios" | "android";
+/**
+ * A device `stim status` lists as owned by `workspace`, in `slot` (`default` when absent). Frames come only
+ * from a booted simulator or a running emulator Stim created.
+ */
+interface FrameTarget {
+  workspace: string;
+  platform: Platform;
+  slot?: string;
+}
+interface Methods {
+  hello: {
+    params: HelloParams;
+    result: HelloResult;
+  };
+  "status.subscribe": {
+    params?: Record<string, never>;
+    result: SubscribeResult;
+  };
+  "logs.query": {
+    params: LogFilter;
+    result: LogsQueryResult;
+  };
+  "logs.subscribe": {
+    params: LogFilter;
+    result: SubscribeResult;
+  };
+  "stats.get": {
+    params?: WorkspaceParams;
+    result: StatsResult;
+  };
+  "settings.get": {
+    params?: WorkspaceParams;
+    result: SettingsResult;
+  };
+  "frames.subscribe": {
+    params: FrameTarget;
+    result: SubscribeResult;
+  };
+  unsubscribe: {
+    params: UnsubscribeParams;
+    result: Record<string, never>;
+  };
+}
+type ClientRequest = { [M in Method]: {
+  id: RequestId;
+  method: M;
+} & Pick<Methods[M], "params">; }[Method];
+interface ProtocolError {
+  code: ErrorCode;
+  message: string;
+}
+type ServerResponse = {
+  id: RequestId;
+  result: Methods[Method]["result"];
+} | {
+  id: RequestId | null;
+  error: ProtocolError;
+};
+/** A full status payload, as `stim status --watch --json` prints it. */
+interface StatusEvent {
+  event: "status";
+  subscription: string;
+  payload: StatusPayload;
+}
+/**
+ * Records for a `logs.subscribe` subscription: first the last `tail` matching records, then new ones as
+ * they arrive.
+ */
+interface LogsEvent {
+  event: "logs";
+  subscription: string;
+  records: LogRecord[];
+}
+/** A subscription ended because its source failed or the client fell behind; the client may resubscribe. */
+interface ErrorEvent {
+  event: "error";
+  subscription: string;
+  error: ProtocolError;
+}
+/** A screenshot of the device, sent when the screen changed, at most 5 times a second. */
+interface FrameEvent {
+  event: "frame";
+  subscription: string;
+  platform: Platform;
+  slot: string;
+  mime: "image/jpeg";
+  width: number;
+  height: number;
+  capturedAt: string;
+  /** Base64-encoded image bytes. */
+  data: string;
+}
+type ServerEvent = StatusEvent | LogsEvent | FrameEvent | ErrorEvent;
+type ServerMessage = ServerResponse | ServerEvent;
+type JsonSchema = Record<string, unknown>;
+/** The JSON Schema of every message on the wire, written to `dist/protocol.schema.json` at build time. */
+declare function protocolJsonSchema(): JsonSchema;
+//#endregion
+export { CAPABILITIES, Capability, ClientRequest, DeviceAuth, ERROR_CODES, ErrorCode, ErrorEvent, FrameEvent, FrameTarget, HelloParams, HelloResult, LOG_LEVELS, LOG_SOURCES, LogFilter, LogLevel, LogRecord, LogSource, LogsEvent, LogsQueryResult, MAX_LOG_TAIL, METHODS, Method, Methods, PROTOCOL_SCHEMA_FILE, PROTOCOL_VERSION, PairingAuth, Platform, ProtocolError, RequestId, ServerEvent, ServerMessage, ServerResponse, SettingsResult, StatsResult, StatusEvent, SubscribeResult, UnsubscribeParams, WorkspaceParams, protocolJsonSchema };

package/dist/protocol.mjs

@@ -0,0 +1,2 @@
+import { a as MAX_LOG_TAIL, c as PROTOCOL_VERSION, i as LOG_SOURCES, l as protocolJsonSchema, n as ERROR_CODES, o as METHODS, r as LOG_LEVELS, s as PROTOCOL_SCHEMA_FILE, t as CAPABILITIES } from "./protocol-dn2_TUeH.mjs";
+export { CAPABILITIES, ERROR_CODES, LOG_LEVELS, LOG_SOURCES, MAX_LOG_TAIL, METHODS, PROTOCOL_SCHEMA_FILE, PROTOCOL_VERSION, protocolJsonSchema };