@zhanguym/chatroom 1.0.0

package/dist/plugins/computer/computer-settings-repository.js

@@ -0,0 +1,41 @@
+export class ComputerSettingsRepository {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    get() {
+        const row = this.database.raw
+            .prepare("SELECT enabled, remote_access, updated_at FROM computer_settings WHERE id = 1")
+            .get();
+        if (row)
+            return fromRow(row);
+        const value = {
+            enabled: false,
+            remoteAccess: true,
+            updatedAt: new Date().toISOString(),
+        };
+        this.set(value);
+        return value;
+    }
+    set(value) {
+        const updatedAt = new Date().toISOString();
+        this.database.raw
+            .prepare(`
+      INSERT INTO computer_settings(id, enabled, remote_access, updated_at)
+      VALUES(1, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        enabled = excluded.enabled,
+        remote_access = excluded.remote_access,
+        updated_at = excluded.updated_at
+    `)
+            .run(value.enabled ? 1 : 0, value.remoteAccess ? 1 : 0, updatedAt);
+        return { ...value, updatedAt };
+    }
+}
+function fromRow(row) {
+    return {
+        enabled: Boolean(row.enabled),
+        remoteAccess: Boolean(row.remote_access),
+        updatedAt: String(row.updated_at),
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { PluginMcpRegistrar } from "#mcp/server/plugin-mcp-registrar";
+import type { ComputerService } from "./computer-service.js";
+export declare function registerComputerTools(mcp: PluginMcpRegistrar, service: ComputerService): void;

package/dist/plugins/computer/mcp.js

@@ -0,0 +1,126 @@
+import { z } from "zod";
+import { closedRead, openWorldMutation } from "#mcp/server/tool-support";
+import { currentMcpAccessScope } from "#mcp/server/request-context";
+import { auditActionOutput, auditComputerActions, auditSnapshotOutput, } from "./audit.js";
+import { computerActionMetadataSchema, computerActionSchema, computerSnapshotMetadataSchema, computerSnapshotTargetSchema, } from "./computer-schemas.js";
+export function registerComputerTools(mcp, service) {
+    mcp.registerTool("computer_snapshot", {
+        title: "Observe computer",
+        description: "Observe the current desktop using a screenshot and compact accessibility elements. Element IDs are valid only for the returned snapshotId.",
+        inputSchema: z.object({
+            target: computerSnapshotTargetSchema.optional(),
+            includeScreenshot: z.boolean().default(true),
+            includeElements: z.boolean().default(true),
+        }),
+        outputSchema: computerSnapshotMetadataSchema,
+        annotations: closedRead,
+        action: "snapshot",
+        audit: {
+            output: (value) => auditSnapshotOutput(value),
+        },
+        present: presentSnapshot,
+    }, (input) => service.snapshot(currentMcpAccessScope(), {
+        includeScreenshot: input.includeScreenshot,
+        includeElements: input.includeElements,
+        ...(input.target === undefined
+            ? {}
+            : { target: normalizeSnapshotTarget(input.target) }),
+    }));
+    mcp.registerTool("computer_action", {
+        title: "Control computer",
+        description: "Execute a bounded batch of semantic or coordinate desktop actions. Prefer elementId from the latest snapshot; elementId actions require that snapshotId.",
+        inputSchema: z.object({
+            snapshotId: z.string().optional(),
+            actions: z.array(computerActionSchema).min(1).max(50),
+            observeAfter: z.boolean().default(true),
+        }),
+        outputSchema: computerActionMetadataSchema,
+        annotations: openWorldMutation,
+        action: "action",
+        audit: {
+            input: (value) => auditComputerActions(value),
+            output: (value) => auditActionOutput(value),
+        },
+        present: presentAction,
+    }, (input) => service.action(currentMcpAccessScope(), {
+        actions: input.actions,
+        observeAfter: input.observeAfter,
+        ...(input.snapshotId === undefined
+            ? {}
+            : { snapshotId: input.snapshotId }),
+    }));
+}
+function presentSnapshot(value) {
+    const snapshot = value;
+    const { screenshot, ...metadata } = snapshot;
+    return {
+        content: [
+            { type: "text", text: JSON.stringify(metadata, null, 2) },
+            ...(screenshot
+                ? [
+                    {
+                        type: "image",
+                        data: screenshot.data,
+                        mimeType: screenshot.mimeType,
+                    },
+                ]
+                : []),
+        ],
+        structuredContent: metadata,
+    };
+}
+function presentAction(value) {
+    const result = value;
+    const screenshot = result.snapshot?.screenshot;
+    const snapshot = result.snapshot
+        ? (({ screenshot: _screenshot, ...metadata }) => metadata)(result.snapshot)
+        : undefined;
+    const safe = {
+        success: result.success,
+        revision: result.revision,
+        executionMode: result.executionMode,
+        focusChanged: result.focusChanged,
+        ...(snapshot === undefined ? {} : { snapshot }),
+    };
+    return {
+        content: [
+            { type: "text", text: JSON.stringify(safe, null, 2) },
+            ...(screenshot
+                ? [
+                    {
+                        type: "image",
+                        data: screenshot.data,
+                        mimeType: screenshot.mimeType,
+                    },
+                ]
+                : []),
+        ],
+        structuredContent: safe,
+    };
+}
+function normalizeSnapshotTarget(input) {
+    switch (input.type) {
+        case "desktop":
+            return { type: "desktop" };
+        case "display":
+            return input.displayId === undefined
+                ? { type: "display" }
+                : { type: "display", displayId: input.displayId };
+        case "app":
+            return { type: "app", app: input.app };
+        case "window":
+            return { type: "window", elementId: input.elementId };
+        case "region": {
+            const region = {
+                type: "region",
+                x: input.x,
+                y: input.y,
+                width: input.width,
+                height: input.height,
+            };
+            return input.displayId === undefined
+                ? region
+                : { ...region, displayId: input.displayId };
+        }
+    }
+}

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

@@ -0,0 +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 function createComputerPlugin(): InternalPlugin;

package/dist/plugins/computer/plugin.js

@@ -0,0 +1,29 @@
+import { createServiceToken } from "#plugins/types";
+import { NativeComputerBackend } from "./computer-native-backend.js";
+import { ComputerService } from "./computer-service.js";
+import { ComputerSettingsRepository } from "./computer-settings-repository.js";
+import { registerComputerTools } from "./mcp.js";
+import { currentMcpAccessScope } from "#mcp/server/request-context";
+export const ComputerServiceToken = createServiceToken("computer");
+export function createComputerPlugin() {
+    let service = null;
+    return {
+        id: "computer",
+        activate(context) {
+            service = new ComputerService(new NativeComputerBackend(), new ComputerSettingsRepository(context.database), context.events);
+            context.services.provide(ComputerServiceToken, service);
+        },
+        registerMcp(mcp) {
+            if (!service)
+                throw new Error("Computer plugin is not active");
+            if (currentMcpAccessScope() === "remote" &&
+                !service.settings().remoteAccess)
+                return;
+            registerComputerTools(mcp, service);
+        },
+        async deactivate() {
+            await service?.shutdown();
+            service = null;
+        },
+    };
+}

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

@@ -0,0 +1,174 @@
+export type ComputerAccessScope = "local" | "remote";
+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";
+export interface ComputerSettings {
+    enabled: boolean;
+    remoteAccess: boolean;
+    updatedAt: string;
+}
+export interface ComputerPermissions {
+    accessibility: ComputerPermissionState;
+    screenRecording: ComputerPermissionState;
+}
+export interface ComputerDisplay {
+    id: string;
+    name: string;
+    width: number;
+    height: number;
+    scale: number;
+    primary: boolean;
+}
+export interface ComputerStatus {
+    platform: ComputerPlatform;
+    helper: ComputerHelperState;
+    permissions: ComputerPermissions;
+    displays: ComputerDisplay[];
+    settings: ComputerSettings;
+}
+export interface ComputerElement {
+    id: number;
+    role: string;
+    name: string | null;
+    value: string | null;
+    enabled: boolean;
+    focused: boolean;
+    selected: boolean;
+    sensitive: boolean;
+    bounds: [number, number, number, number] | null;
+    actions: string[];
+}
+export type ComputerSnapshotTarget = {
+    type: "desktop";
+} | {
+    type: "display";
+    displayId?: string;
+} | {
+    type: "app";
+    app: string;
+} | {
+    type: "window";
+    elementId: number;
+} | {
+    type: "region";
+    displayId?: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export interface ComputerSnapshotRequest {
+    target?: ComputerSnapshotTarget;
+    includeScreenshot: boolean;
+    includeElements: boolean;
+}
+export interface ComputerSnapshot {
+    snapshotId: string;
+    revision: number;
+    display: ComputerDisplay | null;
+    activeApp: string | null;
+    activeWindow: string | null;
+    cursor: {
+        x: number;
+        y: number;
+    } | null;
+    elements: ComputerElement[];
+    screenshot?: {
+        mimeType: "image/jpeg" | "image/png";
+        data: string;
+    };
+}
+export type ComputerAction = {
+    type: "move";
+    x: number;
+    y: number;
+} | {
+    type: "click";
+    x?: number;
+    y?: number;
+    elementId?: number;
+} | {
+    type: "double_click";
+    x?: number;
+    y?: number;
+    elementId?: number;
+} | {
+    type: "right_click";
+    x?: number;
+    y?: number;
+    elementId?: number;
+} | {
+    type: "drag";
+    from: {
+        x: number;
+        y: number;
+    };
+    to: {
+        x: number;
+        y: number;
+    };
+    durationMs?: number;
+} | {
+    type: "scroll";
+    deltaX?: number;
+    deltaY: number;
+    elementId?: number;
+} | {
+    type: "keypress";
+    keys: string[];
+} | {
+    type: "type_text";
+    text: string;
+    elementId?: number;
+} | {
+    type: "invoke";
+    elementId: number;
+} | {
+    type: "set_value";
+    elementId: number;
+    value: string;
+} | {
+    type: "select_text";
+    elementId: number;
+    start: number;
+    length: number;
+} | {
+    type: "activate_app";
+    app: string;
+} | {
+    type: "activate_window";
+    elementId: number;
+} | {
+    type: "move_window";
+    elementId: number;
+    x: number;
+    y: number;
+} | {
+    type: "resize_window";
+    elementId: number;
+    width: number;
+    height: number;
+} | {
+    type: "wait";
+    ms: number;
+};
+export interface ComputerActionRequest {
+    snapshotId?: string;
+    actions: ComputerAction[];
+    observeAfter: boolean;
+}
+export interface ComputerActionResult {
+    success: true;
+    revision: number;
+    snapshot?: ComputerSnapshot;
+    executionMode: "semantic" | "background" | "foreground" | "mixed";
+    focusChanged: boolean;
+}
+export interface ComputerBackend {
+    status(): Promise<Omit<ComputerStatus, "settings">>;
+    requestPermission(permission: ComputerPermission): Promise<Omit<ComputerStatus, "settings">>;
+    snapshot(request: ComputerSnapshotRequest, revision: number): Promise<ComputerSnapshot>;
+    action(request: ComputerActionRequest, revision: number): Promise<ComputerActionResult>;
+    dispose(): Promise<void>;
+}

package/dist/plugins/computer/types.js

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

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

@@ -0,0 +1,30 @@
+import type { CommandRunner } from "#core/runtime/command-runner";
+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 relatedPaths;
+    private pathExistsInHead;
+    private validateBranchName;
+    private withSnapshotIndex;
+}