@ccmsg/protocol 0.1.0

package/src/control/agents.ts

@@ -0,0 +1,64 @@
+import { type Static, Type } from "@sinclair/typebox";
+import { topicFrame } from "../envelope.ts";
+import { InstanceId, Sid, Timestamp } from "../identifiers.ts";
+import { upstream } from "../upstream.ts";
+
+/** One session as the harness itself reports it, noted with which config home
+ * it was found under.
+ *
+ * This is the harness's view rather than the instance's: it covers sessions
+ * that never connected here, and it carries what only the process knows — its
+ * pid, its terminal, the title the session gave itself. The instance renames
+ * the fields as it copies them in; the words inside them stay the harness's,
+ * which is why the status-like fields are open sets. */
+export const AgentInfo = Type.Object(
+  {
+    sid: Sid,
+    /** The instance that polled it, and whose host the pid belongs to. */
+    instance: InstanceId,
+    pid: Type.Integer({ minimum: 1 }),
+    cwd: Type.String(),
+    /** Whether the session is one a person is sitting at or one running on its
+     * own. An open set. */
+    kind: Type.String(),
+    started_at: Timestamp,
+    /** The session's own title, when it has set one. */
+    name: Type.Optional(Type.String()),
+    /** What the session is doing. An open set. */
+    status: Type.Optional(Type.String()),
+    /** What it is waiting on, in the harness's words. */
+    waiting_for: Type.Optional(Type.String()),
+    /** How a background session ended up. An open set; absent for a session a
+     * person is sitting at. */
+    state: Type.Optional(Type.String()),
+    /** The short handle a background session is addressed by. */
+    background_id: Type.Optional(Type.String()),
+    /** The config home this row was polled from. */
+    config_dir: Type.String(),
+    /** The terminal the session runs in, which is the handle a rename types
+     * into. Absent when the process does not name one or its environment could
+     * not be read. Read from the running process rather than remembered from
+     * when it started, since resuming a session gives it a new process. */
+    terminal_id: Type.Optional(Type.String()),
+    /** Which namespace that terminal lives in. Absent means the process set
+     * none, which the multiplexer treats as its default — not the instance's
+     * own namespace, which can differ. Typing into the wrong namespace reports a
+     * live session as gone. */
+    terminal_namespace: Type.Optional(Type.String()),
+  },
+  { $id: "AgentInfo", ...upstream("claude", "one row of the harness's session list") },
+);
+export type AgentInfo = Static<typeof AgentInfo>;
+
+/** The `agents` topic. Whole-value per instance, like `peers`.
+ *
+ * The instance polls the harness only while somebody is listening here, so the
+ * list is as fresh as the subscription is old. */
+export const AgentsFrame = topicFrame(
+  "agents",
+  Type.Object({
+    agents: Type.Array(AgentInfo),
+    /** When the poll behind this list ran. Absent before the first one. */
+    polled_at: Type.Optional(Timestamp),
+  }),
+);

package/src/control/files.ts

@@ -0,0 +1,323 @@
+import { type Static, Type } from "@sinclair/typebox";
+import { request, response } from "../envelope.ts";
+import { Sid, Timestamp } from "../identifiers.ts";
+
+/** Which authorization surface a path is reached through, and with it the
+ * shape the path takes.
+ *
+ * - `contained` — inside the session's own root. The path is relative to it.
+ * - `workspace` — inside one of the workspace folders the session's editor
+ *   configuration names. The path is absolute, and access is by directory
+ *   prefix.
+ * - `external` — one file outside both, named by the session's transcript. The
+ *   path is absolute and the grant is that exact file: there is no directory to
+ *   descend, which is why listing and searching offer no `external`.
+ *
+ * The kind is an argument rather than three ops because the reply is the same
+ * document in all three cases and only the check in front of it differs. */
+export const FileKind = Type.Union(
+  [Type.Literal("contained"), Type.Literal("workspace"), Type.Literal("external")],
+  { $id: "FileKind" },
+);
+export type FileKind = Static<typeof FileKind>;
+
+/** The kinds that name a directory to work within. */
+export const DirKind = Type.Union([Type.Literal("contained"), Type.Literal("workspace")], {
+  $id: "DirKind",
+});
+export type DirKind = Static<typeof DirKind>;
+
+/** Lists one directory.
+ *
+ * What a session may see differs from what a person may see — the role decides
+ * the visible range, not whether the call is allowed. */
+export const DirListArgs = Type.Object({
+  /** The session whose roots are browsed. */
+  sid: Sid,
+  kind: DirKind,
+  /** Relative to the session root for `contained`, where an empty string is the
+   * root itself; absolute for `workspace`. */
+  path: Type.Optional(Type.String()),
+});
+export type DirListArgs = Static<typeof DirListArgs>;
+
+/** One directory entry. Sockets, devices and the like collapse to `other`; a
+ * symlink is reported as itself, and one pointing out of the root is listed but
+ * refuses to resolve. */
+export const DirEntry = Type.Object(
+  {
+    name: Type.String(),
+    type: Type.Union([
+      Type.Literal("file"),
+      Type.Literal("dir"),
+      Type.Literal("symlink"),
+      Type.Literal("other"),
+    ]),
+    /** Bytes. Files only. */
+    size: Type.Optional(Type.Integer({ minimum: 0 })),
+    /** Absent when the host would not state one. */
+    mtime_at: Type.Optional(Timestamp),
+  },
+  { $id: "DirEntry" },
+);
+export type DirEntry = Static<typeof DirEntry>;
+
+export const DirListResult = Type.Object({
+  sid: Sid,
+  /** The path as the instance normalized it, in the shape the kind implies. */
+  path: Type.String(),
+  entries: Type.Array(DirEntry),
+});
+export type DirListResult = Static<typeof DirListResult>;
+
+export const DirListRequest = request("dir_list", DirListArgs);
+export const DirListResponse = response("dir_list", DirListResult);
+
+export const FileReadArgs = Type.Object({
+  sid: Sid,
+  kind: FileKind,
+  path: Type.String({ minLength: 1 }),
+});
+export type FileReadArgs = Static<typeof FileReadArgs>;
+
+export const FileReadResult = Type.Object({
+  sid: Sid,
+  path: Type.String(),
+  /** Size on disk, which may exceed what `content` carries. */
+  size: Type.Integer({ minimum: 0 }),
+  /** The content was cut at the instance's read limit. */
+  truncated: Type.Boolean(),
+  /** The head of the file sniffed as binary, so no text is sent. */
+  binary: Type.Boolean(),
+  /** Empty when `binary`. */
+  content: Type.String(),
+  /** Also the token an edit passes back: an edit whose file has moved on since
+   * this read is refused instead of overwriting the newer copy. */
+  mtime_at: Timestamp,
+});
+export type FileReadResult = Static<typeof FileReadResult>;
+
+export const FileReadRequest = request("file_read", FileReadArgs);
+export const FileReadResponse = response("file_read", FileReadResult);
+
+/** Writes a new file into the session's inbox directory.
+ *
+ * The one place a client may put a file without the user having opened it
+ * first, which is why it takes no `kind`: the destination is fixed and only the
+ * name within it is the caller's. `file_create` is the general form. */
+export const FileWriteArgs = Type.Object({
+  sid: Sid,
+  /** Relative to the session's working directory. */
+  path: Type.String({ minLength: 1 }),
+  content: Type.String(),
+});
+export type FileWriteArgs = Static<typeof FileWriteArgs>;
+
+export const FileWriteResult = Type.Object({
+  sid: Sid,
+  path: Type.String(),
+});
+export type FileWriteResult = Static<typeof FileWriteResult>;
+
+export const FileWriteRequest = request("file_write", FileWriteArgs);
+export const FileWriteResponse = response("file_write", FileWriteResult);
+
+/** Creates a file that does not exist yet.
+ *
+ * The symmetric partner of `file_edit`: create versus overwrite. It never
+ * replaces an existing path, and it does not make parent directories. There is
+ * no `external` kind — that allowlist names single files, so it holds no
+ * directory to create in. */
+export const FileCreateArgs = Type.Object({
+  sid: Sid,
+  kind: DirKind,
+  path: Type.String({ minLength: 1 }),
+  /** Usually empty: a client creates the file and lets the user fill it in. */
+  content: Type.String(),
+});
+export type FileCreateArgs = Static<typeof FileCreateArgs>;
+
+export const FileCreateResult = Type.Object({
+  sid: Sid,
+  path: Type.String(),
+});
+export type FileCreateResult = Static<typeof FileCreateResult>;
+
+export const FileCreateRequest = request("file_create", FileCreateArgs);
+export const FileCreateResponse = response("file_create", FileCreateResult);
+
+/** Overwrites an existing text file in place.
+ *
+ * It only ever overwrites — it does not create, delete or rename. The expected
+ * size and time come from the read the editor was populated from; a file that
+ * changed in between is refused rather than clobbered. A file whose current
+ * content sniffs as binary is refused too, so this can never turn a binary into
+ * text. */
+export const FileEditArgs = Type.Object({
+  sid: Sid,
+  kind: FileKind,
+  path: Type.String({ minLength: 1 }),
+  content: Type.String(),
+  /** The modification time the editor read. */
+  expected_mtime_at: Timestamp,
+  /** Guards a change that happened to leave the modification time alone, which
+   * a coarse filesystem clock makes possible. */
+  expected_size: Type.Integer({ minimum: 0 }),
+});
+export type FileEditArgs = Static<typeof FileEditArgs>;
+
+export const FileEditResult = Type.Object({
+  sid: Sid,
+  path: Type.String(),
+  size: Type.Integer({ minimum: 0 }),
+  /** The new lock token, so a second edit in the same sitting needs no re-read. */
+  mtime_at: Timestamp,
+});
+export type FileEditResult = Static<typeof FileEditResult>;
+
+export const FileEditRequest = request("file_edit", FileEditArgs);
+export const FileEditResponse = response("file_edit", FileEditResult);
+
+/** Deletes one regular file. Never a directory, never a symlink, never
+ * recursive: this only unlinks files a person could see as a leaf. `external`
+ * is not offered — that allowlist exists so a transcript's files can be read,
+ * and deleting one on the strength of having observed it is another matter. */
+export const FileDeleteArgs = Type.Object({
+  sid: Sid,
+  kind: DirKind,
+  path: Type.String({ minLength: 1 }),
+});
+export type FileDeleteArgs = Static<typeof FileDeleteArgs>;
+
+export const FileDeleteResult = Type.Object({
+  sid: Sid,
+  path: Type.String(),
+});
+export type FileDeleteResult = Static<typeof FileDeleteResult>;
+
+export const FileDeleteRequest = request("file_delete", FileDeleteArgs);
+export const FileDeleteResponse = response("file_delete", FileDeleteResult);
+
+/** Searches for files by name under one browsable root.
+ *
+ * Listing one directory at a time cannot answer "where is the file whose path
+ * contains this" without the asker having already opened every candidate
+ * directory, so the walk happens where the whole subtree is reachable at once. */
+export const FileFindArgs = Type.Object({
+  sid: Sid,
+  kind: DirKind,
+  /** Where to search. Relative to the session root for `contained`, absolute
+   * for `workspace`; absent means the root itself. */
+  root: Type.Optional(Type.String()),
+  /** Whitespace-separated words, all of which must appear in a candidate's
+   * path, with a leading `-` excluding one. Matching ignores case. A query with
+   * nothing to include matches nothing rather than returning the whole tree, so
+   * a cleared search box costs no walk. */
+  query: Type.String(),
+  /** Skip what the repository's ignore rules hide, and do not descend into
+   * ignored directories. Defaults to true, because the unfiltered result is
+   * dominated by vendored trees — with a capped reply those hits do not merely
+   * add noise, they push the real answer out of it. */
+  respect_gitignore: Type.Optional(Type.Boolean()),
+});
+export type FileFindArgs = Static<typeof FileFindArgs>;
+
+export const FileFindHit = Type.Object(
+  {
+    /** In the shape the kind implies, so it can be opened as it stands. */
+    path: Type.String(),
+    type: Type.Union([Type.Literal("file"), Type.Literal("dir"), Type.Literal("symlink")]),
+  },
+  { $id: "FileFindHit" },
+);
+export type FileFindHit = Static<typeof FileFindHit>;
+
+export const FileFindResult = Type.Object({
+  sid: Sid,
+  hits: Type.Array(FileFindHit),
+  /** The walk hit its result cap or its visit budget, so the hits are not the
+   * complete match set. Saying so is better than implying these are all. */
+  truncated: Type.Boolean(),
+});
+export type FileFindResult = Static<typeof FileFindResult>;
+
+export const FileFindRequest = request("file_find", FileFindArgs);
+export const FileFindResponse = response("file_find", FileFindResult);
+
+/** Asks which of a batch of paths the instance is willing to serve as files.
+ *
+ * A client that has found path-shaped text in a message uses this to decide
+ * which of them to turn into links. Each path is tried against the three
+ * surfaces in turn and the first that admits it and finds a regular file wins. */
+export const FileStatBatchArgs = Type.Object({
+  sid: Sid,
+  /** Absolute paths, resolved by the caller. */
+  paths: Type.Array(Type.String()),
+});
+export type FileStatBatchArgs = Static<typeof FileStatBatchArgs>;
+
+export const FileStatEntry = Type.Object(
+  {
+    kind: FileKind,
+    /** In the shape that kind implies, ready to be opened. */
+    path: Type.String(),
+  },
+  { $id: "FileStatEntry" },
+);
+export type FileStatEntry = Static<typeof FileStatEntry>;
+
+export const FileStatBatchResult = Type.Object({
+  /** One slot per requested path, in the same order.
+   *
+   * Design rationale: an unresolved path is `null` rather than being left out,
+   * which is the one place this contract states an absence instead of omitting
+   * it. The slots are the caller's own list read back, and dropping the misses
+   * would break the correspondence that makes the reply usable at all. A miss
+   * is deliberately one value for every reason — outside the allowlist, not a
+   * regular file, or simply not there — so this cannot be used to ask whether a
+   * path the caller may not read exists. */
+  results: Type.Array(Type.Union([FileStatEntry, Type.Null()])),
+});
+export type FileStatBatchResult = Static<typeof FileStatBatchResult>;
+
+export const FileStatBatchRequest = request("file_stat_batch", FileStatBatchArgs);
+export const FileStatBatchResponse = response("file_stat_batch", FileStatBatchResult);
+
+/** Reads the directory tree the launcher may start a session in.
+ *
+ * Directories only: this answers "where could a new session run", which is a
+ * different question from browsing a session's files, and it is bounded by the
+ * roots the launcher is configured with rather than by any session. */
+export const DirTreeArgs = Type.Object({
+  /** Configured roots, or any directory below one — a client expands the tree
+   * lazily by asking for a descendant. */
+  roots: Type.Array(Type.String()),
+  /** How deep to walk. Absent uses the configured depth; a lazy expansion asks
+   * for one level. */
+  depth: Type.Optional(Type.Integer({ minimum: 1 })),
+  /** Substring of the root-relative path. Matching nodes and their ancestors
+   * survive the filter. */
+  filter: Type.Optional(Type.String()),
+});
+export type DirTreeArgs = Static<typeof DirTreeArgs>;
+
+/** One node of the tree. No `children` means the walk stopped at its depth
+ * here, and a client may ask for this path to go further; an empty array means
+ * the directory holds no subdirectories. */
+export const DirTreeEntry = Type.Recursive(
+  (self) =>
+    Type.Object({
+      path: Type.String(),
+      children: Type.Optional(Type.Array(self)),
+    }),
+  { $id: "DirTreeEntry" },
+);
+export type DirTreeEntry = Static<typeof DirTreeEntry>;
+
+export const DirTreeResult = Type.Object({
+  entries: Type.Array(DirTreeEntry),
+});
+export type DirTreeResult = Static<typeof DirTreeResult>;
+
+export const DirTreeRequest = request("dir_tree", DirTreeArgs);
+export const DirTreeResponse = response("dir_tree", DirTreeResult);

package/src/control/kv.ts

@@ -0,0 +1,108 @@
+import { type Static, Type } from "@sinclair/typebox";
+import { NAMESPACE_PATTERN } from "../common/topics.ts";
+import { request, response, topicFrame } from "../envelope.ts";
+import { Timestamp } from "../identifiers.ts";
+
+/** Which namespace a key lives in. Namespaces do not nest and carry no meaning
+ * here: they keep one user of this store from colliding with another. */
+export const Namespace = Type.String({ $id: "Namespace", pattern: `^${NAMESPACE_PATTERN}$` });
+export type Namespace = Static<typeof Namespace>;
+
+/** What names a value within its namespace.
+ *
+ * Unlike a namespace, a key may hold text a person typed, so it is bounded and
+ * kept free of control characters rather than shaped into an identifier. Any
+ * structure within a key — a prefix naming which machine a value belongs to,
+ * say — is its user's convention, and this contract reads none of it. */
+export const KvKey = Type.String({
+  $id: "KvKey",
+  minLength: 1,
+  maxLength: 256,
+  pattern: "^[^\\u0000-\\u001f]+$",
+});
+export type KvKey = Static<typeof KvKey>;
+
+/** A stored value. Any JSON: what a value means belongs to whoever writes and
+ * reads it, and a store that understood its contents would have to be changed
+ * every time one of them did. */
+export const KvValue = Type.Unknown({ $id: "KvValue" });
+
+/** Reads one value.
+ *
+ * The whole of what this store promises is that a key is unique within its
+ * namespace. Instances mirror it between themselves, and when two of them hold
+ * different values for one key the later `updated_at` is the one that stands —
+ * so the value read here is the newest the answering instance knows of, not
+ * necessarily the newest anywhere. */
+export const KvReadArgs = Type.Object({ ns: Namespace, key: KvKey });
+export type KvReadArgs = Static<typeof KvReadArgs>;
+
+export const KvReadResult = Type.Object({
+  value: KvValue,
+  /** When the value was written, which is also what settles a disagreement
+   * between two instances. */
+  updated_at: Timestamp,
+});
+export type KvReadResult = Static<typeof KvReadResult>;
+
+export const KvReadRequest = request("kv_read", KvReadArgs);
+export const KvReadResponse = response("kv_read", KvReadResult);
+
+/** Writes one value, replacing whatever the key held. */
+export const KvWriteArgs = Type.Object({
+  ns: Namespace,
+  key: KvKey,
+  value: KvValue,
+  /** When the value was written. A caller states it when the write it is
+   * reporting happened at some other time than this call — which is what lets a
+   * value written while an instance was unreachable arrive later without
+   * pretending to be newer than it is. Absent, the answering instance stamps it
+   * with the present. */
+  updated_at: Type.Optional(Timestamp),
+});
+export type KvWriteArgs = Static<typeof KvWriteArgs>;
+
+export const KvWriteResult = Type.Object({
+  /** What the entry now carries, whether it was given or stamped. */
+  updated_at: Timestamp,
+});
+export type KvWriteResult = Static<typeof KvWriteResult>;
+
+export const KvWriteRequest = request("kv_write", KvWriteArgs);
+export const KvWriteResponse = response("kv_write", KvWriteResult);
+
+/** Removes one key. A key that was not there is no error: the caller wanted the
+ * namespace to be without it, and it is. */
+export const KvDeleteArgs = Type.Object({ ns: Namespace, key: KvKey });
+export type KvDeleteArgs = Static<typeof KvDeleteArgs>;
+
+export const KvDeleteResult = Type.Object({});
+export type KvDeleteResult = Static<typeof KvDeleteResult>;
+
+export const KvDeleteRequest = request("kv_delete", KvDeleteArgs);
+export const KvDeleteResponse = response("kv_delete", KvDeleteResult);
+
+/** One entry, in a snapshot or in the change that produced it. */
+export const KvEntry = Type.Object(
+  {
+    key: KvKey,
+    /** Absent exactly when the entry is a removal, which is the only case with
+     * no value to state. */
+    value: Type.Optional(KvValue),
+    updated_at: Timestamp,
+    /** Marks a removal. Absent means the entry is there to be read, so a
+     * snapshot never carries it. */
+    deleted: Type.Optional(Type.Literal(true)),
+  },
+  { $id: "KvEntry" },
+);
+export type KvEntry = Static<typeof KvEntry>;
+
+/** The `kv:<ns>` topic, which is how a change one client makes reaches the
+ * others while they are looking at it.
+ *
+ * Snapshot and change are the same shape: the snapshot is every entry the
+ * namespace holds, and a later frame is the entries that changed. A removal
+ * travels as an entry marked deleted rather than as an absence, since an
+ * absence in a list of changes would say nothing. */
+export const KvFrame = topicFrame("kv", Type.Object({ entries: Type.Array(KvEntry) }));

package/src/control/launcher.ts

@@ -0,0 +1,100 @@
+import { type Static, Type } from "@sinclair/typebox";
+import { request, response } from "../envelope.ts";
+
+/** Reads the launcher's configuration, as much of it as a form needs.
+ *
+ * Neither the directory tree nor the launch itself lets a client learn the
+ * roots it may pick from, or the recipes and their parameters — which are the
+ * form. This fills that gap, and its capability answer is also how a client
+ * decides whether to offer a launcher at all. */
+export const LauncherConfigReadArgs = Type.Object({});
+export type LauncherConfigReadArgs = Static<typeof LauncherConfigReadArgs>;
+
+/** One value the recipe's command reads.
+ *
+ * The declaration is the only statement of which variables exist: the launcher
+ * defines exactly these and nothing else. A client renders one input per
+ * declaration, in order. */
+export const LauncherParam = Type.Object(
+  {
+    /** A shell identifier, unique within a recipe. Some names are conventional
+     * enough to deserve a dedicated widget — a directory picker, a model
+     * chooser — and anything else is a plain text field. */
+    name: Type.String({ minLength: 1 }),
+    /** The form's initial value, and what resetting it restores. Empty is the
+     * ordinary "the user fills this in" case. */
+    default: Type.String(),
+  },
+  { $id: "LauncherParam" },
+);
+export type LauncherParam = Static<typeof LauncherParam>;
+
+/** One launch recipe as a client sees it: how the shell runs it is the
+ * instance's business and is not reported. */
+export const LauncherTemplate = Type.Object(
+  {
+    name: Type.String({ minLength: 1 }),
+    /** A shell program whose vocabulary is the declared parameters. Nothing is
+     * substituted into it — the parameters reach it as shell variables — so it
+     * is shown verbatim, and a client may offer it for editing. */
+    command: Type.String(),
+    params: Type.Array(LauncherParam),
+  },
+  { $id: "LauncherTemplate" },
+);
+export type LauncherTemplate = Static<typeof LauncherTemplate>;
+
+export const LauncherConfigReadResult = Type.Object({
+  /** Directories a session may be started in, on the instance's host. A launch
+   * elsewhere is refused. */
+  root_dirs: Type.Array(Type.String()),
+  /** In configured order; the first is the default recipe. */
+  templates: Type.Array(LauncherTemplate),
+});
+export type LauncherConfigReadResult = Static<typeof LauncherConfigReadResult>;
+
+export const LauncherConfigReadRequest = request("launcher_config_read", LauncherConfigReadArgs);
+export const LauncherConfigReadResponse = response(
+  "launcher_config_read",
+  LauncherConfigReadResult,
+);
+
+/** Starts a session.
+ *
+ * The reply comes back when the launched command has finished or been given up
+ * on, which can be seconds. That waits for nothing else: requests on one
+ * connection are answered as they complete, not in order. */
+export const LauncherRunArgs = Type.Object({
+  /** Where to run, and what the command sees as its working directory. It is a
+   * field of its own rather than one of `params` because it is the one value
+   * the instance acts on itself: it is checked against the configured roots
+   * before anything is spawned. */
+  cwd: Type.String({ minLength: 1 }),
+  /** Values for the recipe's declared parameters, by name. An omitted one falls
+   * back to its default; a name the recipe does not declare is refused rather
+   * than dropped, because a client sending a value nothing will read has a bug
+   * worth surfacing. The values are opaque and are never spliced into shell
+   * text, so none of them can inject syntax. */
+  params: Type.Record(Type.String(), Type.String()),
+  /** Which recipe to launch. Absent takes the default one; a name that is not
+   * configured is refused rather than quietly replaced with something else. */
+  template: Type.Optional(Type.String()),
+  /** Replaces the recipe's command for this launch. A person editing the
+   * command is doing what they could do by typing it in a terminal, so it is
+   * allowed for them and gated behind the same role as the launch itself. */
+  command: Type.Optional(Type.String({ minLength: 1 })),
+});
+export type LauncherRunArgs = Static<typeof LauncherRunArgs>;
+
+export const LauncherRunResult = Type.Object({
+  stdout: Type.String(),
+  stderr: Type.String(),
+  /** Absent when a signal ended the command, which leaves no code to state. */
+  exit_code: Type.Optional(Type.Integer()),
+  /** The command outlived its allowance and was stopped. */
+  timed_out: Type.Boolean(),
+});
+export type LauncherRunResult = Static<typeof LauncherRunResult>;
+
+export const LauncherRunRequest = request("launcher_run", LauncherRunArgs);
+export const LauncherRunResponse = response("launcher_run", LauncherRunResult);