@zhanguym/chatroom 1.0.0 → 1.1.0-beta.1

package/dist/plugins/agent/store.d.ts

@@ -0,0 +1,17 @@
+import type { AgentHistory, AgentHistoryUpdate, AgentItem, AgentProviderSessionState, AgentSession, AgentTurn } from "./types.js";
+export interface AgentStore {
+    reconcileInterrupted(now: string): void;
+    insertSession(session: AgentSession): void;
+    updateSession(session: AgentSession): void;
+    getSession(id: string): AgentSession | null;
+    listSessions(): AgentSession[];
+    deleteSession(id: string): void;
+    getProviderState(sessionId: string, provider: AgentProviderSessionState["provider"]): AgentProviderSessionState | null;
+    upsertProviderState(state: AgentProviderSessionState): void;
+    insertTurn(turn: AgentTurn): void;
+    updateTurn(turn: AgentTurn): void;
+    insertItem(item: AgentItem): void;
+    updateItem(item: AgentItem): void;
+    history(sessionId: string): AgentHistory | null;
+    historyUpdate(sessionId: string, turnIds: readonly string[], itemIds: readonly string[]): AgentHistoryUpdate | null;
+}

package/dist/plugins/agent/store.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,320 @@
+export type AgentProviderId = string;
+export declare const AGENT_PROVIDER_ID_PATTERN: RegExp;
+export declare function isAgentProviderId(value: unknown): value is AgentProviderId;
+export type AgentSessionStatus = "idle" | "running" | "waiting_input" | "error";
+export type AgentTurnStatus = "running" | "completed" | "interrupted" | "failed";
+export type AgentTurnSource = "human" | "mcp";
+export type AgentItemStatus = "running" | "completed" | "waiting" | "interrupted" | "failed";
+export type AgentReasoningSummary = "auto" | "concise" | "detailed" | "none";
+export interface CodexGranularApprovalPolicy {
+    sandbox_approval: boolean;
+    rules: boolean;
+    skill_approval: boolean;
+    request_permissions: boolean;
+    mcp_elicitations: boolean;
+}
+export type CodexApprovalPolicy = "untrusted" | "on-request" | {
+    granular: CodexGranularApprovalPolicy;
+} | "never";
+export type CodexApprovalsReviewer = "user" | "auto_review" | "guardian_subagent";
+export type CodexSandboxMode = "read-only" | "workspace-write" | "danger-full-access";
+export declare const AGENT_PERMISSION_MODES: readonly ["read-only", "workspace-write", "danger-full-access"];
+export declare function isAgentPermissionMode(value: unknown): value is CodexSandboxMode;
+export interface AgentProviderNativeSetting {
+    id: "approvalPolicy" | "approvalsReviewer" | "permissionMode";
+    defaultValue: string;
+    options: readonly {
+        id: string;
+        description: string | null;
+    }[];
+    granularFields: readonly {
+        id: string;
+        description: string | null;
+    }[];
+}
+export interface AgentSessionConfig {
+    model: string | null;
+    reasoningEffort: string | null;
+    reasoningSummary: AgentReasoningSummary | null;
+    serviceTier: string | null;
+    approvalPolicy: CodexApprovalPolicy | null;
+    approvalsReviewer: CodexApprovalsReviewer | null;
+    permissionMode: CodexSandboxMode | null;
+}
+export interface TokenUsageBreakdown {
+    totalTokens: number;
+    inputTokens: number;
+    cachedInputTokens: number;
+    cacheWriteInputTokens: number;
+    outputTokens: number;
+    reasoningOutputTokens: number;
+}
+export interface AgentTokenUsage {
+    total: TokenUsageBreakdown;
+    last: TokenUsageBreakdown;
+    modelContextWindow: number | null;
+}
+export interface AgentPlanStep {
+    step: string;
+    status: "pending" | "inProgress" | "completed";
+}
+export interface AgentModel {
+    id: string;
+    model: string;
+    displayName: string;
+    description: string;
+    modelSpecialty: string | null;
+    isDefault: boolean;
+    upgrade: string | null;
+    upgradeInfo: unknown | null;
+    availabilityMessage: string | null;
+    reasoningEfforts: Array<{
+        id: string;
+        description: string;
+    }>;
+    defaultReasoningEffort: string | null;
+    reasoningSummaries: AgentReasoningSummary[];
+    defaultReasoningSummary: AgentReasoningSummary | null;
+    inputModalities: Array<"text" | "image" | "audio">;
+    multiAgentVersion: string | null;
+    serviceTiers: Array<{
+        id: string;
+        name: string;
+        description: string;
+    }>;
+    defaultServiceTier: string | null;
+    availableAccessPrograms: {
+        cyber: string[];
+        [program: string]: string[];
+    } | null;
+}
+export interface AgentProviderQuotaWindow {
+    id: string;
+    label: string | null;
+    utilization: number | null;
+    resetsAt: string | null;
+}
+export interface AgentProviderExtraUsage {
+    enabled: boolean;
+    monthlyLimit: number | null;
+    usedCredits: number | null;
+    utilization: number | null;
+    currency: string | null;
+}
+export interface AgentProviderAccountUsage {
+    subscriptionType: string | null;
+    windows: AgentProviderQuotaWindow[];
+    extraUsage: AgentProviderExtraUsage | null;
+    updatedAt: string;
+}
+export interface AgentProviderDetails {
+    configRequirements: unknown | null;
+    rateLimits: unknown | null;
+    accountUsage: AgentProviderAccountUsage | null;
+}
+export type AgentReviewTarget = {
+    type: "uncommittedChanges";
+} | {
+    type: "baseBranch";
+    branch: string;
+} | {
+    type: "commit";
+    sha: string;
+    title: string | null;
+} | {
+    type: "custom";
+    instructions: string;
+};
+export interface AgentProviderFeatures {
+    nativeReview: boolean;
+    steering: boolean;
+    [feature: string]: boolean;
+}
+export interface AgentProviderProbe {
+    installed: boolean;
+    authenticated: boolean;
+    version: string | null;
+    error: string | null;
+    capabilities: {
+        namespaceTools: boolean;
+        imageGeneration: boolean;
+        webSearch: boolean;
+        [capability: string]: boolean;
+    } | null;
+}
+export interface AgentProviderStatus extends AgentProviderProbe {
+    id: AgentProviderId;
+    displayName: string;
+    icon: string | null;
+    features: AgentProviderFeatures;
+    nativeSettings: readonly AgentProviderNativeSetting[];
+}
+export interface AgentSessionAttention {
+    kind: "approval" | "input";
+    count: number;
+}
+export interface AgentSession extends AgentSessionConfig {
+    id: string;
+    workspaceRoot: string;
+    provider: AgentProviderId;
+    status: AgentSessionStatus;
+    attention: AgentSessionAttention | null;
+    createdAt: string;
+    tokenUsage: AgentTokenUsage | null;
+    updatedAt: string;
+}
+export interface AgentProviderSessionState extends AgentSessionConfig {
+    sessionId: string;
+    provider: AgentProviderId;
+    providerSessionId: string;
+    continuityContext: string;
+    syncedThroughTurnId: string | null;
+    createdAt: string;
+    tokenUsage: AgentTokenUsage | null;
+    updatedAt: string;
+}
+export interface AgentError {
+    message: string;
+    details: string | null;
+    providerData: unknown | null;
+}
+export interface AgentTurn extends AgentSessionConfig {
+    id: string;
+    sessionId: string;
+    providerTurnId: string | null;
+    provider: AgentProviderId;
+    source: AgentTurnSource;
+    status: AgentTurnStatus;
+    error: AgentError | null;
+    usage: TokenUsageBreakdown | null;
+    startedAt: string;
+    completedAt: string | null;
+}
+export interface AgentAttachment {
+    kind: "image" | "audio" | "skill" | "file";
+    name: string;
+    path: string;
+    mimeType: string | null;
+}
+export interface AgentArtifact {
+    kind: "image" | "file";
+    name: string;
+    path: string;
+    mimeType: string | null;
+}
+export interface AgentFileChange {
+    path: string;
+    kind: string;
+    movePath: string | null;
+    diff: string;
+}
+export interface AgentInteractionOption {
+    id: string;
+    label: string;
+    description: string | null;
+}
+export interface AgentInputQuestion {
+    id: string;
+    label: string;
+    question: string;
+    options: AgentInteractionOption[];
+    multiSelect: boolean;
+    allowFreeText: boolean;
+    secret: boolean;
+}
+export type AgentInteractionResponse = {
+    type: "approval";
+    decision: string;
+} | {
+    type: "input";
+    answers: Record<string, string[]>;
+};
+export type AgentItem = AgentItemBase & ({
+    type: "user_message";
+    source?: AgentTurnSource;
+    text: string;
+    attachments: AgentAttachment[];
+} | {
+    type: "assistant_message";
+    text: string;
+    phase: "commentary" | "final_answer" | null;
+} | {
+    type: "command";
+    command: string;
+    cwd: string | null;
+    output: string;
+    exitCode: number | null;
+} | {
+    type: "tool";
+    progress: string | null;
+    name: string;
+    server: string | null;
+    input: unknown;
+    output: unknown;
+    error: string | null;
+} | {
+    type: "turn_diff";
+    diff: string;
+} | {
+    type: "file_change";
+    changes: AgentFileChange[];
+} | {
+    type: "plan";
+    text: string;
+    steps: AgentPlanStep[];
+} | {
+    type: "reasoning_summary";
+    text: string;
+} | {
+    type: "artifact";
+    artifact: AgentArtifact;
+} | {
+    type: "interaction";
+    interaction: {
+        kind: "approval" | "input";
+        title: string;
+        description: string | null;
+        questions: AgentInputQuestion[];
+        approvalOptions: AgentInteractionOption[];
+        response: AgentInteractionResponse | null;
+    };
+} | {
+    type: "context_compaction";
+    trigger: "auto" | "manual" | null;
+    error: string | null;
+} | {
+    type: "notice";
+    level: "info" | "warning" | "error";
+    text: string;
+});
+export interface AgentItemBase {
+    id: string;
+    turnId: string;
+    providerItemId: string | null;
+    sequence: number;
+    status: AgentItemStatus;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface AgentHistory {
+    session: AgentSession;
+    turns: Array<{
+        turn: AgentTurn;
+        items: AgentItem[];
+    }>;
+}
+export interface AgentHistoryUpdate {
+    session: AgentSession;
+    turns: AgentTurn[];
+    items: AgentItem[];
+}
+export interface AgentTurnInput {
+    outputSchema: unknown | null;
+    text: string;
+    attachments: AgentAttachment[];
+}
+export interface CreateAgentSessionInput extends Partial<AgentSessionConfig> {
+    workspaceRoot: string;
+    provider: AgentProviderId;
+    model: string | null;
+}

package/dist/plugins/agent/types.js

@@ -0,0 +1,13 @@
+export const AGENT_PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+export function isAgentProviderId(value) {
+    return typeof value === "string" && AGENT_PROVIDER_ID_PATTERN.test(value);
+}
+export const AGENT_PERMISSION_MODES = [
+    "read-only",
+    "workspace-write",
+    "danger-full-access",
+];
+export function isAgentPermissionMode(value) {
+    return (typeof value === "string" &&
+        AGENT_PERMISSION_MODES.some((mode) => mode === value));
+}

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

@@ -1,4 +1,4 @@
 import type { InternalPlugin } from "#plugins/types";
 import { CloudController } from "./controller.js";
-export declare const CloudService: import("#plugins/types").ServiceToken<CloudController>;
+export declare const CloudServiceToken: import("#app/service-registry").ServiceToken<CloudController>;
 export declare function createCloudPlugin(): InternalPlugin;

package/dist/plugins/cloud/plugin.js

@@ -1,13 +1,13 @@
-import { createServiceToken } from "#plugins/types";
+import { createServiceToken } from "#app/service-registry";
 import { CloudController } from "./controller.js";
-export const CloudService = createServiceToken("cloud");
+export const CloudServiceToken = createServiceToken("cloud");
 export function createCloudPlugin() {
     let controller = null;
     return {
         id: "cloud",
         async activate(context) {
             controller = await CloudController.create(context.config, context.logs, context.externalAccess);
-            context.services.provide(CloudService, controller);
+            context.services.provide(CloudServiceToken, controller);
         },
         async deactivate() {
             await controller?.stop();

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

@@ -395,14 +395,13 @@ function publicHost(lease, service) {
     return new URL(baseUrl).host;
 }
 function allowedPath(service, value) {
-    const pathname = new URL(value, "http://localhost").pathname;
+    const pathname = new URL(value, "http://localhost").pathname.toLowerCase();
+    const mcpPath = pathname === "/mcp" || pathname.startsWith("/mcp/");
+    const oauthPath = pathname.startsWith("/oauth/") ||
+        pathname.startsWith("/.well-known/oauth-");
     if (service === "mcp")
-        return (pathname === "/mcp" ||
-            pathname.startsWith("/.well-known/oauth-") ||
-            pathname.startsWith("/oauth/"));
-    return (pathname !== "/mcp" &&
-        !pathname.startsWith("/oauth/") &&
-        !pathname.startsWith("/.well-known/oauth-"));
+        return mcpPath || oauthPath;
+    return !mcpPath && !oauthPath;
 }
 function sanitizeHeaders(headers) {
     const blocked = new Set([

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

@@ -5,9 +5,17 @@ export class NativeComputerBackend {
     host = new ComputerNativeHost();
     restartWhenGranted = new Set();
     async status() {
-        const value = await this.readStatus().catch(() => ({
+        const value = await this.readStatus().catch((error) => ({
             platform: this.host.platform,
             helper: "unavailable",
+            ...(error instanceof ChatRoomError &&
+                error.code === "UNSUPPORTED" &&
+                error.details &&
+                typeof error.details === "object" &&
+                "reason" in error.details &&
+                error.details.reason === "no_x11_session"
+                ? { unavailableReason: "no_x11_session" }
+                : {}),
             permissions: {
                 accessibility: "unknown",
                 screenRecording: "unknown",

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

@@ -62,8 +62,17 @@ export class ComputerNativeHost {
             const child = this.child;
             if (!child || child.killed || child.stdin.destroyed)
                 this.rejectRequest(id, transportError);
-            else
-                child.stdin.write(line);
+            else {
+                try {
+                    child.stdin.write(line, (error) => {
+                        if (error)
+                            this.failTransport(child, error);
+                    });
+                }
+                catch (error) {
+                    this.failTransport(child, error instanceof Error ? error : new Error(String(error)));
+                }
+            }
         }
         return promise;
     }
@@ -104,8 +113,12 @@ export class ComputerNativeHost {
                 return this.startMacHelper(generation);
             case "windows":
                 return this.startPipeHelper(windowsHelperPath(), "Windows", process.env, generation);
-            case "linux":
-                return this.startPipeHelper(linuxHelperPath(), "Linux X11", linuxDesktopEnvironment(), generation);
+            case "linux": {
+                const env = linuxDesktopEnvironment();
+                if (!env.DISPLAY)
+                    return Promise.reject(new ChatRoomError("UNSUPPORTED", "Linux Computer Use requires an active X11 graphical session", { reason: "no_x11_session" }));
+                return this.startPipeHelper(linuxHelperPath(), "Linux X11", env, generation);
+            }
             case "unsupported":
                 return Promise.reject(new ChatRoomError("UNSUPPORTED", "Computer Use is supported only on macOS, Windows, and Linux X11"));
         }
@@ -182,6 +195,7 @@ export class ComputerNativeHost {
             env,
         });
         this.child = child;
+        child.stdin.on("error", (error) => this.failTransport(child, error));
         this.lines = createInterface({ input: child.stdout });
         this.lines.on("line", (line) => this.handleLine(line));
         child.stderr.on("data", (chunk) => console.error("[computer-helper]", String(chunk).trimEnd()));
@@ -204,8 +218,10 @@ export class ComputerNativeHost {
         cancelStarting?.(error);
         if (isCurrentSocket)
             this.socket = null;
-        if (isCurrentChild)
+        if (isCurrentChild) {
+            this.child?.kill();
             this.child = null;
+        }
         this.lines?.close();
         this.lines = null;
         this.cleanupSocketPath();

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

@@ -1,9 +1,9 @@
 import { z } from "zod";
 export declare const computerNativeStatusSchema: z.ZodObject<{
     platform: z.ZodEnum<{
+        linux: "linux";
         macos: "macos";
         windows: "windows";
-        linux: "linux";
         unsupported: "unsupported";
     }>;
     helper: z.ZodEnum<{
@@ -13,15 +13,15 @@ export declare const computerNativeStatusSchema: z.ZodObject<{
     }>;
     permissions: z.ZodObject<{
         accessibility: z.ZodEnum<{
+            unknown: "unknown";
             granted: "granted";
             denied: "denied";
-            unknown: "unknown";
             "not-required": "not-required";
         }>;
         screenRecording: z.ZodEnum<{
+            unknown: "unknown";
             granted: "granted";
             denied: "denied";
-            unknown: "unknown";
             "not-required": "not-required";
         }>;
     }, z.core.$strip>;
@@ -72,6 +72,8 @@ export declare const computerSnapshotSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const computerSnapshotMetadataSchema: z.ZodObject<{
+    snapshotId: z.ZodString;
+    revision: z.ZodNumber;
     display: z.ZodNullable<z.ZodObject<{
         id: z.ZodString;
         name: z.ZodString;
@@ -80,8 +82,6 @@ export declare const computerSnapshotMetadataSchema: z.ZodObject<{
         scale: z.ZodNumber;
         primary: z.ZodBoolean;
     }, z.core.$strip>>;
-    snapshotId: z.ZodString;
-    revision: z.ZodNumber;
     activeApp: z.ZodNullable<z.ZodString>;
     activeWindow: z.ZodNullable<z.ZodString>;
     cursor: z.ZodNullable<z.ZodObject<{
@@ -234,6 +234,8 @@ export declare const computerActionMetadataSchema: z.ZodObject<{
     }>;
     focusChanged: z.ZodBoolean;
     snapshot: z.ZodOptional<z.ZodObject<{
+        snapshotId: z.ZodString;
+        revision: z.ZodNumber;
         display: z.ZodNullable<z.ZodObject<{
             id: z.ZodString;
             name: z.ZodString;
@@ -242,8 +244,6 @@ export declare const computerActionMetadataSchema: z.ZodObject<{
             scale: z.ZodNumber;
             primary: z.ZodBoolean;
         }, z.core.$strip>>;
-        snapshotId: z.ZodString;
-        revision: z.ZodNumber;
         activeApp: z.ZodNullable<z.ZodString>;
         activeWindow: z.ZodNullable<z.ZodString>;
         cursor: z.ZodNullable<z.ZodObject<{

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

@@ -10,17 +10,20 @@ export declare class ComputerService {
     private currentSnapshotId;
     private latestSnapshotValue;
     private latestSnapshotCapturedAt;
+    private readonly recentScreenshots;
     private queue;
     constructor(backend: ComputerBackend, settingsRepository: ComputerSettingsStore, events: RuntimeEventBus);
     settings(): ComputerSettings;
     latestSnapshot(scope: ComputerAccessScope): ComputerSnapshot | null;
     latestSnapshotTimestamp(): string | null;
+    screenshot(scope: ComputerAccessScope, snapshotId: string): NonNullable<ComputerSnapshot["screenshot"]> | null;
     requestPermission(permission: ComputerPermission): Promise<ComputerStatus>;
     status(): Promise<ComputerStatus>;
     setSettings(patch: Partial<Pick<ComputerSettings, "enabled" | "remoteAccess">>): ComputerSettings;
     snapshot(scope: ComputerAccessScope, request: ComputerSnapshotRequest): Promise<ComputerSnapshot>;
     action(scope: ComputerAccessScope, request: ComputerActionRequest): Promise<ComputerActionResult>;
     shutdown(): Promise<void>;
+    private rememberScreenshot;
     private assertActionBudget;
     private assertAllowed;
     private assertScopeAllowed;

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

@@ -8,6 +8,7 @@ export class ComputerService {
     currentSnapshotId = null;
     latestSnapshotValue = null;
     latestSnapshotCapturedAt = null;
+    recentScreenshots = new Map();
     queue = Promise.resolve();
     constructor(backend, settingsRepository, events) {
         this.backend = backend;
@@ -27,6 +28,13 @@ export class ComputerService {
     latestSnapshotTimestamp() {
         return this.latestSnapshotValue ? this.latestSnapshotCapturedAt : null;
     }
+    screenshot(scope, snapshotId) {
+        const settings = this.settings();
+        if (!settings.enabled)
+            return null;
+        this.assertScopeAllowed(scope, settings);
+        return this.recentScreenshots.get(snapshotId) ?? null;
+    }
     requestPermission(permission) {
         return this.serial(async () => {
             const base = await this.backend.requestPermission(permission);
@@ -43,9 +51,10 @@ export class ComputerService {
             this.currentSnapshotId = null;
             this.latestSnapshotValue = null;
             this.latestSnapshotCapturedAt = null;
+            this.recentScreenshots.clear();
             void this.backend.dispose().catch(() => undefined);
         }
-        this.events.emit({ type: "computer-settings", settings: next });
+        this.events.emit({ type: "computer-settings" });
         return next;
     }
     snapshot(scope, request) {
@@ -58,6 +67,11 @@ export class ComputerService {
             value.revision = this.revision;
             this.latestSnapshotValue = value;
             this.latestSnapshotCapturedAt = new Date().toISOString();
+            this.rememberScreenshot(value);
+            this.events.emit({
+                type: "computer-snapshot",
+                snapshotId: value.snapshotId,
+            });
             return value;
         });
     }
@@ -76,6 +90,11 @@ export class ComputerService {
             if (result.snapshot) {
                 this.latestSnapshotValue = result.snapshot;
                 this.latestSnapshotCapturedAt = new Date().toISOString();
+                this.rememberScreenshot(result.snapshot);
+                this.events.emit({
+                    type: "computer-snapshot",
+                    snapshotId: result.snapshot.snapshotId,
+                });
             }
             return result;
         });
@@ -84,8 +103,21 @@ export class ComputerService {
         this.currentSnapshotId = null;
         this.latestSnapshotValue = null;
         this.latestSnapshotCapturedAt = null;
+        this.recentScreenshots.clear();
         await this.backend.dispose();
     }
+    rememberScreenshot(snapshot) {
+        if (!snapshot.screenshot)
+            return;
+        this.recentScreenshots.delete(snapshot.snapshotId);
+        this.recentScreenshots.set(snapshot.snapshotId, snapshot.screenshot);
+        while (this.recentScreenshots.size > 2) {
+            const oldest = this.recentScreenshots.keys().next().value;
+            if (typeof oldest !== "string")
+                break;
+            this.recentScreenshots.delete(oldest);
+        }
+    }
     assertActionBudget(request) {
         const durationMs = request.actions.reduce((total, action) => {
             if (action.type === "wait")

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

@@ -1,4 +1,4 @@
 import type { InternalPlugin } from "#plugins/types";
 import { ComputerService } from "./computer-service.js";
-export declare const ComputerServiceToken: import("#plugins/types").ServiceToken<ComputerService>;
+export declare const ComputerServiceToken: import("#app/service-registry").ServiceToken<ComputerService>;
 export declare function createComputerPlugin(): InternalPlugin;

package/dist/plugins/computer/plugin.js

@@ -1,4 +1,4 @@
-import { createServiceToken } from "#plugins/types";
+import { createServiceToken } from "#app/service-registry";
 import { NativeComputerBackend } from "./computer-native-backend.js";
 import { ComputerService } from "./computer-service.js";
 import { ComputerSettingsRepository } from "./computer-settings-repository.js";

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

@@ -23,6 +23,7 @@ export interface ComputerDisplay {
 export interface ComputerStatus {
     platform: ComputerPlatform;
     helper: ComputerHelperState;
+    unavailableReason?: "no_x11_session";
     permissions: ComputerPermissions;
     displays: ComputerDisplay[];
     settings: ComputerSettings;

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

@@ -1,9 +1,10 @@
 import type { CommandRunner } from "#core/runtime/command-runner";
-import type { GitBranch, GitCommit, GitDiff, GitStatus } from "./types.js";
-export declare class GitService {
+import type { GitAccess, GitBranch, GitCommit, GitDiff, GitStatus } from "#app/git-access";
+export declare class GitService implements GitAccess {
     private readonly commands;
     constructor(commands: CommandRunner);
     status(cwd: string): Promise<GitStatus | null>;
+    projectFiles(cwd: string, maxFiles?: number): Promise<string[] | null>;
     diff(cwd: string, filePath?: string, maxPreviewBytes?: number): Promise<GitDiff>;
     stage(cwd: string, paths: string[]): Promise<GitStatus>;
     unstage(cwd: string, paths: string[]): Promise<GitStatus>;