@supanadit/morse-web 0.9.5 → 0.11.0

package/dist/server.mjs

@@ -38,7 +38,11 @@ var CLIENT_MESSAGE_TYPES = [
   "model/set",
   "thinking/set",
   "interaction/respond",
-  "host/command"
+  "host/command",
+  "terminal/open",
+  "terminal/input",
+  "terminal/resize",
+  "terminal/close"
 ];
 function encodeWireMessage(message) {
   return JSON.stringify(message);
@@ -75,7 +79,7 @@ function hasKnownType(value, allowed) {
 }
 
 // ../protocol/dist/version.js
-var PROTOCOL_VERSION = 19;
+var PROTOCOL_VERSION = 20;
 var FRONTEND_MANIFEST_FILE = "webview.manifest.json";
 var DEFAULT_WS_PATH = "/ws";
 
@@ -1706,11 +1710,11 @@ function promptDescription(raw) {
     }
     body = raw.slice(frontmatter[0].length);
   }
-  const firstLine = body.split("\n").find((line) => line.trim().length > 0);
-  if (firstLine === void 0) {
+  const firstLine2 = body.split("\n").find((line) => line.trim().length > 0);
+  if (firstLine2 === void 0) {
     return void 0;
   }
-  const trimmed = firstLine.trim();
+  const trimmed = firstLine2.trim();
   return trimmed.length > 60 ? `${trimmed.slice(0, 60)}...` : trimmed;
 }
 function unquote(value) {
@@ -2667,6 +2671,14 @@ var HostSessionController = class {
   loadingOlderHistory = false;
   /** Discriminates history item ids across pages (see `historyItems`). */
   historyPageSeq = 0;
+  /** The shells this client has open, keyed by the terminal id it named. */
+  terminals = /* @__PURE__ */ new Map();
+  /**
+   * Bumped whenever a terminal id is opened or closed. A shell's late `exit`
+   * (a replaced one, a killed one) compares its generation and stays silent, so
+   * it cannot delete or report over the shell now holding the id.
+   */
+  terminalGenerations = /* @__PURE__ */ new Map();
   constructor(options) {
     this.options = options;
   }
@@ -2709,6 +2721,11 @@ var HostSessionController = class {
       return;
     }
     this.disposed = true;
+    for (const process2 of this.terminals.values()) {
+      process2.kill();
+    }
+    this.terminals.clear();
+    this.terminalGenerations.clear();
     this.detachRegistry?.();
     this.detachRegistry = void 0;
     this.detachTranscripts?.();
@@ -2796,10 +2813,83 @@ var HostSessionController = class {
       case "host/command":
         await this.runHostCommand(message.payload.command, message.payload.args, message.payload.requestId);
         return;
+      case "terminal/open":
+        await this.openTerminal(message.payload);
+        return;
+      case "terminal/input":
+        this.terminals.get(message.payload.terminalId)?.write(message.payload.data);
+        return;
+      case "terminal/resize":
+        this.terminals.get(message.payload.terminalId)?.resize(message.payload.cols, message.payload.rows);
+        return;
+      case "terminal/close":
+        this.closeTerminal(message.payload.terminalId);
+        return;
       default:
         return;
     }
   }
+  /**
+   * Starts a shell for the bottom panel. The directory is the viewing session's
+   * (or the draft's), never an arbitrary path the client names — the backend
+   * still re-checks it against the host policy before spawning.
+   */
+  async openTerminal(payload) {
+    if (this.options.terminal === void 0) {
+      this.emitTerminalExit(payload.terminalId, void 0, "This host has no terminal.");
+      return;
+    }
+    this.closeTerminal(payload.terminalId);
+    const generation = this.terminalGenerations.get(payload.terminalId) ?? 0;
+    const cwd = payload.cwd ?? this.currentState().workspace.cwd;
+    const cols = clampGeometry(payload.cols, 80);
+    const rows = clampGeometry(payload.rows, 24);
+    let process2;
+    try {
+      process2 = await this.options.terminal.open({ cwd, cols, rows }, {
+        output: (data) => {
+          if (this.terminalGenerations.get(payload.terminalId) === generation) {
+            this.emitTerminalOutput(payload.terminalId, data);
+          }
+        },
+        exit: (code, error) => {
+          if (this.terminalGenerations.get(payload.terminalId) !== generation) {
+            return;
+          }
+          this.terminals.delete(payload.terminalId);
+          this.emitTerminalExit(payload.terminalId, code, error);
+        }
+      });
+    } catch (error) {
+      this.options.logger.warn("Failed to open a terminal", error);
+      this.emitTerminalExit(payload.terminalId, void 0, describeTerminalError(error));
+      return;
+    }
+    if (!this.disposed && this.terminalGenerations.get(payload.terminalId) === generation) {
+      this.terminals.set(payload.terminalId, process2);
+    } else {
+      process2.kill();
+    }
+  }
+  closeTerminal(terminalId) {
+    this.terminalGenerations.set(terminalId, (this.terminalGenerations.get(terminalId) ?? 0) + 1);
+    const process2 = this.terminals.get(terminalId);
+    if (process2 === void 0) {
+      return;
+    }
+    this.terminals.delete(terminalId);
+    process2.kill();
+  }
+  emitTerminalOutput(terminalId, data) {
+    if (data.length > 0 && !this.disposed) {
+      this.options.emit({ type: "terminal/output", payload: { terminalId, data } });
+    }
+  }
+  emitTerminalExit(terminalId, code, error) {
+    if (!this.disposed) {
+      this.options.emit({ type: "terminal/exit", payload: { terminalId, code, error } });
+    }
+  }
   async openDefaultSession() {
     const existingKey = this.options.services.registry.activeKeyOf();
     if (existingKey) {
@@ -3227,15 +3317,15 @@ var HostSessionController = class {
       this.answerHostCommand(requestId, false, void 0, `This host does not support "${command}".`);
       return;
     }
-    const result = await this.guard(() => Promise.resolve(handler(command, args, { cwd: this.currentState().workspace.cwd })));
-    if (!requestId) {
-      return;
-    }
-    if (result.ok) {
-      this.answerHostCommand(requestId, true, result.value);
+    let value;
+    try {
+      value = await handler(command, args, { cwd: this.currentState().workspace.cwd });
+    } catch (error) {
+      this.options.logger.error(`Morse command failed: ${describeError(error)}`, error);
+      this.answerHostCommand(requestId, false, void 0, `"${command}" failed`);
       return;
     }
-    this.answerHostCommand(requestId, false, void 0, `"${command}" failed`);
+    this.answerHostCommand(requestId, true, value);
   }
   /** Replies to a host command the frontend asked a value for. */
   answerHostCommand(requestId, ok, data, error) {
@@ -3543,6 +3633,15 @@ function describeError(error) {
   }
   return typeof error === "string" ? error : JSON.stringify(error);
 }
+function clampGeometry(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.max(1, Math.min(1e3, Math.floor(value)));
+}
+function describeTerminalError(error) {
+  return error instanceof MorseError ? error.message : describeError(error);
+}
 function describeAgentFailure(error, hint) {
   const code = agentErrorCode(error);
   const install = error instanceof AgentUnavailableError ? error.remedy?.install : void 0;
@@ -3667,8 +3766,75 @@ var ServerProjectPolicy = class {
   }
 };
 
-// ../server/src/internal/registry.ts
+// ../server/src/internal/terminal/terminal.service.ts
+import { spawn as spawnPty } from "node-pty";
 import { Inject as Inject2, Injectable } from "@nestjs/common";
+var SIGKILL_AFTER_MS = 1500;
+function defaultShell() {
+  const configured = process.env.SHELL?.trim();
+  if (configured !== void 0 && configured.length > 0) {
+    return configured;
+  }
+  return process.platform === "win32" ? "powershell.exe" : "/bin/bash";
+}
+var ServerTerminalBackend = class {
+  constructor(policy, logger) {
+    this.policy = policy;
+    this.logger = logger;
+  }
+  open(options, sink) {
+    if (!this.policy.canOpen(options.cwd)) {
+      throw new UnsupportedByHostError(
+        `Morse is not allowed to run a terminal in ${options.cwd}.`
+      );
+    }
+    const shell = defaultShell();
+    const pty = spawnPty(shell, [], {
+      name: "xterm-256color",
+      cols: options.cols,
+      rows: options.rows,
+      cwd: options.cwd,
+      env: { ...process.env, TERM: "xterm-256color", MORSE_TERMINAL: "1" }
+    });
+    this.logger.info(`Terminal opened in ${options.cwd} (${shell}, pid ${pty.pid})`);
+    let exited = false;
+    const data = pty.onData((chunk) => sink.output(chunk));
+    pty.onExit(({ exitCode }) => {
+      exited = true;
+      data.dispose();
+      sink.exit(exitCode);
+    });
+    return {
+      write: (input) => {
+        if (!exited) {
+          pty.write(input);
+        }
+      },
+      resize: (cols, rows) => {
+        if (!exited) {
+          pty.resize(cols, rows);
+        }
+      },
+      kill: () => {
+        if (exited) {
+          return;
+        }
+        exited = true;
+        pty.kill();
+        const timer = setTimeout(() => pty.kill("SIGKILL"), SIGKILL_AFTER_MS);
+        timer.unref?.();
+      }
+    };
+  }
+};
+ServerTerminalBackend = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject2(MORSE_PROJECT_POLICY)),
+  __decorateParam(1, Inject2(MORSE_LOGGER))
+], ServerTerminalBackend);
+
+// ../server/src/internal/registry.ts
+import { Inject as Inject3, Injectable as Injectable2 } from "@nestjs/common";
 function createSessionRegistry(adapter, config, logger) {
   return new SessionRegistry({
     factory: adapter.factory,
@@ -3689,19 +3855,19 @@ var MorseRegistryLifecycle = class {
   }
 };
 MorseRegistryLifecycle = __decorateClass([
-  Injectable(),
-  __decorateParam(0, Inject2(MORSE_SESSION_REGISTRY)),
-  __decorateParam(1, Inject2(MORSE_TRANSCRIPT_STORE))
+  Injectable2(),
+  __decorateParam(0, Inject3(MORSE_SESSION_REGISTRY)),
+  __decorateParam(1, Inject3(MORSE_TRANSCRIPT_STORE))
 ], MorseRegistryLifecycle);
 
 // ../server/src/internal/ws/morse.gateway.ts
 import {
   WebSocketGateway
 } from "@nestjs/websockets";
-import { Inject as Inject4 } from "@nestjs/common";
+import { Inject as Inject5 } from "@nestjs/common";
 
 // ../server/src/internal/ws/session-factory.service.ts
-import { Inject as Inject3, Injectable as Injectable2 } from "@nestjs/common";
+import { Inject as Inject4, Injectable as Injectable3 } from "@nestjs/common";
 
 // ../server/src/internal/uploads/upload-store.ts
 import { existsSync } from "node:fs";
@@ -3959,6 +4125,169 @@ async function readGitDiff(cwd, requested) {
   );
   return { path: rel, diff: diff ?? "" };
 }
+async function readCommitFiles(cwd, requested) {
+  const hash = requested.trim();
+  if (!isCommitHash(hash)) {
+    return { isRepo: false, hash, files: [] };
+  }
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() !== "true") {
+    return { isRepo: false, hash, files: [] };
+  }
+  const raw = await gitText(
+    ["show", "--name-status", "--format=", "-z", "--find-renames", "--relative", hash],
+    cwd
+  );
+  return { isRepo: true, hash, files: parseNameStatus(raw ?? "") };
+}
+async function readCommitDiff(cwd, hash, requested) {
+  const rel = toPosix2(relative3(cwd, resolveWithin(cwd, requested)));
+  if (!isCommitHash(hash.trim())) {
+    return { path: rel, diff: "" };
+  }
+  const diff = await gitText(
+    ["show", "--format=", "--no-color", "--no-ext-diff", "-U3", "--relative", hash.trim(), "--", rel],
+    cwd
+  );
+  return { path: rel, diff: diff ?? "" };
+}
+function isCommitHash(hash) {
+  return /^[0-9a-fA-F]{4,40}$/.test(hash);
+}
+function parseNameStatus(raw) {
+  const tokens = raw.split("\0");
+  const files = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const status = tokens[index];
+    if (!status) {
+      continue;
+    }
+    const letter = status[0] ?? "";
+    const rename = letter === "R" || letter === "C";
+    const path = tokens[index + (rename ? 2 : 1)];
+    index += rename ? 2 : 1;
+    if (path) {
+      files.push({ path: toPosix2(path), status: `${letter} ` });
+    }
+  }
+  return files;
+}
+async function stageGitPaths(cwd, requested) {
+  const paths = resolvePaths(cwd, requested);
+  if (paths.length > 0) {
+    await gitRun(["add", "--", ...paths], cwd);
+  }
+  return readGitStatus(cwd);
+}
+async function unstageGitPaths(cwd, requested) {
+  const paths = resolvePaths(cwd, requested);
+  if (paths.length > 0) {
+    const reset = await gitRun(["reset", "--quiet", "HEAD", "--", ...paths], cwd);
+    if (!reset) {
+      await gitRun(["rm", "--cached", "--quiet", "--", ...paths], cwd);
+    }
+  }
+  return readGitStatus(cwd);
+}
+async function readGitSync(cwd) {
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() !== "true") {
+    return { isRepo: false, ahead: 0, behind: 0 };
+  }
+  const [branch, upstream] = await Promise.all([
+    gitText(["rev-parse", "--abbrev-ref", "HEAD"], cwd),
+    gitText(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"], cwd)
+  ]);
+  const name = branch?.trim() || void 0;
+  const tracked = upstream?.trim() || void 0;
+  if (tracked === void 0) {
+    return { isRepo: true, branch: name, ahead: 0, behind: 0 };
+  }
+  const counts = await gitText(
+    ["rev-list", "--left-right", "--count", `${tracked}...HEAD`],
+    cwd
+  );
+  const [behind, ahead] = parseCounts(counts ?? "");
+  return { isRepo: true, branch: name, upstream: tracked, ahead, behind };
+}
+async function pullGit(cwd) {
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() === "true") {
+    await gitRun(["pull", "--no-edit"], cwd, 18e4);
+  }
+  return readGitSync(cwd);
+}
+async function pushGit(cwd) {
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() === "true") {
+    await gitRun(["push", "--follow-tags"], cwd, 18e4);
+  }
+  return readGitSync(cwd);
+}
+async function readGitBranches(cwd) {
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() !== "true") {
+    return { isRepo: false, local: [], remote: [], tags: [] };
+  }
+  const [current, local, remote, tags] = await Promise.all([
+    gitText(["rev-parse", "--abbrev-ref", "HEAD"], cwd),
+    gitText(["for-each-ref", "--format=%(refname:short)", "refs/heads"], cwd),
+    gitText(["for-each-ref", "--format=%(refname:short)", "refs/remotes"], cwd),
+    gitText(["for-each-ref", "--format=%(refname:short)", "refs/tags"], cwd)
+  ]);
+  return {
+    isRepo: true,
+    current: current?.trim() || void 0,
+    local: nonEmptyLines(local),
+    remote: nonEmptyLines(remote).filter((name) => !name.endsWith("/HEAD")),
+    tags: nonEmptyLines(tags)
+  };
+}
+async function commitGit(cwd, message) {
+  const text = message.trim();
+  if (text.length === 0) {
+    return { ok: false, message: "A commit needs a message." };
+  }
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() !== "true") {
+    return { ok: false, message: "This project is not a git repository." };
+  }
+  const result = await gitExec(["commit", "-m", text], cwd, 6e4);
+  return { ok: result.ok, message: result.ok ? void 0 : firstLine(result.output) };
+}
+async function checkoutGit(cwd, branch, create) {
+  const name = branch.trim();
+  if (!isBranchName(name)) {
+    return { ok: false, message: "That is not a usable branch name." };
+  }
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() !== "true") {
+    return { ok: false, message: "This project is not a git repository." };
+  }
+  const result = await gitExec(
+    create ? ["checkout", "-b", name] : ["checkout", name],
+    cwd,
+    6e4
+  );
+  return { ok: result.ok, message: result.ok ? void 0 : firstLine(result.output) };
+}
+function isBranchName(name) {
+  return name.length > 0 && !name.startsWith("-") && !name.includes("..") && !name.includes("@{") && !name.endsWith("/") && !/\s/.test(name) && !/[~^:?*\[\\]/.test(name);
+}
+function firstLine(output) {
+  const line = output.split("\n").find((candidate) => candidate.trim().length > 0)?.trim();
+  if (line === void 0) {
+    return void 0;
+  }
+  return line.length > 200 ? `${line.slice(0, 197)}\u2026` : line;
+}
+function nonEmptyLines(output) {
+  return (output ?? "").split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function parseCounts(raw) {
+  const [behind, ahead] = raw.trim().split(/\s+/).map((value) => Number.parseInt(value, 10));
+  return [Number.isFinite(behind) ? behind : 0, Number.isFinite(ahead) ? ahead : 0];
+}
 function toPosix2(path) {
   return path.split("\\").join("/");
 }
@@ -4006,6 +4335,37 @@ function gitText(args, cwd) {
     );
   });
 }
+function resolvePaths(cwd, requested) {
+  return requested.filter((path) => typeof path === "string" && path.length > 0).map((path) => toPosix2(relative3(cwd, resolveWithin(cwd, path))));
+}
+async function gitRun(args, cwd, timeout = 5e3) {
+  return (await gitExec(args, cwd, timeout)).ok;
+}
+function gitExec(args, cwd, timeout = 5e3) {
+  return new Promise((resolve6) => {
+    execFile(
+      "git",
+      args,
+      {
+        cwd,
+        timeout,
+        maxBuffer: 8 * 1024 * 1024,
+        windowsHide: true,
+        env: {
+          ...process.env,
+          GIT_TERMINAL_PROMPT: "0",
+          GIT_EDITOR: "true",
+          GIT_MERGE_AUTOEDIT: "no"
+        }
+      },
+      (error, stdout, stderr) => {
+        resolve6(
+          error === null ? { ok: true, output: stdout.trim() } : { ok: false, output: (stderr || error.message || "").trim() }
+        );
+      }
+    );
+  });
+}
 
 // ../server/src/internal/workspace/workspace-index.ts
 import { execFile as execFile2 } from "node:child_process";
@@ -4140,12 +4500,13 @@ function toPosix3(path) {
 
 // ../server/src/internal/ws/session-factory.service.ts
 var MorseSessionFactory = class {
-  constructor(registry, transcripts, policy, logger, config) {
+  constructor(registry, transcripts, policy, logger, config, terminal) {
     this.registry = registry;
     this.transcripts = transcripts;
     this.policy = policy;
     this.logger = logger;
     this.config = config;
+    this.terminal = terminal;
   }
   capabilities() {
     return {
@@ -4167,6 +4528,10 @@ var MorseSessionFactory = class {
       // The same reasoning for history: VS Code has Source Control, so the
       // browser host is the one that answers `gitLog` for its own git panel.
       gitPanel: true,
+      // VS Code already has an integrated terminal; the browser host has none, so
+      // the bottom panel's terminal is this host's. It runs in the viewing
+      // session's directory and is gated by `ProjectPolicy`, like a session.
+      terminal: true,
       // A browser cannot hand a dragged file's path to pi, so the host takes the
       // bytes and writes them next to the session; the frontend then `@mentions`
       // the path it gets back.
@@ -4205,6 +4570,8 @@ var MorseSessionFactory = class {
       // A page load must not create a session; the first prompt opens one.
       autoOpen: false,
       onHostCommand: (command, args, context) => this.runHostCommand(command, args, context),
+      // The bottom panel's shell: this host can spawn one on its own machine.
+      terminal: this.terminal,
       agentHint: "Install the pi CLI and make sure it is on PATH, or start the server with MORSE_PI_PATH set."
     });
   }
@@ -4265,6 +4632,54 @@ var MorseSessionFactory = class {
         }
         return readGitDiff(cwd, path);
       }
+      case "gitStage": {
+        const cwd = this.requireWritableCwd(context);
+        return stageGitPaths(cwd, gitPaths(args));
+      }
+      case "gitUnstage": {
+        const cwd = this.requireWritableCwd(context);
+        return unstageGitPaths(cwd, gitPaths(args));
+      }
+      case "gitCommitFiles": {
+        const cwd = this.requireWritableCwd(context);
+        const hash = typeof args?.hash === "string" ? args.hash : "";
+        return readCommitFiles(cwd, hash);
+      }
+      case "gitCommitDiff": {
+        const cwd = this.requireWritableCwd(context);
+        const hash = typeof args?.hash === "string" ? args.hash : "";
+        const path = typeof args?.path === "string" ? args.path : "";
+        if (path.length === 0) {
+          throw new UnsupportedByHostError('gitCommitDiff needs a "path" argument.');
+        }
+        return readCommitDiff(cwd, hash, path);
+      }
+      case "gitSync": {
+        const cwd = this.requireWritableCwd(context);
+        return readGitSync(cwd);
+      }
+      case "gitPull": {
+        const cwd = this.requireWritableCwd(context);
+        return pullGit(cwd);
+      }
+      case "gitPush": {
+        const cwd = this.requireWritableCwd(context);
+        return pushGit(cwd);
+      }
+      case "gitCommit": {
+        const cwd = this.requireWritableCwd(context);
+        const message = typeof args?.message === "string" ? args.message : "";
+        return commitGit(cwd, message);
+      }
+      case "gitBranches": {
+        const cwd = this.requireWritableCwd(context);
+        return readGitBranches(cwd);
+      }
+      case "gitCheckout": {
+        const cwd = this.requireWritableCwd(context);
+        const branch = typeof args?.branch === "string" ? args.branch : "";
+        return checkoutGit(cwd, branch, args?.create === true);
+      }
       default:
         throw new UnsupportedByHostError(`This host does not support "${command}".`);
     }
@@ -4292,13 +4707,21 @@ var MorseSessionFactory = class {
   }
 };
 MorseSessionFactory = __decorateClass([
-  Injectable2(),
-  __decorateParam(0, Inject3(MORSE_SESSION_REGISTRY)),
-  __decorateParam(1, Inject3(MORSE_TRANSCRIPT_STORE)),
-  __decorateParam(2, Inject3(MORSE_PROJECT_POLICY)),
-  __decorateParam(3, Inject3(MORSE_LOGGER)),
-  __decorateParam(4, Inject3(MORSE_CONFIG))
+  Injectable3(),
+  __decorateParam(0, Inject4(MORSE_SESSION_REGISTRY)),
+  __decorateParam(1, Inject4(MORSE_TRANSCRIPT_STORE)),
+  __decorateParam(2, Inject4(MORSE_PROJECT_POLICY)),
+  __decorateParam(3, Inject4(MORSE_LOGGER)),
+  __decorateParam(4, Inject4(MORSE_CONFIG)),
+  __decorateParam(5, Inject4(ServerTerminalBackend))
 ], MorseSessionFactory);
+function gitPaths(args) {
+  const paths = args?.paths;
+  if (!Array.isArray(paths)) {
+    return [];
+  }
+  return paths.filter((path) => typeof path === "string" && path.length > 0);
+}
 
 // ../server/src/internal/ws/morse.gateway.ts
 var MorseGateway = class {
@@ -4343,8 +4766,8 @@ var MorseGateway = class {
 };
 MorseGateway = __decorateClass([
   WebSocketGateway({ path: DEFAULT_WS_PATH }),
-  __decorateParam(0, Inject4(MorseSessionFactory)),
-  __decorateParam(1, Inject4(MORSE_LOGGER))
+  __decorateParam(0, Inject5(MorseSessionFactory)),
+  __decorateParam(1, Inject5(MORSE_LOGGER))
 ], MorseGateway);
 
 // ../server/src/app/config.ts
@@ -4476,6 +4899,7 @@ AppModule = __decorateClass([
         inject: [MORSE_CONFIG]
       },
       MorseRegistryLifecycle,
+      ServerTerminalBackend,
       MorseSessionFactory,
       MorseGateway
     ]