@chatroomcp/chatroom 0.2.0 → 0.2.2

package/dist/plugins/git/git-service.js

@@ -0,0 +1,414 @@
+import { mkdtemp, open, rm, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { ChatRoomError } from "../../core/errors/chatroom-error.js";
+const MAX_PATHS = 512;
+export class GitService {
+    commands;
+    constructor(commands) {
+        this.commands = commands;
+    }
+    async status(cwd) {
+        const root = await this.repositoryRoot(cwd);
+        if (!root)
+            return null;
+        const [branch, head, porcelain] = await Promise.all([
+            this.branch(root),
+            this.head(root),
+            this.run(root, [
+                "status",
+                "--porcelain=v1",
+                "-z",
+                "--untracked-files=all",
+            ]),
+        ]);
+        const upstream = head ? await this.upstream(root) : null;
+        const { ahead, behind } = upstream
+            ? await this.aheadBehind(root)
+            : { ahead: 0, behind: 0 };
+        return {
+            branch,
+            head,
+            upstream,
+            ahead,
+            behind,
+            changes: parseStatus(porcelain.stdout),
+        };
+    }
+    async diff(cwd, filePath, maxPreviewBytes = 2 * 1024 * 1024) {
+        const root = await this.requireRepository(cwd);
+        await this.requireHead(root);
+        const paths = filePath ? await this.relatedPaths(root, [filePath]) : [];
+        return this.withSnapshotIndex(root, async ({ env, tempDir }) => {
+            const patchPath = path.join(tempDir, "changes.patch");
+            await this.run(root, [
+                "diff",
+                "--cached",
+                "--binary",
+                "--no-ext-diff",
+                "--no-renames",
+                `--output=${patchPath}`,
+                "HEAD",
+                ...(paths.length ? ["--", ...paths] : []),
+            ], env);
+            return readPatch(patchPath, maxPreviewBytes);
+        });
+    }
+    async stage(cwd, paths) {
+        const root = await this.requireRepository(cwd);
+        await this.run(root, [
+            "add",
+            "-A",
+            "--",
+            ...(await this.relatedPaths(root, paths)),
+        ]);
+        return this.requireStatus(root);
+    }
+    async unstage(cwd, paths) {
+        const root = await this.requireRepository(cwd);
+        const expanded = await this.relatedPaths(root, paths);
+        if (await this.head(root))
+            await this.run(root, ["restore", "--staged", "--", ...expanded]);
+        else
+            await this.run(root, ["rm", "--cached", "-r", "--", ...expanded]);
+        return this.requireStatus(root);
+    }
+    async restore(cwd, filePath) {
+        const root = await this.requireRepository(cwd);
+        const requested = normalizePath(filePath);
+        const status = await this.requireStatus(root);
+        const change = status.changes.find((item) => item.path === requested || item.originalPath === requested);
+        if (!change)
+            throw new ChatRoomError("NOT_FOUND", `No Git change found for path: ${requested}`);
+        if (change.kind === "untracked") {
+            await this.run(root, ["clean", "-f", "--", change.path]);
+            return this.requireStatus(root);
+        }
+        await this.requireHead(root);
+        const paths = [
+            change.path,
+            ...(change.originalPath ? [change.originalPath] : []),
+        ];
+        const tracked = [];
+        const untracked = [];
+        for (const file of [...new Set(paths)]) {
+            if (await this.pathExistsInHead(root, file))
+                tracked.push(file);
+            else
+                untracked.push(file);
+        }
+        if (tracked.length)
+            await this.run(root, [
+                "restore",
+                "--source=HEAD",
+                "--staged",
+                "-W",
+                "--",
+                ...tracked,
+            ]);
+        if (untracked.length) {
+            await this.run(root, ["restore", "--staged", "--", ...untracked]).catch(() => undefined);
+            await this.run(root, ["clean", "-f", "--", ...untracked]);
+        }
+        return this.requireStatus(root);
+    }
+    async commit(cwd, message) {
+        const root = await this.requireRepository(cwd);
+        const normalized = message.trim();
+        if (!normalized)
+            throw new ChatRoomError("INVALID_INPUT", "Commit message is required");
+        if (normalized.length > 10_000)
+            throw new ChatRoomError("INVALID_INPUT", "Commit message is too long");
+        await this.run(root, ["commit", "-m", normalized]);
+        return this.requireStatus(root);
+    }
+    async branches(cwd) {
+        const root = await this.requireRepository(cwd);
+        const result = await this.run(root, [
+            "for-each-ref",
+            "--format=%(HEAD)%00%(refname:short)%00%(upstream:short)",
+            "refs/heads",
+        ]);
+        return result.stdout
+            .split(/\r?\n/)
+            .filter(Boolean)
+            .map((line) => {
+            const [head = "", name = "", upstream = ""] = line.split("\0");
+            return {
+                name,
+                current: head.trim() === "*",
+                upstream: upstream || null,
+            };
+        })
+            .filter((branch) => Boolean(branch.name));
+    }
+    async createBranch(cwd, name) {
+        const root = await this.requireRepository(cwd);
+        const branch = await this.validateBranchName(root, name);
+        await this.run(root, ["switch", "-c", branch]);
+        return this.requireStatus(root);
+    }
+    async switchBranch(cwd, name) {
+        const root = await this.requireRepository(cwd);
+        const branch = await this.validateBranchName(root, name);
+        await this.run(root, ["switch", branch]);
+        return this.requireStatus(root);
+    }
+    async deleteBranch(cwd, name) {
+        const root = await this.requireRepository(cwd);
+        const branch = await this.validateBranchName(root, name);
+        await this.run(root, ["branch", "-d", branch]);
+        return this.requireStatus(root);
+    }
+    async log(cwd, limit = 30) {
+        const root = await this.requireRepository(cwd);
+        if (!(await this.head(root)))
+            return [];
+        const count = Math.min(Math.max(Math.trunc(limit), 1), 100);
+        const result = await this.run(root, [
+            "log",
+            `-n${count}`,
+            "--pretty=format:%H%x1f%h%x1f%an%x1f%aI%x1f%s%x1e",
+        ]);
+        return result.stdout
+            .split("\x1e")
+            .map((record) => record.trim())
+            .filter(Boolean)
+            .map((record) => {
+            const [hash = "", shortHash = "", author = "", date = "", subject = "",] = record.split("\x1f");
+            return { hash, shortHash, author, date, subject };
+        });
+    }
+    async fetch(cwd) {
+        const root = await this.requireRepository(cwd);
+        await this.run(root, ["fetch", "--all", "--prune"]);
+        return this.requireStatus(root);
+    }
+    async pull(cwd) {
+        const root = await this.requireRepository(cwd);
+        await this.run(root, ["pull", "--ff-only"]);
+        return this.requireStatus(root);
+    }
+    async push(cwd) {
+        const root = await this.requireRepository(cwd);
+        await this.run(root, ["push"]);
+        return this.requireStatus(root);
+    }
+    run(cwd, args, env) {
+        return this.commands.run({
+            cwd,
+            command: "git",
+            args,
+            timeoutMs: 120_000,
+            env: { LC_ALL: "C", LANG: "C", ...(env ?? {}) },
+        });
+    }
+    async repositoryRoot(cwd) {
+        try {
+            const root = path.resolve((await this.run(cwd, ["rev-parse", "--show-toplevel"])).stdout.trim());
+            return root === path.resolve(cwd) ? root : null;
+        }
+        catch (error) {
+            if (isNotRepositoryError(error))
+                return null;
+            throw error;
+        }
+    }
+    async requireRepository(cwd) {
+        const root = await this.repositoryRoot(cwd);
+        if (!root)
+            throw new ChatRoomError("INVALID_INPUT", "Workspace is not a Git repository");
+        return root;
+    }
+    async requireStatus(cwd) {
+        const status = await this.status(cwd);
+        if (!status)
+            throw new ChatRoomError("INVALID_INPUT", "Workspace is not a Git repository");
+        return status;
+    }
+    async head(cwd) {
+        try {
+            return ((await this.run(cwd, ["rev-parse", "--verify", "HEAD"])).stdout.trim() || null);
+        }
+        catch (error) {
+            if (isMissingHeadError(error))
+                return null;
+            throw error;
+        }
+    }
+    async requireHead(cwd) {
+        const head = await this.head(cwd);
+        if (!head)
+            throw new ChatRoomError("CONFLICT", "Git operation requires at least one commit");
+        return head;
+    }
+    async branch(cwd) {
+        return ((await this.run(cwd, ["branch", "--show-current"])).stdout.trim() || null);
+    }
+    async upstream(cwd) {
+        try {
+            return ((await this.run(cwd, [
+                "rev-parse",
+                "--abbrev-ref",
+                "--symbolic-full-name",
+                "@{upstream}",
+            ])).stdout.trim() || null);
+        }
+        catch {
+            return null;
+        }
+    }
+    async aheadBehind(cwd) {
+        try {
+            const [ahead = "0", behind = "0"] = (await this.run(cwd, [
+                "rev-list",
+                "--left-right",
+                "--count",
+                "HEAD...@{upstream}",
+            ])).stdout
+                .trim()
+                .split(/\s+/);
+            return { ahead: Number(ahead) || 0, behind: Number(behind) || 0 };
+        }
+        catch {
+            return { ahead: 0, behind: 0 };
+        }
+    }
+    async relatedPaths(cwd, paths) {
+        const normalized = normalizePaths(paths);
+        const status = await this.requireStatus(cwd);
+        const output = new Set(normalized);
+        for (const requested of normalized) {
+            const change = status.changes.find((item) => item.path === requested || item.originalPath === requested);
+            if (change?.path)
+                output.add(change.path);
+            if (change?.originalPath)
+                output.add(change.originalPath);
+        }
+        return [...output];
+    }
+    async pathExistsInHead(cwd, filePath) {
+        try {
+            await this.run(cwd, ["cat-file", "-e", `HEAD:${filePath}`]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async validateBranchName(cwd, name) {
+        const normalized = name.trim();
+        if (!normalized)
+            throw new ChatRoomError("INVALID_INPUT", "Branch name is required");
+        await this.run(cwd, ["check-ref-format", "--branch", normalized]);
+        return normalized;
+    }
+    async withSnapshotIndex(cwd, useIndex) {
+        const tempDir = await mkdtemp(path.join(os.tmpdir(), "chatroom-git-"));
+        const env = { GIT_INDEX_FILE: path.join(tempDir, "index") };
+        try {
+            await this.run(cwd, ["read-tree", "HEAD"], env);
+            await this.run(cwd, ["add", "-A", "--", "."], env);
+            return await useIndex({ env, tempDir });
+        }
+        finally {
+            await rm(tempDir, { recursive: true, force: true }).catch(() => undefined);
+        }
+    }
+}
+function parseStatus(output) {
+    const fields = output.split("\0");
+    const changes = [];
+    for (let index = 0; index < fields.length; index++) {
+        const record = fields[index];
+        if (!record || record.length < 3)
+            continue;
+        const indexStatus = record[0] ?? " ";
+        const workingTreeStatus = record[1] ?? " ";
+        const currentPath = record.slice(3);
+        let originalPath = null;
+        if (["R", "C"].includes(indexStatus) ||
+            ["R", "C"].includes(workingTreeStatus))
+            originalPath = fields[++index] || null;
+        changes.push({
+            path: currentPath,
+            originalPath,
+            indexStatus,
+            workingTreeStatus,
+            kind: changeKind(indexStatus, workingTreeStatus),
+        });
+    }
+    return changes.sort((a, b) => a.path.localeCompare(b.path));
+}
+function changeKind(indexStatus, workingTreeStatus) {
+    const pair = `${indexStatus}${workingTreeStatus}`;
+    if (pair === "??")
+        return "untracked";
+    if (["DD", "AU", "UD", "UA", "DU", "AA", "UU"].includes(pair) ||
+        indexStatus === "U" ||
+        workingTreeStatus === "U")
+        return "conflicted";
+    if (pair.includes("R"))
+        return "renamed";
+    if (pair.includes("C"))
+        return "copied";
+    if (pair.includes("A"))
+        return "added";
+    if (pair.includes("D"))
+        return "deleted";
+    return "modified";
+}
+function normalizePaths(paths) {
+    if (!Array.isArray(paths) || paths.length < 1)
+        throw new ChatRoomError("INVALID_INPUT", "At least one file path is required");
+    if (paths.length > MAX_PATHS)
+        throw new ChatRoomError("INVALID_INPUT", "Too many file paths");
+    return [...new Set(paths.map(normalizePath))];
+}
+function normalizePath(input) {
+    if (typeof input !== "string" || !input || input.includes("\0"))
+        throw new ChatRoomError("INVALID_INPUT", "File path is required");
+    if (path.isAbsolute(input) ||
+        path.win32.isAbsolute(input) ||
+        /^\\\\/.test(input))
+        throw new ChatRoomError("FORBIDDEN", "Absolute Git paths are not allowed");
+    const parts = input
+        .split(/[\\/]+/)
+        .filter((part) => part !== "" && part !== ".");
+    if (parts.length === 0 || parts.some((part) => part === ".."))
+        throw new ChatRoomError("FORBIDDEN", "Invalid Git path");
+    return parts.join("/");
+}
+async function readPatch(patchPath, maxBytes) {
+    const size = (await stat(patchPath)).size;
+    const previewBytes = Math.min(size, maxBytes);
+    const handle = await open(patchPath, "r");
+    try {
+        const buffer = Buffer.alloc(previewBytes);
+        const { bytesRead } = await handle.read(buffer, 0, previewBytes, 0);
+        return {
+            diff: buffer.subarray(0, bytesRead).toString("utf8"),
+            truncated: size > previewBytes,
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}
+function gitErrorText(error) {
+    if (!(error instanceof ChatRoomError))
+        return "";
+    const details = error.details;
+    return `${String(details?.stdout ?? "")}\n${String(details?.stderr ?? "")}`.toLowerCase();
+}
+function isNotRepositoryError(error) {
+    return gitErrorText(error).includes("not a git repository");
+}
+function isMissingHeadError(error) {
+    const text = gitErrorText(error);
+    return (text.includes("needed a single revision") ||
+        text.includes("unknown revision") ||
+        text.includes("bad revision") ||
+        text.includes("ambiguous argument 'head'") ||
+        text.includes("not a valid object name head"));
+}

package/dist/plugins/git/plugin.d.ts

@@ -0,0 +1,4 @@
+import type { InternalPlugin } from "../types.js";
+import { GitService } from "./git-service.js";
+export declare const GitServiceToken: import("../types.js").ServiceToken<GitService>;
+export declare function createGitPlugin(): InternalPlugin;

package/dist/plugins/git/plugin.js

@@ -0,0 +1,12 @@
+import { CommandRunner } from "../../core/runtime/command-runner.js";
+import { createServiceToken } from "../types.js";
+import { GitService } from "./git-service.js";
+export const GitServiceToken = createServiceToken("git");
+export function createGitPlugin() {
+    return {
+        id: "git",
+        activate(context) {
+            context.services.provide(GitServiceToken, new GitService(new CommandRunner()));
+        },
+    };
+}

package/dist/plugins/git/types.d.ts

@@ -0,0 +1,32 @@
+export type GitChangeKind = "modified" | "added" | "deleted" | "renamed" | "copied" | "untracked" | "conflicted";
+export interface GitChange {
+    path: string;
+    originalPath: string | null;
+    indexStatus: string;
+    workingTreeStatus: string;
+    kind: GitChangeKind;
+}
+export interface GitStatus {
+    branch: string | null;
+    head: string | null;
+    upstream: string | null;
+    ahead: number;
+    behind: number;
+    changes: GitChange[];
+}
+export interface GitDiff {
+    diff: string;
+    truncated: boolean;
+}
+export interface GitBranch {
+    name: string;
+    current: boolean;
+    upstream: string | null;
+}
+export interface GitCommit {
+    hash: string;
+    shortHash: string;
+    author: string;
+    date: string;
+    subject: string;
+}

package/dist/plugins/process/backend.d.ts

@@ -1,4 +1,3 @@
-/** OS/process-backend port consumed by ProcessSupervisor. */
 export interface BackendProcess {
     readonly pid: number | null;
     write(data: string): void;

package/dist/plugins/process/head-tail-buffer.d.ts

@@ -1,4 +1,3 @@
-/** Bounded process-output buffer that preserves useful context from both ends of a stream. */
 interface BufferSnapshot {
     text: string;
     bytesSeen: number;

package/dist/plugins/process/infrastructure/pipe-process-backend.js

@@ -1,4 +1,3 @@
-/** Pipe-based ProcessBackend implemented with Node child_process.spawn. */
 import { spawn } from "node:child_process";
 export class PipeProcessBackend {
     kind = "pipe";

package/dist/plugins/process/infrastructure/pty-process-backend.js

@@ -1,4 +1,3 @@
-/** Optional PTY ProcessBackend backed by node-pty when native PTY support is installed. */
 import { ChatRoomError } from "../../../core/errors/chatroom-error.js";
 export class PtyProcessBackend {
     kind = "pty";
@@ -38,9 +37,7 @@ class PtyBackendProcess {
     onStdout(listener) {
         this.processHandle.onData((data) => listener(Buffer.from(data)));
     }
-    onStderr(_listener) {
-        /* PTYs expose a merged stream. */
-    }
+    onStderr(_listener) { }
     onExit(listener) {
         this.processHandle.onExit((event) => listener({
             exitCode: event.exitCode,

package/dist/plugins/process/process-supervisor.js

@@ -1,7 +1,3 @@
-/**
- * Owns all ChatRoom-managed process lifecycle, timeout handling, output buffering, stdin, and process operation events.
- * Platform-specific creation details are delegated to pipe/PTY backends.
- */
 import { randomUUID } from "node:crypto";
 import { ChatRoomError } from "../../core/errors/chatroom-error.js";
 import { childEnvironment } from "../../core/runtime/child-environment.js";
@@ -48,7 +44,6 @@ export class ProcessSupervisor {
             this.operations.associate(operationId, { processId });
         let backend;
         try {
-            // Child environments inherit only the runtime allowlist, then apply explicit request overrides.
             backend = await (request.pty ? this.backends.pty : this.backends.pipe).start(request.command, args, {
                 cwd: request.cwd,
                 env: childEnvironment(request.env),
@@ -75,6 +70,7 @@ export class ProcessSupervisor {
             signal: null,
             timeout: null,
             forceTimeout: null,
+            outputEventTimer: null,
             timedOut: false,
             operationId,
             settled,
@@ -90,7 +86,6 @@ export class ProcessSupervisor {
                 if (managed.state !== "running")
                     return;
                 managed.timedOut = true;
-                // Timeouts first request graceful termination and escalate to SIGKILL only if the backend remains alive.
                 managed.backend.kill("SIGTERM");
                 managed.forceTimeout = setTimeout(() => {
                     if (managed.state === "running")
@@ -137,7 +132,6 @@ export class ProcessSupervisor {
                 Promise.allSettled(survivors.map(([, item]) => item.settled)),
                 new Promise((resolve) => setTimeout(resolve, 1500)),
             ]);
-            // A backend that does not report close after SIGKILL must still be settled before SQLite closes.
             for (const [processId, item] of survivors)
                 if (item.state === "running")
                     this.onExit(processId, null, "SIGKILL");
@@ -147,22 +141,14 @@ export class ProcessSupervisor {
         const item = this.processes.get(processId);
         if (!item || item.state !== "running")
             return;
-        // Store only bounded head/tail output while forwarding live chunks to SSE.
         (stream === "stdout" ? item.stdout : item.stderr).append(chunk);
-        const text = chunk.toString("utf8");
-        this.eventBus.emit({
-            type: "process-output",
-            processId,
-            stream,
-            chunk: text,
-        });
-        const snapshot = this.snapshotOf(processId, item);
-        this.operations.updateRunning(item.operationId, {
-            stdout: snapshot.stdout,
-            stderr: snapshot.stderr,
-            outputTruncated: snapshot.outputTruncated,
-            pid: snapshot.pid,
-        });
+        if (!item.outputEventTimer) {
+            item.outputEventTimer = setTimeout(() => {
+                item.outputEventTimer = null;
+                if (item.state === "running")
+                    this.eventBus.emit({ type: "process-output", processId });
+            }, 500).unref();
+        }
     }
     onExit(processId, exitCode, signal) {
         const item = this.processes.get(processId);
@@ -172,7 +158,8 @@ export class ProcessSupervisor {
             clearTimeout(item.timeout);
         if (item.forceTimeout)
             clearTimeout(item.forceTimeout);
-        // A signal is represented as killed/cancelled; otherwise zero means exited and non-zero means failed.
+        if (item.outputEventTimer)
+            clearTimeout(item.outputEventTimer);
         item.finishedAt = new Date();
         item.exitCode = exitCode;
         item.signal = signal;

package/dist/plugins/process/types.d.ts

@@ -1,7 +1,3 @@
-/**
- * Process lifecycle and request types shared above the platform-specific backend layer.
- * ProcessId is independent from the OS PID and transport/session identity.
- */
 type ProcessState = "running" | "exited" | "killed" | "failed";
 export type ProcessId = string;
 export interface ProcessStartRequest {
@@ -24,7 +20,6 @@ export interface ProcessSnapshot {
     durationMs: number;
     exitCode: number | null;
     signal: string | null;
-    /** Bounded retained output rather than an unbounded transcript. */
     stdout: string;
     stderr: string;
     outputTruncated: boolean;

package/dist/plugins/types.d.ts

@@ -7,7 +7,6 @@ import type { ExternalAccessRegistry } from "../app/external-access-registry.js"
 export interface ServiceToken<T> {
     readonly key: symbol;
     readonly name: string;
-    /** Compile-time marker only; it is never set at runtime. */
     readonly __type?: T;
 }
 export declare function createServiceToken<T>(name: string): ServiceToken<T>;

package/dist/plugins/web/api-types.d.ts

@@ -1,10 +1,9 @@
 import type { Operation as DomainOperation } from "../../core/operations/types.js";
-import type { GitInfo } from "../workspace/domain/git.js";
+import type { GitBranch, GitChange, GitCommit, GitDiff, GitStatus } from "../git/types.js";
 import type { ProcessSnapshot } from "../process/types.js";
 import type { ComputerDisplay, ComputerPermission, ComputerSnapshot, ComputerStatus } from "../computer/types.js";
-import type { Workspace } from "../workspace/domain/workspace.js";
-import type { WorktreeApplyPreview, WorktreeFileDiff } from "../workspace/domain/review.js";
-export type { ComputerDisplay, ComputerPermission, ComputerStatus, ProcessSnapshot, WorktreeApplyPreview, WorktreeFileDiff, };
+import type { WorkspaceEntry, WorkspaceFile, WorkspaceInfo, WorkspaceSkill } from "../workspace/types.js";
+export type { ComputerDisplay, ComputerPermission, ComputerStatus, GitBranch, GitChange, GitCommit, GitDiff, GitStatus, ProcessSnapshot, WorkspaceEntry, WorkspaceFile, WorkspaceInfo, WorkspaceSkill, };
 export interface ComputerPreviewView {
     snapshotId: string;
     revision: number;
@@ -19,6 +18,3 @@ export interface ComputerPreviewView {
     screenshot: ComputerSnapshot["screenshot"] | null;
 }
 export type Operation = DomainOperation;
-export interface WorkspaceView extends Workspace {
-    git?: GitInfo | null;
-}

package/dist/plugins/web/http/api-router.d.ts

@@ -1,4 +1,3 @@
-/** HTTP/JSON presentation adapter for runtime status, workspaces, operations, processes, and management actions. */
 import { Router } from "express";
 import type { WebRuntime } from "../runtime.js";
 import type { RuntimeEventBus } from "../../../app/event-bus.js";

package/dist/plugins/web/http/api-router.js

@@ -1,9 +1,9 @@
-/** HTTP/JSON presentation adapter for runtime status, workspaces, operations, processes, and management actions. */
 import { Router } from "express";
 import { ChatRoomError } from "../../../core/errors/chatroom-error.js";
 import { asyncRoute, parseCookie, requireString, } from "../../../presentation/http/http-utils.js";
 import { createProcessApiRouter } from "./process-api-router.js";
 import { createWorkspaceApiRouter } from "./workspace-api-router.js";
+import { createGitApiRouter } from "./git-api-router.js";
 import { createCloudApiRouter } from "./cloud-api-router.js";
 import { createComputerApiRouter } from "./computer-api-router.js";
 const SESSION_COOKIE = "chatroom_session";
@@ -81,9 +81,6 @@ export function createApiRouter(application, eventBus, auth, passkeys, ingress,
             ...(typeof req.query.status === "string"
                 ? { status: req.query.status }
                 : {}),
-            ...(typeof req.query.workspaceId === "string"
-                ? { workspaceId: req.query.workspaceId }
-                : {}),
         }));
     });
     router.delete("/operations", (_req, res) => {
@@ -97,6 +94,7 @@ export function createApiRouter(application, eventBus, auth, passkeys, ingress,
         res.json(event);
     });
     router.use(createWorkspaceApiRouter(application));
+    router.use(createGitApiRouter(application));
     router.use(createProcessApiRouter(application));
     router.use(createComputerApiRouter(application.computer, application.operations, ingress));
     router.use(createCloudApiRouter(cloud, application.operations));

package/dist/plugins/web/http/git-api-router.d.ts

@@ -0,0 +1,3 @@
+import { Router } from "express";
+import type { WebRuntime } from "../runtime.js";
+export declare function createGitApiRouter(application: WebRuntime): Router;