pim-agent 0.0.1 → 0.9.0

package/packages/daemon/src/DaemonInstall.ts

@@ -0,0 +1,115 @@
+import { join } from "node:path";
+
+import { DaemonUnit, SupersededUnits } from "#core/shared/DaemonUnit";
+import { Supervisor, type Unit } from "#core/shared/Supervisor";
+import { DEFAULT_CLIENT_DIR } from "#server/StaticClient";
+import { WebOptions } from "#server/WebOptions";
+import { Surfaces, type SurfaceName } from "./Surfaces";
+
+type FrozenUnit = Unit & { readonly args: ReadonlyArray<string> };
+
+/** What this machine serves today: the unit being replaced, or the ones it supersedes. */
+export type Installed = {
+  readonly surfaces: ReadonlyArray<SurfaceName>;
+  readonly args: ReadonlyArray<string>;
+};
+
+const NOTHING: Installed = { surfaces: [], args: [] };
+
+/**
+ * A supervisor starts the daemon with no argv: every flag it needs must be
+ * frozen in here. What is installed already is the base the new argv overrides
+ * flag by flag, so installing one surface keeps the other one — and its
+ * settings. Naming `--surfaces` outright is how a daemon is shrunk again.
+ */
+function unit(
+  argv: ReadonlyArray<string>,
+  installed: Installed = NOTHING
+): FrozenUnit {
+  const surfaces = Surfaces.named(argv)
+    ? Surfaces.parse(argv)
+    : Surfaces.union(installed.surfaces, Surfaces.parse(argv));
+  const merged = [...installed.args, ...argv];
+  return {
+    ...DaemonUnit,
+    description: `${DaemonUnit.description} (${surfaces.join(", ")})`,
+    args: [
+      "--surfaces",
+      Surfaces.format(surfaces),
+      ...(surfaces.includes("web")
+        ? WebOptions.freeze(WebOptions.parse(merged))
+        : []),
+    ],
+  };
+}
+
+/**
+ * The merged unit's own argv, or — before the cutover — whatever the per-surface
+ * units were installed with, so a tailnet hostname frozen months ago survives.
+ */
+async function installed(): Promise<Installed> {
+  const current = await Supervisor.installedArgs(DaemonUnit);
+  if (current.length > 0) {
+    return { surfaces: Surfaces.parse(current), args: carriedOver(current) };
+  }
+  const superseded = (
+    await Promise.all(
+      SupersededUnits.map((unit) => Supervisor.installedArgs(unit))
+    )
+  ).filter((args) => args.length > 0);
+  return {
+    surfaces: Surfaces.union(...superseded.map(Surfaces.parse)),
+    args: superseded.flatMap(carriedOver),
+  };
+}
+
+// `--web-cwd` becomes `--cwd` on the way in, or it would outrank a new `--cwd`.
+function carriedOver(args: ReadonlyArray<string>): ReadonlyArray<string> {
+  return args.map((arg) => (arg === "--web-cwd" ? "--cwd" : arg));
+}
+
+async function install(argv: ReadonlyArray<string>): Promise<void> {
+  const descriptor = unit(argv, await installed());
+  const surfaces = Surfaces.parse(descriptor.args);
+  if (surfaces.includes("web")) {
+    await buildClient();
+  }
+  const kept = surfaces.filter((name) => !Surfaces.parse(argv).includes(name));
+  if (kept.length > 0) {
+    console.log(
+      `[install] keeping the ${kept.join(", ")} surface this machine already serves; pass --surfaces to change that`
+    );
+  }
+  console.log(
+    `[install] unit starts: pim --mode ${descriptor.mode} ${descriptor.args.join(" ")}`
+  );
+  await Supervisor.install(descriptor, { replaces: SupersededUnits });
+}
+
+async function uninstall(): Promise<void> {
+  await Supervisor.uninstall(DaemonUnit);
+  await Supervisor.supersede(SupersededUnits);
+}
+
+async function buildClient(): Promise<void> {
+  const at = await Supervisor.detectInstall();
+  // Probe `index.html`, not the directory: a half-emptied `dist/client` is still a broken bundle.
+  const bundled = await Bun.file(
+    join(DEFAULT_CLIENT_DIR, "index.html")
+  ).exists();
+  if (at.kind !== "dev" || bundled) {
+    return;
+  }
+  console.log("[install] building the web client");
+  const proc = Bun.spawn(["bun", "run", "web:build"], {
+    cwd: at.packageRoot,
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+  const code = await proc.exited;
+  if (code !== 0) {
+    throw new Error(`bun run web:build exited ${code}`);
+  }
+}
+
+export const DaemonInstall = { unit, installed, install, uninstall };

package/packages/daemon/src/Surfaces.ts

@@ -0,0 +1,66 @@
+import { Cli as Argv } from "#core/shared/Cli";
+
+export const SURFACE_NAMES = ["web", "telegram"] as const;
+
+export type SurfaceName = (typeof SURFACE_NAMES)[number];
+
+function isSurfaceName(value: string | undefined): value is SurfaceName {
+  return SURFACE_NAMES.includes(value as SurfaceName);
+}
+
+/**
+ * Which surfaces this process should bring up. `--mode web` and `--mode
+ * telegram` are the single-surface spellings of `--surfaces`, so a Telegram-only
+ * install needs no port and a web-only one needs no token.
+ */
+function parse(args: ReadonlyArray<string>): ReadonlyArray<SurfaceName> {
+  let requested: string | undefined;
+  let mode: string | undefined;
+  Argv.scan(args, (key, take) => {
+    switch (key) {
+      case "--surfaces":
+        requested = take() ?? requested;
+        break;
+      case "--mode":
+        mode = take() ?? mode;
+        break;
+      default:
+        break;
+    }
+  });
+  if (requested === undefined) {
+    return isSurfaceName(mode) ? [mode] : SURFACE_NAMES;
+  }
+  const names = requested
+    .split(",")
+    .map((name) => name.trim())
+    .filter((name) => name.length > 0);
+  const unknown = names.filter((name) => !isSurfaceName(name));
+  if (names.length === 0 || unknown.length > 0) {
+    throw new Error(
+      `--surfaces takes a comma-separated list of ${SURFACE_NAMES.join(", ")}, got "${requested}"`
+    );
+  }
+  return SURFACE_NAMES.filter((name) => names.includes(name));
+}
+
+function format(names: ReadonlyArray<SurfaceName>): string {
+  return names.join(",");
+}
+
+/** Whether the caller named the surfaces outright, rather than implying them by mode. */
+function named(args: ReadonlyArray<string>): boolean {
+  return args.some(
+    (arg) => arg === "--surfaces" || arg.startsWith("--surfaces=")
+  );
+}
+
+function union(
+  ...groups: ReadonlyArray<ReadonlyArray<SurfaceName>>
+): ReadonlyArray<SurfaceName> {
+  return SURFACE_NAMES.filter((name) =>
+    groups.some((group) => group.includes(name))
+  );
+}
+
+export const Surfaces = { parse, format, named, union };

package/packages/daemon/src/TelegramSurface.ts

@@ -0,0 +1,30 @@
+import type { AgentRuntime } from "#core/session/AgentRuntime";
+import { Bot } from "#telegram/Bot";
+import { Config } from "#telegram/Config";
+import type { Surface } from "./Daemon";
+
+function create(args: ReadonlyArray<string>, runtime: AgentRuntime): Surface {
+  return {
+    name: "telegram",
+    start: async () => {
+      const config = await Config.load(Config.parseArgs(args));
+      const bot = new Bot(config, runtime);
+      await bot.start();
+      return { stop: () => bot.stop() };
+    },
+  };
+}
+
+/** `--print-config`, which resolves the bot's config the way a run would and stops there. */
+async function printConfig(args: ReadonlyArray<string>): Promise<void> {
+  const config = await Config.load(Config.parseArgs(args));
+  console.log(
+    JSON.stringify(
+      { ...config, token: config.token ? "***" : undefined },
+      null,
+      2
+    )
+  );
+}
+
+export const TelegramSurface = { create, printConfig };

package/packages/daemon/src/WebSurface.ts

@@ -0,0 +1,57 @@
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+
+import { AttachmentStore } from "#core/attachments/AttachmentStore";
+import type { AgentRuntime } from "#core/session/AgentRuntime";
+import { SessionRegistry } from "#core/session/SessionRegistry";
+import { Tools } from "#core/shared/Tools";
+import { defaultAttachmentsRoot } from "#server/AttachmentEndpoint";
+import { SendFileTool } from "#server/SendFileTool";
+import { WebOptions } from "#server/WebOptions";
+import { WsGateway } from "#server/WsGateway";
+import type { Surface } from "./Daemon";
+
+function create(args: ReadonlyArray<string>, runtime: AgentRuntime): Surface {
+  return {
+    name: "web",
+    start: async () => {
+      const options = WebOptions.parse(args);
+      const attachmentsRoot = defaultAttachmentsRoot();
+      const store = new AttachmentStore(attachmentsRoot);
+      const registry = new SessionRegistry({
+        runtime,
+        defaults: { cwd: options.cwd },
+        customTools: ({ cwd, sessionId }) => [
+          Tools.wrap(
+            SendFileTool.build({ store, cwd, sessionId })
+          ) as ToolDefinition,
+        ],
+        systemInstruction: async () =>
+          "The user is interacting with you via a web browser.",
+      });
+      await registry.init();
+
+      const gateway = new WsGateway({
+        registry,
+        hostname: options.hostname,
+        port: WebOptions.port(options),
+        attachmentsRoot,
+        ...(options.clientDir === undefined
+          ? {}
+          : { clientDir: options.clientDir }),
+      });
+      gateway.start();
+      process.stderr.write(
+        `pim-server listening on ${gateway.url} (web UI: http://${options.hostname}:${gateway.port})\n`
+      );
+
+      return {
+        stop: async () => {
+          await gateway.stop();
+          await registry.disposeAll();
+        },
+      };
+    },
+  };
+}
+
+export const WebSurface = { create };

package/packages/daemon/src/index.ts

@@ -0,0 +1,37 @@
+import { AgentRuntime } from "#core/session/AgentRuntime";
+import { Daemon, type Surface } from "./Daemon";
+import { Surfaces } from "./Surfaces";
+import { TelegramSurface } from "./TelegramSurface";
+import { WebSurface } from "./WebSurface";
+
+/** Every surface in this process shares one pi installation, and so one `auth.json`. */
+export function build(args: ReadonlyArray<string>): ReadonlyArray<Surface> {
+  const runtime = new AgentRuntime();
+  return Surfaces.parse(args).map((name) =>
+    name === "web"
+      ? WebSurface.create(args, runtime)
+      : TelegramSurface.create(args, runtime)
+  );
+}
+
+export async function start(args: ReadonlyArray<string>): Promise<void> {
+  if (
+    Surfaces.parse(args).includes("telegram") &&
+    args.includes("--print-config")
+  ) {
+    await TelegramSurface.printConfig(args);
+    return;
+  }
+
+  const daemon = new Daemon(build(args));
+  const running = await daemon.start();
+  console.log(`[daemon] serving ${running.join(", ")}`);
+
+  await new Promise<void>((resolve) => {
+    for (const signal of ["SIGINT", "SIGTERM"] as const) {
+      process.once(signal, () => {
+        void daemon.stop().then(resolve);
+      });
+    }
+  });
+}

package/packages/protocol/src/Command.ts

@@ -0,0 +1,92 @@
+import type { ProtocolVersion } from "./Protocol";
+
+/** A file already uploaded via `POST /upload`, by the id that endpoint answered with; never a client-local path. */
+export type AttachmentRef = {
+  readonly id: string;
+};
+
+/** Client → server. Every command carries an `id` so its response correlates. */
+export type Command =
+  /** Opening frame of every connection; omit `sessionId` to start a new session in `cwd`. */
+  | {
+      readonly id: string;
+      readonly type: "attach";
+      readonly protocolVersion: ProtocolVersion;
+      readonly sessionId?: string;
+      readonly cwd?: string;
+      /** Copy model, thinking level and cwd from this session; ignored when `sessionId` is set or the session is not held open. */
+      readonly like?: string;
+      readonly fromSeq: number;
+    }
+  /** Sent into a running turn it steers that turn, landing before the next model call. */
+  | {
+      readonly id: string;
+      readonly type: "user_message";
+      readonly sessionId: string;
+      readonly text: string;
+      readonly attachments?: readonly AttachmentRef[];
+    }
+  | { readonly id: string; readonly type: "cancel"; readonly sessionId: string }
+  /** Take back the queued messages without stopping the turn; they come back on `restored`. */
+  | {
+      readonly id: string;
+      readonly type: "dequeue";
+      readonly sessionId: string;
+    }
+  | {
+      readonly id: string;
+      readonly type: "pick_files";
+      readonly sessionId: string;
+      readonly query: string;
+      readonly limit: number;
+    }
+  | {
+      readonly id: string;
+      readonly type: "pick_commands";
+      readonly sessionId: string;
+      readonly query: string;
+      readonly limit?: number;
+    }
+  | {
+      readonly id: string;
+      readonly type: "set_cwd" | "set_model" | "set_thinking";
+      readonly sessionId: string;
+      readonly value: string;
+    }
+  /** The session catalogue; answers before any `attach`. */
+  | {
+      readonly id: string;
+      readonly type: "list_sessions";
+      /** Restrict to one working directory; omit for every session on disk. */
+      readonly cwd?: string;
+      readonly limit?: number;
+    }
+  /** The models this server can switch to, plus the current model's thinking levels; answers without a session. */
+  | { readonly id: string; readonly type: "list_models" }
+  /** Subdirectories of `path` on the server's filesystem; errors rather than answering empty when it is not a readable directory. */
+  | { readonly id: string; readonly type: "list_dirs"; readonly path: string }
+  /** Read-only view of a subagent's transcript; `callId` is the parent's tool call and `sessionId` must be this connection's session. */
+  | {
+      readonly id: string;
+      readonly type: "watch_subagent";
+      readonly sessionId: string;
+      readonly callId: string;
+      readonly fromSeq: number;
+    }
+  /** Stop watching; succeeds whether or not this connection holds the watch. */
+  | {
+      readonly id: string;
+      readonly type: "unwatch_subagent";
+      readonly callId: string;
+    }
+  /** Update this install and restart it unconditionally; refused while any session is mid-turn unless `force`. */
+  | { readonly id: string; readonly type: "reload"; readonly force?: boolean };
+
+export type CommandType = Command["type"];
+
+/** A command before the transport stamps its correlation id. */
+export type CommandDraft = Command extends infer T
+  ? T extends Command
+    ? Omit<T, "id">
+    : never
+  : never;

package/packages/protocol/src/ImageRoute.ts

@@ -0,0 +1,23 @@
+const PREFIX = "/image/";
+
+/** Only the names a tool writes: a hex digest and one of the formats a provider takes. */
+const NAME = /^[0-9a-f]{64}\.(?:png|jpg|gif|webp)$/;
+
+/** Server-relative address of a picture a tool view names, the way an attachment's `url` is. */
+function url(sha256: string, extension: string): string {
+  return `${PREFIX}${sha256}.${extension}`;
+}
+
+/** Whether the gateway should route this path to its picture handler. */
+function owns(pathname: string): boolean {
+  return pathname.startsWith(PREFIX);
+}
+
+/** The `<sha256>.<ext>` a request addresses, or null when it is not a name we ever served. */
+function nameOf(pathname: string): string | null {
+  const name = pathname.slice(PREFIX.length);
+  return owns(pathname) && NAME.test(name) ? name : null;
+}
+
+/** `GET /image/<sha256>.<ext>`: the one spelling the server answers and the client asks for. */
+export const ImageRoute = { url, owns, nameOf };

package/packages/protocol/src/Protocol.ts

@@ -0,0 +1,6 @@
+export const PROTOCOL_VERSION = 1;
+
+export type ProtocolVersion = typeof PROTOCOL_VERSION;
+
+/** Close code for a client speaking a protocol version the server does not. */
+export const CLOSE_PROTOCOL_MISMATCH = 4001;

package/packages/protocol/src/ServerEvent.ts

@@ -0,0 +1,251 @@
+import type { DirectoryListing } from "#core/shared/Directories";
+import type { PickerItem } from "#core/picker/PickerItem";
+import type { LeaseFrontend } from "#core/session/SessionLease";
+import type { UpdateSkip } from "#core/shared/Updater";
+import type { NoticeSeverity, ToolView } from "#core/view/ViewBlock";
+import type { ProtocolVersion } from "./Protocol";
+
+export type SessionStatus = "idle" | "thinking" | "streaming" | "tool";
+
+export type TurnStats = {
+  readonly inputTokens: number;
+  readonly outputTokens: number;
+  readonly costUsd: number;
+  readonly durationMs: number;
+};
+
+export type ToolCallView = {
+  readonly callId: string;
+  readonly name: string;
+  readonly view: ToolView;
+};
+
+/** A file a user message carried; `url` is server-relative. */
+export type AttachmentView = {
+  /** What to call it on screen; never a path. */
+  readonly name: string;
+  readonly url: string;
+  readonly isImage: boolean;
+};
+
+/** Projected from pi's session JSONL; `seq` is the line ordinal, so one line must emit at most one durable event and a client resumes at `seq > n`. */
+export type DurableEvent =
+  | {
+      readonly seq: number;
+      readonly type: "message";
+      readonly messageId: string;
+      readonly role: "user" | "assistant";
+      readonly text: string;
+      /** When pi appended the entry, in epoch ms. */
+      readonly timestamp: number;
+      readonly thinking?: string;
+      /** Only ever set on a user message, which may carry nothing else. */
+      readonly attachments?: readonly AttachmentView[];
+      readonly toolCalls?: readonly ToolCallView[];
+      /** The model call failed, with what it said; only ever set on an assistant message. */
+      readonly error?: string;
+    }
+  | {
+      readonly seq: number;
+      readonly type: "tool_result";
+      readonly callId: string;
+      readonly name: string;
+      readonly view: ToolView;
+      readonly isError: boolean;
+    }
+  | {
+      readonly seq: number;
+      readonly type: "notice";
+      readonly severity: NoticeSeverity;
+      readonly text: string;
+    };
+
+/** Progress of the one `reload` this server can have in flight. */
+export type UpdateStateEvent =
+  | {
+      readonly type: "update_state";
+      readonly phase: "step";
+      readonly label: string;
+    }
+  | {
+      readonly type: "update_state";
+      readonly phase: "restarting";
+      readonly from: string;
+      readonly to: string;
+      readonly skipped: readonly UpdateSkip[];
+    }
+  /** New code is on disk but nothing will restart this process: no supervisor owns it. */
+  | {
+      readonly type: "update_state";
+      readonly phase: "stranded";
+      readonly from: string;
+      readonly to: string;
+      readonly skipped: readonly UpdateSkip[];
+    }
+  | {
+      readonly type: "update_state";
+      readonly phase: "failed";
+      readonly error: string;
+    };
+
+/** Unsequenced live state, never replayed by ordinal; live `tool_call`s reappear in a durable message's `toolCalls`, so dedupe on `callId`. */
+export type EphemeralEvent =
+  | {
+      readonly type: "attached";
+      readonly protocolVersion: ProtocolVersion;
+      readonly sessionId: string;
+      readonly cwd: string;
+      /** Highest durable `seq` at attach time; replay follows immediately. */
+      readonly head: number;
+      readonly pimVersion: string;
+      readonly piVersion: string;
+    }
+  /** Several events in one frame; apply them in order, each as if it had arrived alone. */
+  | { readonly type: "replay"; readonly events: readonly StreamEvent[] }
+  | {
+      readonly type: "message_start";
+      readonly role: "assistant";
+      readonly messageId: string;
+    }
+  /** Drop the live message with this id; the durable `message` superseding it was sent immediately before. */
+  | { readonly type: "message_retire"; readonly messageId: string }
+  | {
+      readonly type: "text_delta";
+      readonly messageId: string;
+      readonly delta: string;
+    }
+  | {
+      readonly type: "thinking_delta";
+      readonly messageId: string;
+      readonly delta: string;
+    }
+  | {
+      readonly type: "tool_call";
+      readonly callId: string;
+      readonly name: string;
+      readonly messageId: string;
+      readonly view: ToolView;
+    }
+  | {
+      readonly type: "tool_update";
+      readonly callId: string;
+      readonly view: ToolView;
+    }
+  /** Settled view until pi appends the `tool_result` for the same `callId`, which supersedes it. */
+  | {
+      readonly type: "tool_end";
+      readonly callId: string;
+      readonly view: ToolView;
+      readonly isError: boolean;
+    }
+  /** Every picker answer a client holds for this cwd is stale; drop the cache and re-query. */
+  | {
+      readonly type: "picker_invalidate";
+      readonly scope: "files" | "commands" | "all";
+      readonly cwd: string;
+    }
+  /** A child's events, applied against the child's transcript; sent only to the connection that asked, and never resumed. */
+  | {
+      readonly type: "subagent_events";
+      /** The parent tool call the watch was opened on. */
+      readonly callId: string;
+      readonly events: readonly StreamEvent[];
+    }
+  | { readonly type: "turn_end"; readonly stats: TurnStats }
+  /** Sent to every connection, not just those attached; only sessions this server holds open are reported. */
+  | {
+      readonly type: "session_activity";
+      readonly sessionId: string;
+      readonly status: SessionStatus;
+    }
+  /** Sent to every connection; the read cursor is one per session, not one per client. */
+  | { readonly type: "session_read"; readonly sessionId: string }
+  /** Sent to every connection: the sessions on disk changed, so any listing a client holds is stale. */
+  | { readonly type: "sessions_changed" }
+  /** Sent to every connection; the restart it ends in drops every socket. */
+  | UpdateStateEvent
+  | {
+      readonly type: "session_state";
+      readonly cwd: string;
+      readonly model: string;
+      /** Display name for `model`; absent until one resolves. */
+      readonly modelLabel?: string;
+      readonly thinking: string;
+      readonly cost: number;
+      readonly status: SessionStatus;
+      /** False while another process holds this session's turn lease. */
+      readonly writable: boolean;
+      /** Who holds it; absent when nothing does, or when their record is torn. */
+      readonly heldBy?: {
+        readonly frontend: LeaseFrontend;
+        readonly pid: number;
+      };
+      readonly tps?: number;
+      /** Elapsed run time of the turn in flight, by the server's clock; absent when idle. */
+      readonly turnElapsedMs?: number;
+      /** Context filled, 0–100. Absent until a turn has reported usage. */
+      readonly contextPercent?: number;
+      readonly contextWindow?: number;
+      /** The cwd's git branch, absent outside a repository. */
+      readonly branch?: string;
+      /** Paths git reports as changed; zero is a clean tree. */
+      readonly dirtyCount?: number;
+      readonly ahead?: number;
+      readonly behind?: number;
+    }
+  /** A frame the server could not attribute to any command. */
+  | { readonly type: "error"; readonly message: string };
+
+/** One row of the session catalogue. */
+export type SessionSummaryView = {
+  readonly sessionId: string;
+  readonly cwd: string;
+  readonly createdAt: number;
+  /** End of the last completed turn and the catalogue's sort key, never the file mtime; falls back to `createdAt`. */
+  readonly settledAt: number;
+  /** The session's first user message, trimmed; absent when it has none. */
+  readonly title?: string;
+  /** Has answered since anything last read it; absent means it has not. */
+  readonly unread?: boolean;
+  /** Absent when idle, and for a session this server does not hold open. */
+  readonly status?: SessionStatus;
+};
+
+/** One model the server can be switched to, for the composer's model menu. */
+export type ModelView = {
+  readonly id: string;
+  readonly label: string;
+  /** The provider half of `id`, so a client can tag a row without parsing it. */
+  readonly provider: string;
+};
+
+/** Answer to one `Command`, correlated by its `id`. Never sequenced. */
+export type ResponseEvent = {
+  readonly type: "response";
+  readonly id: string;
+  readonly success: boolean;
+  readonly error?: string;
+  /** Ranked rows, for the commands that answer with data (`pick_*`). */
+  readonly items?: readonly PickerItem[];
+  /** The catalogue, for `list_sessions`. */
+  readonly sessions?: readonly SessionSummaryView[];
+  /** The model catalogue, for `list_models`. */
+  readonly models?: readonly ModelView[];
+  /** What the *current* model supports, on the same answer. */
+  readonly thinkingLevels?: readonly string[];
+  /** One directory's subdirectories, for `list_dirs`. */
+  readonly directory?: DirectoryListing;
+  /** For `cancel` and `dequeue`: queued messages pi gave back, now owned by the client that asked. */
+  readonly restored?: readonly string[];
+};
+
+export type ServerEvent = DurableEvent | EphemeralEvent | ResponseEvent;
+
+/** Anything a session emits: everything on the wire but an answer to a command. */
+export type StreamEvent = DurableEvent | EphemeralEvent;
+
+export type ServerEventType = ServerEvent["type"];
+
+export function isDurableEvent(event: ServerEvent): event is DurableEvent {
+  return "seq" in event;
+}