@zhanguym/chatroom 1.0.0

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

@@ -0,0 +1,70 @@
+import { asChatRoomError } from "#core/errors/chatroom-error";
+import { mcpTool } from "./tool-support.js";
+export class PluginMcpRegistrar {
+    server;
+    operations;
+    pluginId;
+    toolControl;
+    constructor(server, operations, pluginId, toolControl) {
+        this.server = server;
+        this.operations = operations;
+        this.pluginId = pluginId;
+        this.toolControl = toolControl;
+    }
+    registerTool(name, config, handler) {
+        this.toolControl.define({
+            name,
+            pluginId: this.pluginId,
+            title: config.title,
+            description: config.description,
+        });
+        if (!this.server)
+            return;
+        const { action, audit, present, ...toolConfig } = config;
+        const callback = mcpTool(async (input) => {
+            const operation = this.operations.start({
+                pluginId: this.pluginId,
+                source: "mcp",
+                action: typeof action === "function" ? action(input) : action,
+                input: audit?.input ? audit.input(input) : input,
+                ...operationReferences(input),
+            });
+            let deferred = false;
+            const execution = {
+                operationId: operation.operationId,
+                deferCompletion() {
+                    deferred = true;
+                },
+            };
+            try {
+                const result = await handler(input, execution);
+                if (!deferred)
+                    this.operations.finish(operation.operationId, "success", audit?.output ? audit.output(result) : result);
+                return result;
+            }
+            catch (error) {
+                if (this.operations.get(operation.operationId)?.status === "running") {
+                    const normalized = asChatRoomError(error);
+                    this.operations.finish(operation.operationId, "error", null, {
+                        code: normalized.code,
+                        message: normalized.message,
+                        details: normalized.details,
+                    });
+                }
+                throw error;
+            }
+        }, present);
+        const registered = this.server.registerTool(name, toolConfig, callback);
+        this.toolControl.attach(name, registered);
+    }
+}
+function operationReferences(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return {};
+    const record = input;
+    return {
+        ...(typeof record.processId === "string"
+            ? { processId: record.processId }
+            : {}),
+    };
+}

package/dist/mcp/server/request-context.d.ts

@@ -0,0 +1,3 @@
+import type { ComputerAccessScope } from "#plugins/computer/types";
+export declare function runWithMcpAccessScope<T>(scope: ComputerAccessScope, action: () => T): T;
+export declare function currentMcpAccessScope(): ComputerAccessScope;

package/dist/mcp/server/request-context.js

@@ -0,0 +1,8 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const storage = new AsyncLocalStorage();
+export function runWithMcpAccessScope(scope, action) {
+    return storage.run(scope, action);
+}
+export function currentMcpAccessScope() {
+    return storage.getStore() ?? "local";
+}

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

@@ -0,0 +1,31 @@
+import type { RegisteredTool } from "@modelcontextprotocol/server";
+export interface McpToolSettingStore {
+    disabledTools(): string[];
+    setEnabled(name: string, enabled: boolean): void;
+}
+export interface McpToolSummary {
+    name: string;
+    pluginId: string;
+    title: string;
+    description: string;
+    enabled: boolean;
+}
+interface McpToolDefinition {
+    name: string;
+    pluginId: string;
+    title: string;
+    description: string;
+}
+export declare class McpToolControl {
+    private readonly store;
+    private readonly disabled;
+    private readonly definitions;
+    private readonly handles;
+    constructor(store: McpToolSettingStore);
+    define(definition: McpToolDefinition): void;
+    attach(name: string, tool: RegisteredTool): void;
+    list(): McpToolSummary[];
+    setEnabled(name: string, enabled: boolean): McpToolSummary;
+    private updateHandles;
+}
+export {};

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

@@ -0,0 +1,76 @@
+import { ChatRoomError } from "#core/errors/chatroom-error";
+export class McpToolControl {
+    store;
+    disabled = new Set();
+    definitions = new Map();
+    handles = new Map();
+    constructor(store) {
+        this.store = store;
+        for (const name of store.disabledTools())
+            this.disabled.add(name);
+    }
+    define(definition) {
+        const existing = this.definitions.get(definition.name);
+        if (existing && existing.pluginId !== definition.pluginId)
+            throw new Error(`MCP tool already belongs to another plugin: ${definition.name}`);
+        this.definitions.set(definition.name, definition);
+    }
+    attach(name, tool) {
+        let tools = this.handles.get(name);
+        if (!tools) {
+            tools = new Set();
+            this.handles.set(name, tools);
+        }
+        else {
+            for (const reference of tools)
+                if (!reference.deref())
+                    tools.delete(reference);
+        }
+        tools.add(new WeakRef(tool));
+        if (this.disabled.has(name))
+            tool.disable();
+    }
+    list() {
+        return [...this.definitions.values()]
+            .map((definition) => ({
+            ...definition,
+            enabled: !this.disabled.has(definition.name),
+        }))
+            .sort((left, right) => left.pluginId.localeCompare(right.pluginId) ||
+            left.name.localeCompare(right.name));
+    }
+    setEnabled(name, enabled) {
+        const definition = this.definitions.get(name);
+        if (!definition)
+            throw new ChatRoomError("NOT_FOUND", `Unknown MCP tool: ${name}`);
+        if (enabled === !this.disabled.has(name))
+            return { ...definition, enabled };
+        this.store.setEnabled(name, enabled);
+        if (enabled)
+            this.disabled.delete(name);
+        else
+            this.disabled.add(name);
+        this.updateHandles(name, enabled);
+        return { ...definition, enabled };
+    }
+    updateHandles(name, enabled) {
+        const handles = this.handles.get(name);
+        if (!handles)
+            return;
+        for (const reference of [...handles]) {
+            const tool = reference.deref();
+            if (!tool) {
+                handles.delete(reference);
+                continue;
+            }
+            if (tool.enabled === enabled)
+                continue;
+            if (enabled)
+                tool.enable();
+            else
+                tool.disable();
+        }
+        if (!handles.size)
+            this.handles.delete(name);
+    }
+}

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

@@ -0,0 +1,44 @@
+import { type CallToolResult } from "@modelcontextprotocol/server";
+import { z } from "zod";
+export declare const closedRead: {
+    readOnlyHint: true;
+    destructiveHint: false;
+    idempotentHint: true;
+    openWorldHint: false;
+};
+export declare const destructiveLocalMutation: {
+    readOnlyHint: false;
+    destructiveHint: true;
+    idempotentHint: false;
+    openWorldHint: false;
+};
+export declare const openWorldMutation: {
+    readOnlyHint: false;
+    destructiveHint: true;
+    idempotentHint: false;
+    openWorldHint: true;
+};
+export declare const processSnapshotSchema: z.ZodObject<{
+    processId: z.ZodString;
+    command: z.ZodString;
+    args: z.ZodArray<z.ZodString>;
+    cwd: z.ZodString;
+    pid: z.ZodNullable<z.ZodNumber>;
+    state: z.ZodEnum<{
+        running: "running";
+        exited: "exited";
+        killed: "killed";
+        failed: "failed";
+    }>;
+    startedAt: z.ZodString;
+    finishedAt: z.ZodNullable<z.ZodString>;
+    durationMs: z.ZodNumber;
+    exitCode: z.ZodNullable<z.ZodNumber>;
+    signal: z.ZodNullable<z.ZodString>;
+    stdout: z.ZodString;
+    stderr: z.ZodString;
+    outputTruncated: z.ZodBoolean;
+    timedOut: z.ZodBoolean;
+    operationId: z.ZodString;
+}, z.core.$strip>;
+export declare function mcpTool<T>(operation: (input: T) => Promise<unknown> | unknown, present?: (value: unknown) => CallToolResult): (input: T) => Promise<CallToolResult>;

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

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { asChatRoomError } from "#core/errors/chatroom-error";
+export const closedRead = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+};
+export const destructiveLocalMutation = {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false,
+};
+export const openWorldMutation = {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: true,
+};
+export const processSnapshotSchema = z.object({
+    processId: z.string(),
+    command: z.string(),
+    args: z.array(z.string()),
+    cwd: z.string(),
+    pid: z.number().int().nullable(),
+    state: z.enum(["running", "exited", "killed", "failed"]),
+    startedAt: z.string(),
+    finishedAt: z.string().nullable(),
+    durationMs: z.number().nonnegative(),
+    exitCode: z.number().int().nullable(),
+    signal: z.string().nullable(),
+    stdout: z.string(),
+    stderr: z.string(),
+    outputTruncated: z.boolean(),
+    timedOut: z.boolean(),
+    operationId: z.string(),
+});
+export function mcpTool(operation, present) {
+    return async (input) => {
+        try {
+            const value = await operation(input);
+            if (present)
+                return present(value);
+            return {
+                content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
+                structuredContent: asRecord(value),
+            };
+        }
+        catch (error) {
+            const normalized = asChatRoomError(error);
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            code: normalized.code,
+                            message: normalized.message,
+                            details: normalized.details ?? null,
+                        }),
+                    },
+                ],
+            };
+        }
+    };
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : { value };
+}

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

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<key>CFBundleIdentifier</key><string>com.chatroomcp.computer</string>
+<key>CFBundleName</key><string>ChatRoom Computer Helper</string>
+<key>CFBundleDisplayName</key><string>ChatRoom Computer Helper</string>
+<key>CFBundleExecutable</key><string>chatroom-computer-helper</string>
+<key>CFBundlePackageType</key><string>APPL</string>
+<key>CFBundleVersion</key><string>1</string>
+<key>CFBundleShortVersionString</key><string>1.0</string>
+<key>LSMinimumSystemVersion</key><string>14.0</string>
+<key>LSUIElement</key><true/>
+<key>NSHumanReadableCopyright</key><string>ChatRoom</string>
+</dict></plist>

package/dist/native/macos/ChatRoomComputerHelper.app/Contents/_CodeSignature/CodeResources

@@ -0,0 +1,115 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>files</key>
+	<dict/>
+	<key>files2</key>
+	<dict/>
+	<key>rules</key>
+	<dict>
+		<key>^Resources/</key>
+		<true/>
+		<key>^Resources/.*\.lproj/</key>
+		<dict>
+			<key>optional</key>
+			<true/>
+			<key>weight</key>
+			<real>1000</real>
+		</dict>
+		<key>^Resources/.*\.lproj/locversion.plist$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>1100</real>
+		</dict>
+		<key>^Resources/Base\.lproj/</key>
+		<dict>
+			<key>weight</key>
+			<real>1010</real>
+		</dict>
+		<key>^version.plist$</key>
+		<true/>
+	</dict>
+	<key>rules2</key>
+	<dict>
+		<key>.*\.dSYM($|/)</key>
+		<dict>
+			<key>weight</key>
+			<real>11</real>
+		</dict>
+		<key>^(.*/)?\.DS_Store$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>2000</real>
+		</dict>
+		<key>^(Frameworks|SharedFrameworks|PlugIns|Plug-ins|XPCServices|Helpers|MacOS|Library/(Automator|Spotlight|LoginItems))/</key>
+		<dict>
+			<key>nested</key>
+			<true/>
+			<key>weight</key>
+			<real>10</real>
+		</dict>
+		<key>^.*</key>
+		<true/>
+		<key>^Info\.plist$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+		<key>^PkgInfo$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+		<key>^Resources/</key>
+		<dict>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+		<key>^Resources/.*\.lproj/</key>
+		<dict>
+			<key>optional</key>
+			<true/>
+			<key>weight</key>
+			<real>1000</real>
+		</dict>
+		<key>^Resources/.*\.lproj/locversion.plist$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>1100</real>
+		</dict>
+		<key>^Resources/Base\.lproj/</key>
+		<dict>
+			<key>weight</key>
+			<real>1010</real>
+		</dict>
+		<key>^[^/]+$</key>
+		<dict>
+			<key>nested</key>
+			<true/>
+			<key>weight</key>
+			<real>10</real>
+		</dict>
+		<key>^embedded\.provisionprofile$</key>
+		<dict>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+		<key>^version\.plist$</key>
+		<dict>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+	</dict>
+</dict>
+</plist>

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

@@ -0,0 +1,24 @@
+import type { Operation, OperationStart, OperationStatus } from "#core/operations/types";
+import type { OperationQuery, OperationRepository } from "#core/operations/repository";
+import type { RuntimeEventBus } from "#app/event-bus";
+export declare class OperationLog {
+    private readonly repository;
+    private readonly eventBus;
+    private readonly maxPayloadBytes;
+    private readonly redactor;
+    constructor(repository: OperationRepository, eventBus: RuntimeEventBus, maxPayloadBytes: number);
+    start(request: OperationStart): Operation;
+    finish(operationId: string, status: Exclude<OperationStatus, "running">, output?: unknown, error?: unknown): Operation;
+    run<T>(request: OperationStart, action: () => Promise<T>): Promise<T>;
+    list(query?: OperationQuery): Operation[];
+    get(operationId: string): Operation | null;
+    associate(operationId: string, references: {
+        processId?: string | null;
+    }): Operation;
+    clearHistory(): {
+        deleted: number;
+        preserved: number;
+    };
+    reconcileInterrupted(): number;
+    private require;
+}

package/dist/operations/operation-log.js

@@ -0,0 +1,98 @@
+import { randomUUID } from "node:crypto";
+import { boundJson } from "#core/operations/bounded-value";
+import { SecretRedactor } from "#core/operations/redactor";
+import { asChatRoomError, ChatRoomError } from "#core/errors/chatroom-error";
+export class OperationLog {
+    repository;
+    eventBus;
+    maxPayloadBytes;
+    redactor = new SecretRedactor();
+    constructor(repository, eventBus, maxPayloadBytes) {
+        this.repository = repository;
+        this.eventBus = eventBus;
+        this.maxPayloadBytes = maxPayloadBytes;
+    }
+    start(request) {
+        const input = boundJson(this.redactor.redact(request.input ?? null), this.maxPayloadBytes);
+        const operation = {
+            operationId: randomUUID(),
+            pluginId: request.pluginId,
+            source: request.source,
+            action: request.action,
+            status: "running",
+            processId: request.processId ?? null,
+            input: input.value,
+            output: null,
+            error: null,
+            inputTruncated: input.truncated,
+            outputTruncated: false,
+            startedAt: new Date().toISOString(),
+            finishedAt: null,
+            durationMs: null,
+        };
+        this.repository.insert(operation);
+        this.eventBus.emit({ type: "operation", operation });
+        return operation;
+    }
+    finish(operationId, status, output, error) {
+        const operation = this.require(operationId);
+        const finishedAt = new Date();
+        const bounded = boundJson(this.redactor.redact(output ?? null), this.maxPayloadBytes);
+        operation.status = status;
+        operation.output = bounded.value;
+        operation.outputTruncated = bounded.truncated;
+        operation.error = error
+            ? boundJson(this.redactor.redact(error), this.maxPayloadBytes).value
+            : null;
+        operation.finishedAt = finishedAt.toISOString();
+        operation.durationMs = Math.max(0, finishedAt.getTime() - new Date(operation.startedAt).getTime());
+        this.repository.update(operation);
+        this.eventBus.emit({ type: "operation", operation });
+        return operation;
+    }
+    async run(request, action) {
+        const operation = this.start(request);
+        try {
+            const result = await action();
+            this.finish(operation.operationId, "success", result);
+            return result;
+        }
+        catch (error) {
+            const normalized = asChatRoomError(error);
+            this.finish(operation.operationId, "error", null, {
+                code: normalized.code,
+                message: normalized.message,
+                details: normalized.details,
+            });
+            throw error;
+        }
+    }
+    list(query) {
+        return this.repository.list(query);
+    }
+    get(operationId) {
+        return this.repository.get(operationId);
+    }
+    associate(operationId, references) {
+        const operation = this.require(operationId);
+        if (references.processId !== undefined)
+            operation.processId = references.processId;
+        this.repository.update(operation);
+        this.eventBus.emit({ type: "operation", operation });
+        return operation;
+    }
+    clearHistory() {
+        const result = this.repository.clearHistory();
+        this.eventBus.emit({ type: "operations-cleared", ...result });
+        return result;
+    }
+    reconcileInterrupted() {
+        return this.repository.reconcileRunning(new Date().toISOString());
+    }
+    require(operationId) {
+        const operation = this.repository.get(operationId);
+        if (!operation)
+            throw new ChatRoomError("NOT_FOUND", `Operation not found: ${operationId}`);
+        return operation;
+    }
+}

package/dist/plugins/cloud/api-client.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { type CloudEntitlement, type CloudLeaseState, type CloudServiceId } from "./types.js";
+declare const recoveryCredentialSchema: z.ZodObject<{
+    recoveryKey: z.ZodString;
+}, z.core.$strict>;
+declare const sessionSchema: z.ZodObject<{
+    purchaseToken: z.ZodString;
+    managementUrl: z.ZodString;
+    expiresAt: z.ZodString;
+}, z.core.$strict>;
+declare const restoreSchema: z.ZodObject<{
+    entitlements: z.ZodArray<z.ZodObject<{
+        service: z.ZodEnum<{
+            remote_mcp: "remote_mcp";
+            remote_web: "remote_web";
+        }>;
+        status: z.ZodLiteral<"active">;
+        sourceProvider: z.ZodString;
+        sourceId: z.ZodString;
+        validUntil: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    customer: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strict>;
+    publicPrefix: z.ZodNullable<z.ZodString>;
+    recoveryKey: z.ZodString;
+}, z.core.$strict>;
+export declare class CloudApiClient {
+    private readonly baseUrl;
+    constructor(baseUrl: string);
+    createManagementSession(identity: DeviceIdentity): Promise<z.infer<typeof sessionSchema>>;
+    status(identity: DeviceIdentity, purchaseToken: string | null): Promise<{
+        managementSessionActive: boolean;
+        entitlements: CloudEntitlement[];
+        customer: {
+            id: string;
+        } | null;
+        publicPrefix: string | null;
+    }>;
+    restore(identity: DeviceIdentity, recoveryKey: string): Promise<z.infer<typeof restoreSchema>>;
+    replaceRecoveryKey(identity: DeviceIdentity): Promise<z.infer<typeof recoveryCredentialSchema>>;
+    lease(identity: DeviceIdentity, requestedServices: CloudServiceId[]): Promise<CloudLeaseState>;
+    private devicePost;
+}
+interface DeviceIdentity {
+    installationId: string;
+    devicePublicKey: string;
+    devicePrivateKey: string;
+}
+export {};