speexor 0.1.1 → 0.2.1

package/dist/{chunk-B7WLHC4W.js → chunk-5OD5UWB5.js}

@@ -3,9 +3,37 @@ import { execSync, spawn } from 'child_process';
 import { randomUUID } from 'crypto';
 import { existsSync, mkdirSync, createWriteStream } from 'fs';
 import { join } from 'path';
+import { EventEmitter } from 'events';
 
-// src/plugins/agent/opencode.ts
-var debug = Debug("speexor:agent:opencode");
+// src/plugins/agent/retry.ts
+var debug = Debug("speexor:agent:retry");
+var DEFAULT_RETRY = {
+  maxRetries: 4,
+  baseDelayMs: 1e3,
+  maxDelayMs: 8e3
+};
+async function withRetry(fn, label, options = DEFAULT_RETRY) {
+  let lastError;
+  for (let attempt = 0; attempt <= options.maxRetries; attempt++) {
+    try {
+      const value = await fn();
+      if (attempt > 0) {
+        debug(`${label}: succeeded on attempt ${attempt + 1}/${options.maxRetries + 1}`);
+      }
+      return { ok: true, value };
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (attempt < options.maxRetries) {
+        const delay = Math.min(options.baseDelayMs * Math.pow(2, attempt), options.maxDelayMs);
+        debug(`${label}: attempt ${attempt + 1}/${options.maxRetries + 1} failed \u2014 retrying in ${delay}ms: ${lastError.message}`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+  debug(`${label}: all ${options.maxRetries + 1} attempts failed: ${lastError.message}`);
+  return { ok: false, error: lastError };
+}
+var debug2 = Debug("speexor:agent:opencode");
 var OpenCodeAgent = class {
   name = "opencode-agent";
   version = "0.1.0";
@@ -14,30 +42,36 @@ var OpenCodeAgent = class {
   context;
   async initialize(context) {
     this.context = context;
-    debug("OpenCode agent initialized");
+    debug2("OpenCode agent initialized");
   }
   async destroy() {
     this.sessions.clear();
-    debug("OpenCode agent destroyed");
+    debug2("OpenCode agent destroyed");
   }
   async spawn(task, runtime) {
-    const session = {
-      id: `oc-${task.id}-${Date.now()}`,
-      taskId: task.id,
-      provider: "opencode",
-      status: "running",
-      startedAt: /* @__PURE__ */ new Date(),
-      runtimeSessionId: runtime.id
-    };
-    this.sessions.set(session.id, { task, runtime });
-    await this.context.eventBus.emit("agent:spawned", { sessionId: session.id, task: task.id });
-    debug(`OpenCode agent spawned: ${session.id}`);
-    return session;
+    const result = await withRetry(async () => {
+      const session = {
+        id: `oc-${task.id}-${Date.now()}`,
+        taskId: task.id,
+        provider: "opencode",
+        status: "running",
+        startedAt: /* @__PURE__ */ new Date(),
+        runtimeSessionId: runtime.id
+      };
+      this.sessions.set(session.id, { task, runtime });
+      await this.context.eventBus.emit("agent:spawned", { sessionId: session.id, task: task.id });
+      return session;
+    }, "opencode:spawn");
+    if (!result.ok) {
+      throw result.error;
+    }
+    debug2(`OpenCode agent spawned: ${result.value.id}`);
+    return result.value;
   }
   async sendInput(sessionId, input) {
     const session = this.sessions.get(sessionId);
     if (!session) throw new Error(`Session ${sessionId} not found`);
-    debug(`Input sent to session ${sessionId}: ${input.substring(0, 100)}...`);
+    debug2(`Input sent to session ${sessionId}: ${input.substring(0, 100)}...`);
   }
   async getStatus(sessionId) {
     const session = this.sessions.get(sessionId);
@@ -46,10 +80,10 @@ var OpenCodeAgent = class {
   }
   async kill(sessionId) {
     this.sessions.delete(sessionId);
-    debug(`OpenCode agent killed: ${sessionId}`);
+    debug2(`OpenCode agent killed: ${sessionId}`);
   }
 };
-var debug2 = Debug("speexor:agent:claude-code");
+var debug3 = Debug("speexor:agent:claude-code");
 var ClaudeCodeAgent = class {
   name = "claude-code-agent";
   version = "0.1.0";
@@ -58,28 +92,35 @@ var ClaudeCodeAgent = class {
   context;
   async initialize(context) {
     this.context = context;
-    debug2("Claude Code agent initialized");
+    debug3("Claude Code agent initialized");
   }
   async destroy() {
     this.sessions.clear();
   }
   async spawn(task, runtime) {
-    const session = {
-      id: `cc-${task.id}-${Date.now()}`,
-      taskId: task.id,
-      provider: "claude-code",
-      status: "running",
-      startedAt: /* @__PURE__ */ new Date(),
-      runtimeSessionId: runtime.id
-    };
-    this.sessions.set(session.id, { task, runtime });
-    await this.context.eventBus.emit("agent:spawned", { sessionId: session.id, task: task.id });
-    debug2(`Claude Code agent spawned: ${session.id}`);
-    return session;
+    const result = await withRetry(async () => {
+      const session = {
+        id: `cc-${task.id}-${Date.now()}`,
+        taskId: task.id,
+        provider: "claude-code",
+        status: "running",
+        startedAt: /* @__PURE__ */ new Date(),
+        runtimeSessionId: runtime.id
+      };
+      this.sessions.set(session.id, { task, runtime });
+      await this.context.eventBus.emit("agent:spawned", { sessionId: session.id, task: task.id });
+      return session;
+    }, "claude-code:spawn");
+    if (!result.ok) {
+      throw result.error;
+    }
+    debug3(`Claude Code agent spawned: ${result.value.id}`);
+    return result.value;
   }
   async sendInput(sessionId, input) {
     const session = this.sessions.get(sessionId);
     if (!session) throw new Error(`Session ${sessionId} not found`);
+    debug3(`sendInput to ${sessionId}: ${input.slice(0, 100)}`);
   }
   async getStatus(sessionId) {
     return this.sessions.has(sessionId) ? "running" : "error";
@@ -88,34 +129,39 @@ var ClaudeCodeAgent = class {
     this.sessions.delete(sessionId);
   }
 };
-var debug3 = Debug("speexor:agent:aider");
+var debug4 = Debug("speexor:agent:aider");
 var AiderAgent = class {
   name = "aider-agent";
   version = "0.1.0";
   type = "agent";
   sessions = /* @__PURE__ */ new Map();
-  context;
-  async initialize(context) {
-    this.context = context;
-    debug3("Aider agent initialized");
+  async initialize(_context) {
+    debug4("Aider agent initialized");
   }
   async destroy() {
     this.sessions.clear();
   }
   async spawn(task, runtime) {
-    const session = {
-      id: `ai-${task.id}-${Date.now()}`,
-      taskId: task.id,
-      provider: "aider",
-      status: "running",
-      startedAt: /* @__PURE__ */ new Date(),
-      runtimeSessionId: runtime.id
-    };
-    this.sessions.set(session.id, { task, runtime });
-    debug3(`Aider agent spawned: ${session.id}`);
-    return session;
+    const result = await withRetry(async () => {
+      const session = {
+        id: `ai-${task.id}-${Date.now()}`,
+        taskId: task.id,
+        provider: "aider",
+        status: "running",
+        startedAt: /* @__PURE__ */ new Date(),
+        runtimeSessionId: runtime.id
+      };
+      this.sessions.set(session.id, { task, runtime });
+      return session;
+    }, "aider:spawn");
+    if (!result.ok) {
+      throw result.error;
+    }
+    debug4(`Aider agent spawned: ${result.value.id}`);
+    return result.value;
   }
   async sendInput(sessionId, input) {
+    debug4(`sendInput to ${sessionId}: ${input.slice(0, 50)}`);
   }
   async getStatus(sessionId) {
     return this.sessions.has(sessionId) ? "running" : "error";
@@ -124,34 +170,39 @@ var AiderAgent = class {
     this.sessions.delete(sessionId);
   }
 };
-var debug4 = Debug("speexor:agent:codex");
+var debug5 = Debug("speexor:agent:codex");
 var CodexAgent = class {
   name = "codex-agent";
   version = "0.1.0";
   type = "agent";
   sessions = /* @__PURE__ */ new Map();
-  context;
-  async initialize(context) {
-    this.context = context;
-    debug4("Codex agent initialized");
+  async initialize(_context) {
+    debug5("Codex agent initialized");
   }
   async destroy() {
     this.sessions.clear();
   }
   async spawn(task, runtime) {
-    const session = {
-      id: `cx-${task.id}-${Date.now()}`,
-      taskId: task.id,
-      provider: "codex",
-      status: "running",
-      startedAt: /* @__PURE__ */ new Date(),
-      runtimeSessionId: runtime.id
-    };
-    this.sessions.set(session.id, { task, runtime });
-    debug4(`Codex agent spawned: ${session.id}`);
-    return session;
+    const result = await withRetry(async () => {
+      const session = {
+        id: `cx-${task.id}-${Date.now()}`,
+        taskId: task.id,
+        provider: "codex",
+        status: "running",
+        startedAt: /* @__PURE__ */ new Date(),
+        runtimeSessionId: runtime.id
+      };
+      this.sessions.set(session.id, { task, runtime });
+      return session;
+    }, "codex:spawn");
+    if (!result.ok) {
+      throw result.error;
+    }
+    debug5(`Codex agent spawned: ${result.value.id}`);
+    return result.value;
   }
   async sendInput(sessionId, input) {
+    debug5(`sendInput to ${sessionId}: ${input.slice(0, 100)}`);
   }
   async getStatus(sessionId) {
     return this.sessions.has(sessionId) ? "running" : "error";
@@ -160,18 +211,16 @@ var CodexAgent = class {
     this.sessions.delete(sessionId);
   }
 };
-var debug5 = Debug("speexor:runtime:tmux");
+var debug6 = Debug("speexor:runtime:tmux");
 var TmuxRuntime = class {
   name = "tmux-runtime";
   version = "0.1.0";
   type = "runtime";
   sessions = /* @__PURE__ */ new Map();
-  context;
-  async initialize(context) {
-    this.context = context;
+  async initialize(_context) {
     try {
       execSync("tmux -V", { stdio: "ignore" });
-      debug5("tmux available");
+      debug6("tmux available");
     } catch {
       console.warn("tmux not found \u2014 will fall back to process runtime");
       throw new Error("tmux not available on this system");
@@ -197,19 +246,21 @@ var TmuxRuntime = class {
       worktreePath,
       createdAt: /* @__PURE__ */ new Date()
     };
-    this.sessions.set(id, session);
-    debug5(`tmux session created: ${id} at ${worktreePath}`);
+    const entry = { session, lastOutput: "", destroyed: false };
+    this.sessions.set(id, entry);
+    debug6(`tmux session created: ${id} at ${worktreePath}`);
     return session;
   }
   async destroySession(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (!session) return;
+    const entry = this.sessions.get(sessionId);
+    if (!entry) return;
+    entry.destroyed = true;
     try {
       execSync(`tmux kill-session -t speexor-${sessionId}`, { stdio: "ignore" });
     } catch {
     }
     this.sessions.delete(sessionId);
-    debug5(`tmux session destroyed: ${sessionId}`);
+    debug6(`tmux session destroyed: ${sessionId}`);
   }
   async sendInput(sessionId, input) {
     const escaped = input.replace(/'/g, "'\\''");
@@ -222,8 +273,35 @@ var TmuxRuntime = class {
       return "";
     }
   }
-  getLiveStream(sessionId) {
-    throw new Error("Live stream not implemented for tmux");
+  async *getLiveStream(sessionId) {
+    const entry = this.sessions.get(sessionId);
+    if (!entry || entry.destroyed) {
+      throw new Error(`Session ${sessionId} not found or destroyed`);
+    }
+    const POLL_INTERVAL_MS = 500;
+    let lastOutput = entry.lastOutput;
+    try {
+      while (!entry.destroyed) {
+        try {
+          const currentOutput = execSync(`tmux capture-pane -t speexor-${sessionId} -p -S -`, {
+            encoding: "utf-8",
+            stdio: "pipe"
+          });
+          if (currentOutput && currentOutput !== lastOutput) {
+            const newContent = lastOutput ? currentOutput.slice(lastOutput.length) : currentOutput;
+            lastOutput = currentOutput;
+            entry.lastOutput = currentOutput;
+            if (newContent) {
+              yield newContent;
+            }
+          }
+        } catch {
+          break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+      }
+    } finally {
+    }
   }
   async getStatus(sessionId) {
     try {
@@ -234,16 +312,14 @@ var TmuxRuntime = class {
     }
   }
 };
-var debug6 = Debug("speexor:runtime:process");
+var debug7 = Debug("speexor:runtime:process");
 var ProcessRuntime = class {
   name = "process-runtime";
   version = "0.1.0";
   type = "runtime";
   sessions = /* @__PURE__ */ new Map();
-  context;
-  async initialize(context) {
-    this.context = context;
-    debug6("Process runtime initialized");
+  async initialize(_context) {
+    debug7("Process runtime initialized");
   }
   async destroy() {
     for (const [id] of this.sessions) {
@@ -258,21 +334,28 @@ var ProcessRuntime = class {
       mkdirSync(logsDir, { recursive: true });
     }
     const logStream = createWriteStream(join(logsDir, `${id}.log`), { flags: "a" });
-    const child = spawn(process.env.SHELL || "bash", [], {
+    const emitter = new EventEmitter();
+    const child = spawn(process.env.SHELL || process.env.COMSPEC || "bash", [], {
       cwd: worktreePath,
       stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env, TERM: "xterm-256color" }
     });
     child.stdout?.on("data", (data) => {
-      logStream.write(`[stdout] ${data.toString()}`);
+      const text = data.toString();
+      logStream.write(`[stdout] ${text}`);
+      emitter.emit("data", text);
     });
     child.stderr?.on("data", (data) => {
-      logStream.write(`[stderr] ${data.toString()}`);
+      const text = data.toString();
+      logStream.write(`[stderr] ${text}`);
+      emitter.emit("data", text);
     });
     child.on("exit", (code) => {
       logStream.write(`[exit] Process exited with code ${code}
 `);
       logStream.end();
+      emitter.emit("exit", code);
+      emitter.removeAllListeners();
     });
     const session = {
       id,
@@ -281,13 +364,16 @@ var ProcessRuntime = class {
       pid: child.pid,
       createdAt: /* @__PURE__ */ new Date()
     };
-    this.sessions.set(id, { session, process: child });
-    debug6(`Process session created: ${id} (PID: ${child.pid})`);
+    const entry = { session, process: child, emitter, logStream, destroyed: false };
+    this.sessions.set(id, entry);
+    debug7(`Process session created: ${id} (PID: ${child.pid})`);
     return session;
   }
   async destroySession(sessionId) {
     const entry = this.sessions.get(sessionId);
     if (!entry) return;
+    entry.destroyed = true;
+    entry.emitter.removeAllListeners();
     entry.process.kill("SIGTERM");
     setTimeout(() => {
       try {
@@ -296,7 +382,7 @@ var ProcessRuntime = class {
       }
     }, 5e3);
     this.sessions.delete(sessionId);
-    debug6(`Process session destroyed: ${sessionId}`);
+    debug7(`Process session destroyed: ${sessionId}`);
   }
   async sendInput(sessionId, input) {
     const entry = this.sessions.get(sessionId);
@@ -309,8 +395,50 @@ var ProcessRuntime = class {
     if (!entry) return "";
     return `Session ${sessionId} (PID: ${entry.process.pid})`;
   }
-  getLiveStream(sessionId) {
-    throw new Error("Live stream not implemented for process runtime");
+  async *getLiveStream(sessionId) {
+    const entry = this.sessions.get(sessionId);
+    if (!entry || entry.destroyed) {
+      throw new Error(`Session ${sessionId} not found or destroyed`);
+    }
+    const { emitter } = entry;
+    let buffer = [];
+    let resolve = null;
+    let done = false;
+    const onData = (data) => {
+      if (resolve) {
+        const r = resolve;
+        resolve = null;
+        r({ value: data, done: false });
+      } else {
+        buffer.push(data);
+      }
+    };
+    const onExit = () => {
+      done = true;
+      if (resolve) {
+        const r = resolve;
+        resolve = null;
+        r({ value: "", done: true });
+      }
+    };
+    emitter.on("data", onData);
+    emitter.on("exit", onExit);
+    try {
+      while (!done) {
+        if (buffer.length > 0) {
+          yield buffer.shift();
+        } else {
+          const result = await new Promise((res) => {
+            resolve = res;
+          });
+          if (result.done) break;
+          yield result.value;
+        }
+      }
+    } finally {
+      emitter.off("data", onData);
+      emitter.off("exit", onExit);
+    }
   }
   async getStatus(sessionId) {
     const entry = this.sessions.get(sessionId);
@@ -319,16 +447,14 @@ var ProcessRuntime = class {
     return exited ? "stopped" : "running";
   }
 };
-var debug7 = Debug("speexor:workspace:git-worktree");
+var debug8 = Debug("speexor:workspace:git-worktree");
 var GitWorktreeWorkspace = class {
   name = "git-worktree-workspace";
   version = "0.1.0";
   type = "workspace";
   sessions = /* @__PURE__ */ new Map();
-  context;
   worktreesDir = ".speexor/worktrees";
-  async initialize(context) {
-    this.context = context;
+  async initialize(_context) {
     const dir = join(process.cwd(), this.worktreesDir);
     if (!existsSync(dir)) {
       mkdirSync(dir, { recursive: true });
@@ -338,12 +464,12 @@ var GitWorktreeWorkspace = class {
     } catch {
       throw new Error("Not a git repository. Run `speexor start <repo>` first.");
     }
-    debug7("Git worktree workspace initialized");
+    debug8("Git worktree workspace initialized");
   }
   async destroy() {
     const stale = await this.cleanupStale();
     if (stale.length > 0) {
-      debug7(`Cleaned up ${stale.length} stale worktree(s)`);
+      debug8(`Cleaned up ${stale.length} stale worktree(s)`);
     }
   }
   async createWorktree(task) {
@@ -368,7 +494,7 @@ var GitWorktreeWorkspace = class {
       createdAt: /* @__PURE__ */ new Date()
     };
     this.sessions.set(session.id, session);
-    debug7(`Worktree created: ${branch} at ${worktreePath}`);
+    debug8(`Worktree created: ${branch} at ${worktreePath}`);
     return session;
   }
   async removeWorktree(sessionId) {
@@ -383,7 +509,7 @@ var GitWorktreeWorkspace = class {
       }
     }
     this.sessions.delete(sessionId);
-    debug7(`Worktree removed: ${sessionId}`);
+    debug8(`Worktree removed: ${sessionId}`);
   }
   getWorktreePath(sessionId) {
     const session = this.sessions.get(sessionId);
@@ -418,18 +544,16 @@ var GitWorktreeWorkspace = class {
     return cleaned;
   }
 };
-var debug8 = Debug("speexor:tracker:github");
+var debug9 = Debug("speexor:tracker:github");
 var GitHubTracker = class {
   name = "github-tracker";
   version = "0.1.0";
   type = "tracker";
-  context;
   handlers = [];
-  async initialize(context) {
-    this.context = context;
+  async initialize(_context) {
     try {
       execSync("gh --version", { stdio: "ignore" });
-      debug8("GitHub CLI available");
+      debug9("GitHub CLI available");
     } catch {
       throw new Error("GitHub CLI (gh) not found. Install from https://cli.github.com/");
     }
@@ -458,7 +582,7 @@ var GitHubTracker = class {
       }));
       return issues;
     } catch (error) {
-      debug8("Failed to fetch issues:", error);
+      debug9("Failed to fetch issues:", error);
       return [];
     }
   }
@@ -483,24 +607,17 @@ var GitHubTracker = class {
   onEvent(handler) {
     this.handlers.push(handler);
   }
-  emit(event) {
-    for (const handler of this.handlers) {
-      handler(event);
-    }
-  }
 };
-var debug9 = Debug("speexor:scm:github");
+var debug10 = Debug("speexor:scm:github");
 var GitHubSCM = class {
   name = "github-scm";
   version = "0.1.0";
   type = "scm";
-  context;
   handlers = [];
-  async initialize(context) {
-    this.context = context;
+  async initialize(_context) {
     try {
       execSync("gh --version", { stdio: "ignore" });
-      debug9("GitHub CLI available");
+      debug10("GitHub CLI available");
     } catch {
       throw new Error("GitHub CLI (gh) not found");
     }
@@ -603,13 +720,13 @@ var GitHubSCM = class {
     return "none";
   }
 };
-var debug10 = Debug("speexor:notifier:desktop");
+var debug11 = Debug("speexor:notifier:desktop");
 var DesktopNotifier = class {
   name = "desktop-notifier";
   version = "0.1.0";
   type = "notifier";
   async initialize(_context) {
-    debug10("Desktop notifier initialized");
+    debug11("Desktop notifier initialized");
   }
   async destroy() {
   }
@@ -623,15 +740,97 @@ var DesktopNotifier = class {
           { stdio: "ignore" }
         );
       } else if (platform === "win32") {
-        const icon = level === "error" ? "Warning" : "Information";
         execSync(`powershell -c "New-BurntToastNotification -Text '${title}', '${message}'"`, { stdio: "ignore" });
       } else if (platform === "linux") {
         execSync(`notify-send "${title}" "${message}"`, { stdio: "ignore" });
       }
-      debug10(`Desktop notification: ${title} - ${message}`);
+      debug11(`Desktop notification: ${title} - ${message}`);
     } catch (error) {
-      debug10(`Failed to send notification: ${error}`);
+      debug11(`Failed to send notification: ${error}`);
+    }
+  }
+};
+var debug12 = Debug("speexor:terminal");
+var TerminalPluginImpl = class {
+  name = "terminal";
+  version = "0.1.0";
+  type = "terminal";
+  sessions = /* @__PURE__ */ new Map();
+  context;
+  async initialize(context) {
+    this.context = context;
+    debug12("Terminal plugin initialized");
+  }
+  async destroy() {
+    for (const [sessionId] of this.sessions) {
+      await this.detach(sessionId).catch(() => {
+      });
     }
+    this.sessions.clear();
+    debug12("Terminal plugin destroyed");
+  }
+  async attach(sessionId) {
+    if (this.sessions.has(sessionId)) return;
+    const child = spawn(process.env.SHELL || process.env.COMSPEC || "cmd.exe", [], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, TERM: "xterm-256color" }
+    });
+    const session = {
+      sessionId,
+      process: child,
+      handlers: /* @__PURE__ */ new Set(),
+      buffer: ""
+    };
+    child.stdout?.on("data", (data) => {
+      const text = data.toString();
+      session.buffer += text;
+      for (const handler of session.handlers) {
+        handler(text);
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      const text = data.toString();
+      session.buffer += text;
+      for (const handler of session.handlers) {
+        handler(text);
+      }
+    });
+    child.on("exit", (code) => {
+      debug12(`Terminal session ${sessionId} exited with code ${code}`);
+      this.sessions.delete(sessionId);
+      this.context.eventBus.emit("terminal:detached", {
+        sessionId,
+        exitCode: code
+      });
+    });
+    this.sessions.set(sessionId, session);
+    this.context.eventBus.emit("terminal:attached", { sessionId });
+    debug12(`Terminal session attached: ${sessionId}`);
+  }
+  async detach(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    session.process.kill("SIGTERM");
+    setTimeout(() => {
+      try {
+        session.process.kill("SIGKILL");
+      } catch {
+      }
+    }, 5e3);
+    session.handlers.clear();
+    this.sessions.delete(sessionId);
+    this.context.eventBus.emit("terminal:detached", { sessionId });
+    debug12(`Terminal session detached: ${sessionId}`);
+  }
+  async write(sessionId, data) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Terminal session ${sessionId} not found`);
+    session.process.stdin?.write(data);
+  }
+  onData(sessionId, handler) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Terminal session ${sessionId} not found`);
+    session.handlers.add(handler);
   }
 };
 
@@ -653,7 +852,9 @@ function loadAllPlugins() {
     // SCM
     new GitHubSCM(),
     // Notifier
-    new DesktopNotifier()
+    new DesktopNotifier(),
+    // Terminal
+    new TerminalPluginImpl()
   ];
   return plugins;
 }
@@ -662,5 +863,5 @@ function loadPluginByType(type) {
 }
 
 export { loadAllPlugins, loadPluginByType };
-//# sourceMappingURL=chunk-B7WLHC4W.js.map
-//# sourceMappingURL=chunk-B7WLHC4W.js.map
+//# sourceMappingURL=chunk-5OD5UWB5.js.map
+//# sourceMappingURL=chunk-5OD5UWB5.js.map