@chatroomcp/chatroom 0.2.0 → 0.2.2

package/dist/mcp/server/create-mcp-server.js

@@ -7,9 +7,9 @@ export function createChatRoomMcpHandler(plugins) {
     });
 }
 function createServer(plugins) {
-    const server = new McpServer({ name: CHATROOM_NAME, version: CHATROOM_VERSION }, {
-        instructions: "Workspace lifecycle is independent from MCP connections. " +
-            "Use WorkspaceId only with workspace tools and ProcessId only with process tools.",
+    const server = new McpServer({
+        name: CHATROOM_NAME,
+        version: CHATROOM_VERSION,
     });
     plugins.registerMcp(server);
     return server;

package/dist/mcp/server/plugin-mcp-registrar.d.ts

@@ -4,7 +4,6 @@ type PluginToolInput<Schema extends StandardSchemaWithJSON> = StandardSchemaWith
 type PluginToolAction<Input> = string | ((input: Input) => string);
 export interface PluginToolExecution {
     readonly operationId: string;
-    /** Keep the operation running after the MCP handler returns. The owner must finish it later. */
     deferCompletion(): void;
 }
 export interface PluginToolConfig<InputSchema extends StandardSchemaWithJSON, OutputSchema extends StandardSchemaWithJSON> {
@@ -20,7 +19,6 @@ export interface PluginToolConfig<InputSchema extends StandardSchemaWithJSON, Ou
     };
     present?: (output: unknown) => CallToolResult;
 }
-/** Framework-owned MCP registration boundary that guarantees every plugin tool is audited. */
 export declare class PluginMcpRegistrar {
     private readonly server;
     private readonly operations;

package/dist/mcp/server/plugin-mcp-registrar.js

@@ -1,6 +1,5 @@
 import { asChatRoomError } from "../../core/errors/chatroom-error.js";
 import { mcpTool } from "./tool-support.js";
-/** Framework-owned MCP registration boundary that guarantees every plugin tool is audited. */
 export class PluginMcpRegistrar {
     server;
     operations;
@@ -53,9 +52,6 @@ function operationReferences(input) {
         return {};
     const record = input;
     return {
-        ...(typeof record.workspaceId === "string"
-            ? { workspaceId: record.workspaceId }
-            : {}),
         ...(typeof record.processId === "string"
             ? { processId: record.processId }
             : {}),

package/dist/mcp/server/tool-support.d.ts

@@ -6,18 +6,6 @@ export declare const closedRead: {
     idempotentHint: true;
     openWorldHint: false;
 };
-export declare const localWrite: {
-    readOnlyHint: false;
-    destructiveHint: true;
-    idempotentHint: true;
-    openWorldHint: false;
-};
-export declare const localMutation: {
-    readOnlyHint: false;
-    destructiveHint: false;
-    idempotentHint: false;
-    openWorldHint: false;
-};
 export declare const destructiveLocalMutation: {
     readOnlyHint: false;
     destructiveHint: true;
@@ -30,55 +18,6 @@ export declare const openWorldMutation: {
     idempotentHint: false;
     openWorldHint: true;
 };
-export declare const workspaceOutputSchema: z.ZodObject<{
-    id: z.ZodString;
-    root: z.ZodString;
-    sourceRoot: z.ZodString;
-    mode: z.ZodEnum<{
-        checkout: "checkout";
-        worktree: "worktree";
-    }>;
-    createdAt: z.ZodString;
-    lastUsedAt: z.ZodString;
-    instructions: z.ZodArray<z.ZodString>;
-    skills: z.ZodArray<z.ZodString>;
-    capabilities: z.ZodObject<{
-        filesystem: z.ZodLiteral<"read-write">;
-        git: z.ZodBoolean;
-        skills: z.ZodBoolean;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export declare const fileReadOutputSchema: z.ZodObject<{
-    content: z.ZodString;
-    bytes: z.ZodNumber;
-    truncated: z.ZodBoolean;
-}, z.core.$strip>;
-export declare const fileWriteOutputSchema: z.ZodObject<{
-    path: z.ZodString;
-    bytes: z.ZodNumber;
-}, z.core.$strip>;
-export declare const fileInfoSchema: z.ZodObject<{
-    path: z.ZodString;
-    type: z.ZodEnum<{
-        file: "file";
-        directory: "directory";
-        symlink: "symlink";
-    }>;
-    size: z.ZodNumber;
-    modifiedAt: z.ZodString;
-}, z.core.$strip>;
-export declare const searchMatchSchema: z.ZodObject<{
-    path: z.ZodString;
-    line: z.ZodNumber;
-    column: z.ZodNumber;
-    preview: z.ZodString;
-}, z.core.$strip>;
-export declare const changeSetSchema: z.ZodObject<{
-    files: z.ZodArray<z.ZodString>;
-    replacements: z.ZodNumber;
-    bytesBefore: z.ZodNumber;
-    bytesAfter: z.ZodNumber;
-}, z.core.$strip>;
 export declare const processSnapshotSchema: z.ZodObject<{
     processId: z.ZodString;
     command: z.ZodString;

package/dist/mcp/server/tool-support.js

@@ -6,18 +6,6 @@ export const closedRead = {
     idempotentHint: true,
     openWorldHint: false,
 };
-export const localWrite = {
-    readOnlyHint: false,
-    destructiveHint: true,
-    idempotentHint: true,
-    openWorldHint: false,
-};
-export const localMutation = {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: false,
-    openWorldHint: false,
-};
 export const destructiveLocalMutation = {
     readOnlyHint: false,
     destructiveHint: true,
@@ -30,48 +18,6 @@ export const openWorldMutation = {
     idempotentHint: false,
     openWorldHint: true,
 };
-export const workspaceOutputSchema = z.object({
-    id: z.string(),
-    root: z.string(),
-    sourceRoot: z.string(),
-    mode: z.enum(["checkout", "worktree"]),
-    createdAt: z.string(),
-    lastUsedAt: z.string(),
-    instructions: z.array(z.string()),
-    skills: z.array(z.string()),
-    capabilities: z.object({
-        filesystem: z.literal("read-write"),
-        git: z.boolean(),
-        skills: z.boolean(),
-    }),
-});
-export const fileReadOutputSchema = z.object({
-    content: z.string(),
-    bytes: z.number().int().nonnegative(),
-    truncated: z.boolean(),
-});
-export const fileWriteOutputSchema = z.object({
-    path: z.string(),
-    bytes: z.number().int().nonnegative(),
-});
-export const fileInfoSchema = z.object({
-    path: z.string(),
-    type: z.enum(["file", "directory", "symlink"]),
-    size: z.number().int().nonnegative(),
-    modifiedAt: z.string(),
-});
-export const searchMatchSchema = z.object({
-    path: z.string(),
-    line: z.number().int().positive(),
-    column: z.number().int().positive(),
-    preview: z.string(),
-});
-export const changeSetSchema = z.object({
-    files: z.array(z.string()),
-    replacements: z.number().int().nonnegative(),
-    bytesBefore: z.number().int().nonnegative(),
-    bytesAfter: z.number().int().nonnegative(),
-});
 export const processSnapshotSchema = z.object({
     processId: z.string(),
     command: z.string(),

package/dist/native/macos/ChatRoomComputerHelper.app/Contents/Info.plist

@@ -8,7 +8,7 @@
 <key>CFBundlePackageType</key><string>APPL</string>
 <key>CFBundleVersion</key><string>1</string>
 <key>CFBundleShortVersionString</key><string>1.0</string>
-<key>LSMinimumSystemVersion</key><string>15.2</string>
+<key>LSMinimumSystemVersion</key><string>14.0</string>
 <key>LSUIElement</key><true/>
 <key>NSHumanReadableCopyright</key><string>ChatRoom</string>
 </dict></plist>

package/dist/operations/operation-log.d.ts

@@ -1,7 +1,6 @@
 import type { Operation, OperationStart, OperationStatus } from "../core/operations/types.js";
 import type { OperationQuery, OperationRepository } from "../core/operations/repository.js";
 import type { RuntimeEventBus } from "../app/event-bus.js";
-/** Persists redacted, bounded operations produced by ChatRoom plugins. */
 export declare class OperationLog {
     private readonly repository;
     private readonly eventBus;
@@ -10,12 +9,10 @@ export declare class OperationLog {
     constructor(repository: OperationRepository, eventBus: RuntimeEventBus, maxPayloadBytes: number);
     start(request: OperationStart): Operation;
     finish(operationId: string, status: Exclude<OperationStatus, "running">, output?: unknown, error?: unknown): Operation;
-    updateRunning(operationId: string, output: unknown): Operation;
     run<T>(request: OperationStart, action: () => Promise<T>): Promise<T>;
     list(query?: OperationQuery): Operation[];
     get(operationId: string): Operation | null;
     associate(operationId: string, references: {
-        workspaceId?: string | null;
         processId?: string | null;
     }): Operation;
     clearHistory(): {

package/dist/operations/operation-log.js

@@ -2,7 +2,6 @@ import { randomUUID } from "node:crypto";
 import { boundJson } from "../core/operations/bounded-value.js";
 import { SecretRedactor } from "../core/operations/redactor.js";
 import { asChatRoomError, ChatRoomError, } from "../core/errors/chatroom-error.js";
-/** Persists redacted, bounded operations produced by ChatRoom plugins. */
 export class OperationLog {
     repository;
     eventBus;
@@ -21,7 +20,6 @@ export class OperationLog {
             source: request.source,
             action: request.action,
             status: "running",
-            workspaceId: request.workspaceId ?? null,
             processId: request.processId ?? null,
             input: input.value,
             output: null,
@@ -52,17 +50,6 @@ export class OperationLog {
         this.eventBus.emit({ type: "operation", operation });
         return operation;
     }
-    updateRunning(operationId, output) {
-        const operation = this.require(operationId);
-        if (operation.status !== "running")
-            return operation;
-        const bounded = boundJson(this.redactor.redact(output), this.maxPayloadBytes);
-        operation.output = bounded.value;
-        operation.outputTruncated = bounded.truncated;
-        this.repository.update(operation);
-        this.eventBus.emit({ type: "operation", operation });
-        return operation;
-    }
     async run(request, action) {
         const operation = this.start(request);
         try {
@@ -88,8 +75,6 @@ export class OperationLog {
     }
     associate(operationId, references) {
         const operation = this.require(operationId);
-        if (references.workspaceId !== undefined)
-            operation.workspaceId = references.workspaceId;
         if (references.processId !== undefined)
             operation.processId = references.processId;
         this.repository.update(operation);

package/dist/plugins/cloud/api-client.js

@@ -79,6 +79,7 @@ export class CloudApiClient {
                 ...payload,
                 ...proof,
             }),
+            signal: AbortSignal.timeout(15_000),
         });
         const body = (await response.json().catch(() => null));
         if (!response.ok) {

package/dist/plugins/cloud/controller.d.ts

@@ -18,6 +18,7 @@ export declare class CloudController {
     private lastError;
     private managementTimer;
     private renewalTimer;
+    private statusRetryTimer;
     private stopped;
     private constructor();
     static create(config: ChatRoomConfig, externalAccess?: ExternalAccessSink): Promise<CloudController>;
@@ -38,6 +39,7 @@ export declare class CloudController {
     private refreshLeaseIfNeeded;
     private connectTunnel;
     private publishExternalAccess;
+    private scheduleStatusRetry;
     private scheduleManagementSync;
     private scheduleRenewal;
     private validManagementSession;

package/dist/plugins/cloud/controller.js

@@ -13,6 +13,7 @@ export class CloudController {
     lastError = null;
     managementTimer = null;
     renewalTimer = null;
+    statusRetryTimer = null;
     stopped = true;
     constructor(config, cloudApi, externalAccess) {
         this.config = config;
@@ -28,6 +29,9 @@ export class CloudController {
         return controller;
     }
     status() {
+        const lease = this.state.lease && Date.parse(this.state.lease.expiresAt) > Date.now()
+            ? this.state.lease
+            : null;
         return {
             installationId: this.state.installationId,
             customerId: this.state.customerId,
@@ -37,10 +41,8 @@ export class CloudController {
             managementSessionActive: Boolean(this.state.managementSession &&
                 Date.parse(this.state.managementSession.expiresAt) > Date.now()),
             connection: this.connection,
-            mcpUrl: this.state.lease?.mcpBaseUrl
-                ? `${this.state.lease.mcpBaseUrl}/mcp`
-                : null,
-            webUrl: this.state.lease?.webBaseUrl ?? null,
+            mcpUrl: lease?.mcpBaseUrl ? `${lease.mcpBaseUrl}/mcp` : null,
+            webUrl: lease?.webBaseUrl ?? null,
             lastError: this.lastError,
         };
     }
@@ -48,7 +50,10 @@ export class CloudController {
         if (!this.stopped)
             return;
         this.stopped = false;
-        await this.syncStatus().catch((error) => this.setError(error));
+        await this.syncStatus().catch((error) => {
+            this.setError(error);
+            this.scheduleStatusRetry();
+        });
         this.scheduleManagementSync();
     }
     async stop() {
@@ -57,8 +62,11 @@ export class CloudController {
             clearTimeout(this.managementTimer);
         if (this.renewalTimer)
             clearTimeout(this.renewalTimer);
+        if (this.statusRetryTimer)
+            clearTimeout(this.statusRetryTimer);
         this.managementTimer = null;
         this.renewalTimer = null;
+        this.statusRetryTimer = null;
         this.tunnel?.stop();
         this.tunnel = null;
         this.externalAccess?.clearCloud();
@@ -106,6 +114,9 @@ export class CloudController {
             this.scheduleRenewal();
         }
         this.lastError = null;
+        if (this.statusRetryTimer)
+            clearTimeout(this.statusRetryTimer);
+        this.statusRetryTimer = null;
         return this.status();
     }
     async restore(recoveryKey) {
@@ -222,6 +233,18 @@ export class CloudController {
                 : null,
         });
     }
+    scheduleStatusRetry(delayMs = 30_000) {
+        if (this.stopped || this.statusRetryTimer)
+            return;
+        this.statusRetryTimer = setTimeout(() => {
+            this.statusRetryTimer = null;
+            void this.syncStatus().catch((error) => {
+                this.setError(error);
+                this.scheduleStatusRetry();
+            });
+        }, delayMs);
+        this.statusRetryTimer.unref();
+    }
     scheduleManagementSync(delayMs = 3_000) {
         if (this.managementTimer)
             clearTimeout(this.managementTimer);

package/dist/plugins/cloud/tunnel-client.js

@@ -77,15 +77,11 @@ export class CloudTunnelClient {
         this.acceptingServices = new Set(lease.services);
         if (this.stopped)
             return;
-        // A new signed lease on the same tunnel is applied in-band. This keeps the
-        // current WebUI/API request alive while service permissions change.
         if (!tunnelChanged) {
             if (this.socket?.readyState === WebSocket.OPEN)
                 this.send({ type: "update-lease", lease: lease.token });
             return;
         }
-        // Changing the tunnel endpoint still requires a reconnect. If a service is
-        // being removed, let current streams finish before moving the connection.
         if (!removesService || this.streams.size === 0) {
             this.socket?.close();
             return;

package/dist/plugins/computer/computer-native-host.d.ts

@@ -15,9 +15,10 @@ export declare class ComputerNativeHost {
     restart(reason?: string): void;
     dispose(): Promise<void>;
     private ensureStarted;
+    private startHelper;
     private startMacHelper;
     private attachSocket;
-    private startWindowsHelper;
+    private startPipeHelper;
     private failTransport;
     private reset;
     private rejectPending;

package/dist/plugins/computer/computer-native-host.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { spawn } from "node:child_process";
+import { spawn, spawnSync, } from "node:child_process";
 import { chmodSync, existsSync, rmSync } from "node:fs";
 import { createServer } from "node:net";
 import { createInterface } from "node:readline";
@@ -21,6 +21,8 @@ export class ComputerNativeHost {
             return "macos";
         if (process.platform === "win32")
             return "windows";
+        if (process.platform === "linux")
+            return "linux";
         return "unsupported";
     }
     get idle() {
@@ -59,18 +61,16 @@ export class ComputerNativeHost {
         this.reset(new Error("Computer helper stopped"));
     }
     async ensureStarted() {
-        if (this.platform === "macos" && this.socket && !this.socket.destroyed)
+        const platform = this.platform;
+        if (platform === "macos" && this.socket && !this.socket.destroyed)
             return;
-        if (this.platform === "windows" && this.child && !this.child.killed)
+        if ((platform === "windows" || platform === "linux") &&
+            this.child &&
+            !this.child.killed)
             return;
         if (this.starting)
             return this.starting;
-        this.starting =
-            this.platform === "macos"
-                ? this.startMacHelper()
-                : this.platform === "windows"
-                    ? this.startWindowsHelper()
-                    : Promise.reject(new ChatRoomError("UNSUPPORTED", "Computer Use is supported only on macOS and Windows"));
+        this.starting = this.startHelper(platform);
         try {
             await this.starting;
         }
@@ -78,6 +78,18 @@ export class ComputerNativeHost {
             this.starting = null;
         }
     }
+    startHelper(platform) {
+        switch (platform) {
+            case "macos":
+                return this.startMacHelper();
+            case "windows":
+                return this.startPipeHelper(windowsHelperPath(), "Windows");
+            case "linux":
+                return this.startPipeHelper(linuxHelperPath(), "Linux X11", linuxDesktopEnvironment());
+            case "unsupported":
+                return Promise.reject(new ChatRoomError("UNSUPPORTED", "Computer Use is supported only on macOS, Windows, and Linux X11"));
+        }
+    }
     async startMacHelper() {
         const app = macHelperAppPath();
         if (!app)
@@ -131,13 +143,13 @@ export class ComputerNativeHost {
         socket.once("error", (error) => this.failTransport(socket, error));
         socket.once("close", () => this.failTransport(socket, new Error("Computer helper exited")));
     }
-    async startWindowsHelper() {
-        const executable = windowsHelperPath();
+    async startPipeHelper(executable, platformName, env = process.env) {
         if (!executable)
-            throw new ChatRoomError("UNSUPPORTED", "Windows Computer helper is missing");
+            throw new ChatRoomError("UNSUPPORTED", `${platformName} Computer helper is missing`);
         const child = spawn(executable, [], {
             stdio: ["pipe", "pipe", "pipe"],
-            windowsHide: true,
+            windowsHide: process.platform === "win32",
+            env,
         });
         this.child = child;
         this.lines = createInterface({ input: child.stdout });
@@ -236,10 +248,88 @@ function projectRoot() {
     return path.resolve(path.dirname(current), "../../..");
 }
 function macHelperAppPath() {
-    const app = path.join(projectRoot(), "dist", "native", "macos", "ChatRoomComputerHelper.app");
-    return existsSync(app) ? app : null;
+    return nativeHelperPath("macos", "ChatRoomComputerHelper.app");
 }
 function windowsHelperPath() {
-    const executable = path.join(projectRoot(), "dist", "native", "windows", "chatroom-computer-helper.exe");
-    return existsSync(executable) ? executable : null;
+    return nativeHelperPath("windows", "chatroom-computer-helper.exe");
+}
+function linuxHelperPath() {
+    return nativeHelperPath("linux", "chatroom-computer-helper");
+}
+function nativeHelperPath(...parts) {
+    const target = path.join(projectRoot(), "dist", "native", ...parts);
+    return existsSync(target) ? target : null;
+}
+function linuxDesktopEnvironment() {
+    const env = { ...process.env };
+    const uid = typeof process.getuid === "function" ? process.getuid() : null;
+    if (!env.XDG_RUNTIME_DIR && uid !== null) {
+        const runtimeDir = `/run/user/${uid}`;
+        if (existsSync(runtimeDir))
+            env.XDG_RUNTIME_DIR = runtimeDir;
+    }
+    if (!env.DISPLAY) {
+        const display = activeX11Display(uid);
+        if (display) {
+            env.DISPLAY = display;
+            env.XDG_SESSION_TYPE = "x11";
+        }
+    }
+    if (!env.XAUTHORITY) {
+        const candidates = [
+            env.HOME ? path.join(env.HOME, ".Xauthority") : null,
+            env.XDG_RUNTIME_DIR
+                ? path.join(env.XDG_RUNTIME_DIR, "gdm", "Xauthority")
+                : null,
+        ];
+        const authority = candidates.find((candidate) => !!candidate && existsSync(candidate));
+        if (authority)
+            env.XAUTHORITY = authority;
+    }
+    if (!env.DBUS_SESSION_BUS_ADDRESS && env.XDG_RUNTIME_DIR) {
+        const bus = path.join(env.XDG_RUNTIME_DIR, "bus");
+        if (existsSync(bus))
+            env.DBUS_SESSION_BUS_ADDRESS = `unix:path=${bus}`;
+    }
+    return env;
+}
+function activeX11Display(uid) {
+    if (process.platform !== "linux" || uid === null)
+        return null;
+    const loginctl = existsSync("/usr/bin/loginctl")
+        ? "/usr/bin/loginctl"
+        : "loginctl";
+    const sessions = spawnSync(loginctl, ["list-sessions", "--no-legend", "--no-pager"], {
+        encoding: "utf8",
+        timeout: 2_000,
+    });
+    if (sessions.status !== 0 || !sessions.stdout)
+        return null;
+    const userId = String(uid);
+    for (const line of sessions.stdout.split("\n")) {
+        const [sessionId, sessionUid] = line.trim().split(/\s+/, 3);
+        if (!sessionId || sessionUid !== userId)
+            continue;
+        const details = spawnSync(loginctl, [
+            "show-session",
+            sessionId,
+            "--no-pager",
+            "-p",
+            "Type",
+            "-p",
+            "Active",
+            "-p",
+            "Display",
+        ], { encoding: "utf8", timeout: 2_000 });
+        if (details.status !== 0 || !details.stdout)
+            continue;
+        const values = Object.fromEntries(details.stdout
+            .split("\n")
+            .map((item) => item.split("=", 2))
+            .filter((item) => item.length === 2));
+        if (values.Type === "x11" && values.Active === "yes" && values.Display) {
+            return values.Display;
+        }
+    }
+    return null;
 }

package/dist/plugins/computer/computer-schemas.d.ts

@@ -36,6 +36,7 @@ export declare const computerNativeStatusSchema: z.ZodObject<{
     platform: z.ZodEnum<{
         macos: "macos";
         windows: "windows";
+        linux: "linux";
         unsupported: "unsupported";
     }>;
     helper: z.ZodEnum<{

package/dist/plugins/computer/computer-schemas.js

@@ -30,7 +30,7 @@ export const computerScreenshotSchema = z.object({
     data: z.string(),
 });
 export const computerNativeStatusSchema = z.object({
-    platform: z.enum(["macos", "windows", "unsupported"]),
+    platform: z.enum(["macos", "windows", "linux", "unsupported"]),
     helper: z.enum(["running", "stopped", "unavailable"]),
     permissions: z.object({
         accessibility: computerPermissionStateSchema,

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

@@ -1,5 +1,5 @@
 export type ComputerAccessScope = "local" | "remote";
-export type ComputerPlatform = "macos" | "windows" | "unsupported";
+export type ComputerPlatform = "macos" | "windows" | "linux" | "unsupported";
 export type ComputerHelperState = "running" | "stopped" | "unavailable";
 export type ComputerPermissionState = "granted" | "denied" | "unknown" | "not-required";
 export type ComputerPermission = "accessibility" | "screenRecording";

package/dist/plugins/git/git-service.d.ts

@@ -0,0 +1,33 @@
+import type { CommandRunner } from "../../core/runtime/command-runner.js";
+import type { GitBranch, GitCommit, GitDiff, GitStatus } from "./types.js";
+export declare class GitService {
+    private readonly commands;
+    constructor(commands: CommandRunner);
+    status(cwd: string): Promise<GitStatus | null>;
+    diff(cwd: string, filePath?: string, maxPreviewBytes?: number): Promise<GitDiff>;
+    stage(cwd: string, paths: string[]): Promise<GitStatus>;
+    unstage(cwd: string, paths: string[]): Promise<GitStatus>;
+    restore(cwd: string, filePath: string): Promise<GitStatus>;
+    commit(cwd: string, message: string): Promise<GitStatus>;
+    branches(cwd: string): Promise<GitBranch[]>;
+    createBranch(cwd: string, name: string): Promise<GitStatus>;
+    switchBranch(cwd: string, name: string): Promise<GitStatus>;
+    deleteBranch(cwd: string, name: string): Promise<GitStatus>;
+    log(cwd: string, limit?: number): Promise<GitCommit[]>;
+    fetch(cwd: string): Promise<GitStatus>;
+    pull(cwd: string): Promise<GitStatus>;
+    push(cwd: string): Promise<GitStatus>;
+    private run;
+    private repositoryRoot;
+    private requireRepository;
+    private requireStatus;
+    private head;
+    private requireHead;
+    private branch;
+    private upstream;
+    private aheadBehind;
+    private relatedPaths;
+    private pathExistsInHead;
+    private validateBranchName;
+    private withSnapshotIndex;
+}