@zhanguym/chatroom 1.0.0 → 1.1.0-beta.1

package/dist/app/application.d.ts

@@ -10,7 +10,6 @@ export interface ApplicationComponents {
     eventBus: RuntimeEventBus;
     operations: OperationLog;
     plugins: PluginManager;
-    application: import("#plugins/web/runtime").WebRuntime;
     processes: import("#plugins/process/process-supervisor").ProcessSupervisor;
     cloud: import("#plugins/cloud/controller").CloudController;
     computer: import("#plugins/computer/computer-service").ComputerService;

package/dist/app/application.js

@@ -9,13 +9,14 @@ import { OperationLog } from "#operations/operation-log";
 import { AuthService } from "#auth/auth-service";
 import { PasskeyService } from "#auth/passkey-service";
 import { ExternalAccessRegistry } from "./external-access-registry.js";
-import { ServiceRegistry } from "#plugins/types";
+import { ServiceRegistry } from "#app/service-registry";
 import { PluginManager } from "#plugins/plugin-manager";
 import { createWorkspacePlugin } from "#plugins/workspace/plugin";
 import { createGitPlugin } from "#plugins/git/plugin";
-import { createProcessPlugin, ProcessService } from "#plugins/process/plugin";
-import { createCloudPlugin, CloudService } from "#plugins/cloud/plugin";
+import { createProcessPlugin, ProcessServiceToken, } from "#plugins/process/plugin";
+import { createCloudPlugin, CloudServiceToken } from "#plugins/cloud/plugin";
 import { createComputerPlugin, ComputerServiceToken, } from "#plugins/computer/plugin";
+import { createAgentPlugin } from "#plugins/agent/plugin";
 import { createWebPlugin, WebServiceToken } from "#plugins/web/plugin";
 import { createChatRoomMcpHandler } from "#mcp/server/create-mcp-server";
 import { McpToolControl } from "#mcp/server/tool-control";
@@ -41,17 +42,18 @@ export async function createApplication(config, logs) {
             services,
             logs,
         }, [
-            createWorkspacePlugin(),
             createGitPlugin(),
+            createWorkspacePlugin(),
             createProcessPlugin(),
             createComputerPlugin(),
             createCloudPlugin(),
+            createAgentPlugin(),
             createWebPlugin(),
         ]);
         await plugins.start();
         const web = services.require(WebServiceToken);
-        const processes = services.require(ProcessService);
-        const cloud = services.require(CloudService);
+        const processes = services.require(ProcessServiceToken);
+        const cloud = services.require(CloudServiceToken);
         const computer = services.require(ComputerServiceToken);
         const mcp = createChatRoomMcpHandler(plugins);
         const http = new HttpServer(config, web.application, eventBus, auth, passkeys, mcp, externalAccess, cloud, logs);
@@ -60,7 +62,6 @@ export async function createApplication(config, logs) {
             eventBus,
             operations,
             plugins,
-            application: web.application,
             processes,
             cloud,
             computer,

package/dist/app/event-bus.d.ts

@@ -1,22 +1,25 @@
-import type { Operation } from "#core/operations/types";
-import type { ProcessSnapshot } from "#plugins/process/types";
-import type { ComputerSettings } from "#plugins/computer/types";
 export type RuntimeEvent = {
     type: "operation";
-    operation: Operation;
+    operationId: string;
+    pluginId: string;
 } | {
     type: "operations-cleared";
-    deleted: number;
-    preserved: number;
 } | {
     type: "process";
-    process: ProcessSnapshot;
+    processId: string;
+    output?: boolean;
+    deleted?: boolean;
 } | {
     type: "computer-settings";
-    settings: ComputerSettings;
 } | {
-    type: "process-output";
-    processId: string;
+    type: "computer-snapshot";
+    snapshotId: string;
+} | {
+    type: "agent";
+    sessionId: string;
+    turnIds?: string[];
+    itemIds?: string[];
+    deleted?: boolean;
 };
 export declare class RuntimeEventBus {
     private readonly emitter;

package/dist/app/external-access-registry.d.ts

@@ -10,6 +10,7 @@ export declare class ExternalAccessRegistry {
     constructor(config: ChatRoomConfig["auth"]);
     setCloud(state: ExternalAccessState): void;
     clearCloud(): void;
+    publicWebBaseUrl(): string | null;
     baseUrlForHost(kind: ExternalAccessKind, hostname: string): string | null;
     matches(kind: ExternalAccessKind, hostname: string): boolean;
     hasHost(hostname: string): boolean;

package/dist/app/external-access-registry.js

@@ -13,6 +13,9 @@ export class ExternalAccessRegistry {
     clearCloud() {
         this.cloud = { mcpBaseUrl: null, webBaseUrl: null };
     }
+    publicWebBaseUrl() {
+        return this.cloud.webBaseUrl ?? this.selfHosted.webBaseUrl;
+    }
     baseUrlForHost(kind, hostname) {
         for (const url of this.urls(kind))
             if (new URL(url).hostname === hostname)

package/dist/app/git-access.d.ts

@@ -0,0 +1,50 @@
+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;
+}
+export interface GitAccess {
+    projectFiles(cwd: string, maxFiles?: number): Promise<string[] | null>;
+    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>;
+}
+export declare const GitAccessToken: import("#app/service-registry").ServiceToken<GitAccess>;

package/dist/app/git-access.js

@@ -0,0 +1,2 @@
+import { createServiceToken } from "#app/service-registry";
+export const GitAccessToken = createServiceToken("git-access");

package/dist/app/service-registry.d.ts

@@ -0,0 +1,11 @@
+export interface ServiceToken<T> {
+    readonly key: symbol;
+    readonly name: string;
+    readonly __type?: T;
+}
+export declare function createServiceToken<T>(name: string): ServiceToken<T>;
+export declare class ServiceRegistry {
+    private readonly values;
+    provide<T>(token: ServiceToken<T>, value: T): void;
+    require<T>(token: ServiceToken<T>): T;
+}

package/dist/app/service-registry.js

@@ -0,0 +1,17 @@
+export function createServiceToken(name) {
+    return { key: Symbol(name), name };
+}
+export class ServiceRegistry {
+    values = new Map();
+    provide(token, value) {
+        if (this.values.has(token.key))
+            throw new Error(`Service already provided: ${token.name}`);
+        this.values.set(token.key, value);
+    }
+    require(token) {
+        const value = this.values.get(token.key);
+        if (value === undefined)
+            throw new Error(`Required service unavailable: ${token.name}`);
+        return value;
+    }
+}

package/dist/app/workspace-access.d.ts

@@ -0,0 +1,24 @@
+export interface WorkspaceEntry {
+    root: string;
+    name: string;
+    summary: string | null;
+}
+export interface WorkspaceSkill {
+    name: string;
+    description: string;
+    path: string;
+}
+export interface WorkspaceInfo extends WorkspaceEntry {
+    presetPrompt: string | null;
+    instructions: string | null;
+    skills: WorkspaceSkill[];
+}
+export interface WorkspaceAccess {
+    roots(): string[];
+    list(): Promise<WorkspaceEntry[]>;
+    resolve(input: string): Promise<string>;
+    createProject(parentInput: string, nameInput: string): Promise<WorkspaceEntry>;
+    projectFiles(input: string, maxFiles?: number): Promise<string[]>;
+    info(input: string): Promise<WorkspaceInfo>;
+}
+export declare const WorkspaceAccessToken: import("#app/service-registry").ServiceToken<WorkspaceAccess>;

package/dist/app/workspace-access.js

@@ -0,0 +1,2 @@
+import { createServiceToken } from "#app/service-registry";
+export const WorkspaceAccessToken = createServiceToken("workspace-access");

package/dist/auth/ingress-policy.d.ts

@@ -13,8 +13,10 @@ export declare class IngressPolicy {
     allowsHost(hostname: string): boolean;
     requiresWebAuth(req: Request): boolean;
     isExternalWeb(req: Request): boolean;
+    isRemoteWeb(req: Request): boolean;
     requiresMcpAuth(req: Request): boolean;
     isExternalMcp(req: Request): boolean;
+    isRemoteMcp(req: Request): boolean;
     secureWebCookie(req: Request): boolean;
     expectedWebOrigin(req: Request): string | null;
     webAuthnOrigin(req: Request): WebAuthnOrigin | null;

package/dist/auth/ingress-policy.js

@@ -14,19 +14,25 @@ export class IngressPolicy {
         return (this.staticHosts.has(hostname) || this.externalAccess.hasHost(hostname));
     }
     requiresWebAuth(req) {
-        if (this.isExternalWeb(req))
+        if (this.isRemoteWeb(req))
             return true;
         return this.config.auth.localWebAuth;
     }
     isExternalWeb(req) {
         return this.externalAccess.matches("web", req.hostname);
     }
+    isRemoteWeb(req) {
+        return this.externalAccess.hasHost(req.hostname) || !isLoopbackPeer(req);
+    }
     requiresMcpAuth(req) {
-        return this.isExternalMcp(req);
+        return this.isRemoteMcp(req);
     }
     isExternalMcp(req) {
         return this.externalAccess.matches("mcp", req.hostname);
     }
+    isRemoteMcp(req) {
+        return this.externalAccess.hasHost(req.hostname) || !isLoopbackPeer(req);
+    }
     secureWebCookie(req) {
         const base = this.externalBaseUrl(req, "web");
         if (!base)
@@ -59,3 +65,9 @@ export class IngressPolicy {
         return this.externalAccess.baseUrlForHost(kind, req.hostname);
     }
 }
+function isLoopbackPeer(req) {
+    const address = req.socket.remoteAddress;
+    return (address === "::1" ||
+        address?.startsWith("127.") === true ||
+        address?.startsWith("::ffff:127.") === true);
+}

package/dist/auth/passkey-service.js

@@ -140,6 +140,6 @@ export class PasskeyService {
 }
 function requireOrigin(origin) {
     if (!origin)
-        throw new ChatRoomError("UNSUPPORTED", "Passkeys require a secure public WebUI origin");
+        throw new ChatRoomError("UNSUPPORTED", "Passkeys require a secure public Web UI origin");
     return origin;
 }

package/dist/cli/run-cli.js

@@ -13,7 +13,7 @@ async function init() {
     console.log(`ChatRoom initialized: ${result.configPath}`);
     console.log(`Allowed roots: ${result.config.allowedRoots.join(", ")}`);
     console.log(`Owner token: ${result.config.auth.ownerToken}`);
-    console.log("Local loopback WebUI does not require authentication by default. Keep the owner token private for public access.");
+    console.log("Local loopback Web UI does not require authentication by default. Keep the owner token private for public access.");
 }
 async function serve() {
     const config = await loadConfig();

package/dist/core/fs/safe-directory.d.ts

@@ -0,0 +1,9 @@
+export declare function normalizeRelativePath(input: string): string;
+export declare function resolveReadableWithin(root: string, relativePath: string): Promise<string>;
+export declare function resolveReadableFileWithin(root: string, relativePath: string): Promise<{
+    absolute: string;
+    relative: string;
+}>;
+export declare function resolveWritableWithin(root: string, relativePath: string): Promise<string>;
+export declare function writeBytesAtomicWithin(root: string, relativePath: string, content: Uint8Array, mode?: number): Promise<void>;
+export declare function removeFileWithin(root: string, relativePath: string): Promise<void>;

package/dist/core/fs/safe-directory.js

@@ -0,0 +1,129 @@
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, realpath, rename, rm, stat, writeFile, } from "node:fs/promises";
+import path from "node:path";
+import { ChatRoomError } from "#core/errors/chatroom-error";
+export function normalizeRelativePath(input) {
+    if (typeof input !== "string" || input.includes("\0"))
+        throw new ChatRoomError("INVALID_INPUT", "Path must be a valid string");
+    if (path.isAbsolute(input) ||
+        path.win32.isAbsolute(input) ||
+        /^\\\\/.test(input))
+        throw new ChatRoomError("FORBIDDEN", "Absolute paths are not allowed");
+    const parts = input
+        .split(/[\\/]+/)
+        .filter((part) => part !== "" && part !== ".");
+    if (parts.some((part) => part === ".."))
+        throw new ChatRoomError("FORBIDDEN", "Path traversal is not allowed");
+    return parts.join("/") || ".";
+}
+export async function resolveReadableWithin(root, relativePath) {
+    const lexical = lexicalWithin(root, relativePath);
+    const canonical = await realpath(lexical).catch((error) => {
+        if (error.code === "ENOENT")
+            throw new ChatRoomError("NOT_FOUND", `Path does not exist: ${relativePath}`);
+        throw error;
+    });
+    if (!inside(root, canonical))
+        throw new ChatRoomError("FORBIDDEN", "Symlink escapes root directory");
+    return canonical;
+}
+export async function resolveReadableFileWithin(root, relativePath) {
+    const absolute = await resolveReadableWithin(root, relativePath);
+    if (!(await stat(absolute)).isFile())
+        throw new ChatRoomError("INVALID_INPUT", `Not a file: ${relativePath}`);
+    return {
+        absolute,
+        relative: path.relative(root, absolute).split(path.sep).join("/"),
+    };
+}
+export async function resolveWritableWithin(root, relativePath) {
+    const target = lexicalWithin(root, relativePath);
+    const relative = path.relative(root, target);
+    const parts = relative.split(path.sep).filter(Boolean);
+    let current = root;
+    for (let index = 0; index < parts.length - 1; index++) {
+        current = path.join(current, parts[index]);
+        let info;
+        try {
+            info = await lstat(current);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            try {
+                await mkdir(current, { recursive: false, mode: 0o700 });
+            }
+            catch (mkdirError) {
+                if (mkdirError.code !== "EEXIST")
+                    throw mkdirError;
+            }
+            info = await lstat(current);
+        }
+        if (info.isSymbolicLink())
+            throw new ChatRoomError("FORBIDDEN", `Writes through symlinked directories are not allowed: ${relativePath}`);
+        if (!info.isDirectory())
+            throw new ChatRoomError("INVALID_INPUT", `Parent is not a directory: ${parts[index]}`);
+        const canonical = await realpath(current);
+        if (!inside(root, canonical))
+            throw new ChatRoomError("FORBIDDEN", "Write path escapes root directory");
+    }
+    try {
+        const targetInfo = await lstat(target);
+        if (targetInfo.isSymbolicLink())
+            throw new ChatRoomError("FORBIDDEN", `Writes through symlinks are not allowed: ${relativePath}`);
+        if (!targetInfo.isFile())
+            throw new ChatRoomError("INVALID_INPUT", `Not a file: ${relativePath}`);
+    }
+    catch (error) {
+        if (error instanceof ChatRoomError)
+            throw error;
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    return target;
+}
+export async function writeBytesAtomicWithin(root, relativePath, content, mode = 0o600) {
+    const target = await resolveWritableWithin(root, relativePath);
+    const temporary = `${target}.chatroom-${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, content, { flag: "wx", mode });
+        await rename(temporary, target);
+    }
+    finally {
+        await rm(temporary, { force: true }).catch(() => undefined);
+    }
+}
+export async function removeFileWithin(root, relativePath) {
+    const target = lexicalWithin(root, relativePath);
+    const relative = path.relative(root, target);
+    const parts = relative.split(path.sep).filter(Boolean);
+    let current = root;
+    for (let index = 0; index < parts.length - 1; index++) {
+        current = path.join(current, parts[index]);
+        const info = await lstat(current);
+        if (info.isSymbolicLink())
+            throw new ChatRoomError("FORBIDDEN", `Removal through symlinked directories is not allowed: ${relativePath}`);
+        if (!info.isDirectory())
+            throw new ChatRoomError("INVALID_INPUT", `Parent is not a directory: ${parts[index]}`);
+        if (!inside(root, await realpath(current)))
+            throw new ChatRoomError("FORBIDDEN", "Removal path escapes root directory");
+    }
+    const info = await lstat(target);
+    if (!info.isFile() && !info.isSymbolicLink())
+        throw new ChatRoomError("INVALID_INPUT", `Not a file: ${relativePath}`);
+    await rm(target, { force: true });
+}
+function lexicalWithin(root, relativePath) {
+    const normalized = normalizeRelativePath(relativePath);
+    const absolute = path.resolve(root, ...normalized.split("/"));
+    if (!inside(root, absolute))
+        throw new ChatRoomError("FORBIDDEN", "Path escapes root directory");
+    return absolute;
+}
+function inside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return (relative === "" ||
+        (!relative.startsWith(`..${path.sep}`) &&
+            relative !== ".." &&
+            !path.isAbsolute(relative)));
+}

package/dist/core/operations/repository.d.ts

@@ -2,6 +2,8 @@ import type { Operation, OperationStatus } from "./types.js";
 export interface OperationQuery {
     limit?: number;
     offset?: number;
+    beforeStartedAt?: string;
+    beforeOperationId?: string;
     pluginId?: string;
     status?: OperationStatus | string;
 }

package/dist/core/runtime/line-process.d.ts

@@ -0,0 +1,19 @@
+export interface LineProcessOptions {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    onStdout(line: string): void;
+    onStderr(line: string): void;
+    onExit(code: number | null, signal: NodeJS.Signals | null): void;
+    onError(error: Error): void;
+}
+export declare class LineProcess {
+    private readonly child;
+    constructor(options: LineProcessOptions);
+    spawned(): Promise<void>;
+    writeLine(line: string): void;
+    terminate(): void;
+    forceKill(): void;
+    waitForExit(timeoutMs: number): Promise<void>;
+}

package/dist/core/runtime/line-process.js

@@ -0,0 +1,51 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { childEnvironment } from "./child-environment.js";
+export class LineProcess {
+    child;
+    constructor(options) {
+        this.child = spawn(options.command, options.args ?? [], {
+            ...(options.cwd ? { cwd: options.cwd } : {}),
+            env: childEnvironment(options.env),
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        createInterface({ input: this.child.stdout }).on("line", options.onStdout);
+        createInterface({ input: this.child.stderr }).on("line", options.onStderr);
+        this.child.once("exit", options.onExit);
+        this.child.once("error", options.onError);
+    }
+    async spawned() {
+        if (this.child.pid)
+            return;
+        await new Promise((resolve, reject) => {
+            this.child.once("spawn", resolve);
+            this.child.once("error", reject);
+        });
+    }
+    writeLine(line) {
+        if (!this.child.stdin.writable)
+            throw new Error("Child process stdin is not writable");
+        this.child.stdin.write(line + "\n");
+    }
+    terminate() {
+        if (this.child.exitCode === null)
+            this.child.kill("SIGTERM");
+    }
+    forceKill() {
+        if (this.child.exitCode === null)
+            this.child.kill("SIGKILL");
+    }
+    async waitForExit(timeoutMs) {
+        if (this.child.exitCode !== null)
+            return;
+        await new Promise((resolve) => {
+            const timer = setTimeout(resolve, timeoutMs);
+            timer.unref();
+            this.child.once("exit", () => {
+                clearTimeout(timer);
+                resolve();
+            });
+        });
+    }
+}

package/dist/infrastructure/database/operation-repository.js

@@ -42,11 +42,17 @@ export class OperationRepository {
             where.push("status=?");
             args.push(query.status);
         }
+        if (query.beforeStartedAt && query.beforeOperationId) {
+            where.push("(started_at < ? OR (started_at = ? AND operation_id < ?))");
+            args.push(query.beforeStartedAt, query.beforeStartedAt, query.beforeOperationId);
+        }
         const limit = Math.min(Math.max(query.limit ?? 100, 1), 500);
-        const offset = Math.max(query.offset ?? 0, 0);
+        const offset = query.beforeStartedAt && query.beforeOperationId
+            ? 0
+            : Math.max(query.offset ?? 0, 0);
         const filter = where.length ? `WHERE ${where.join(" AND ")}` : "";
         return this.database.raw
-            .prepare(`SELECT * FROM operations ${filter} ORDER BY started_at DESC LIMIT ? OFFSET ?`)
+            .prepare(`SELECT * FROM operations ${filter} ORDER BY started_at DESC, operation_id DESC LIMIT ? OFFSET ?`)
             .all(...args, limit, offset).map(fromRow);
     }
     reconcileRunning(finishedAt) {

package/dist/infrastructure/database/schema.d.ts

@@ -1 +1 @@
-export declare const DATABASE_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS operations (\n    operation_id TEXT PRIMARY KEY,\n    plugin_id TEXT NOT NULL,\n    source TEXT NOT NULL,\n    action TEXT NOT NULL,\n    status TEXT NOT NULL,\n    process_id TEXT,\n    input_json TEXT NOT NULL,\n    output_json TEXT NOT NULL,\n    error_json TEXT NOT NULL,\n    input_truncated INTEGER NOT NULL DEFAULT 0,\n    output_truncated INTEGER NOT NULL DEFAULT 0,\n    started_at TEXT NOT NULL,\n    finished_at TEXT,\n    duration_ms INTEGER\n  );\n  CREATE INDEX IF NOT EXISTS operations_started_idx ON operations(started_at DESC);\n  CREATE INDEX IF NOT EXISTS operations_plugin_idx ON operations(plugin_id, started_at DESC);\n  CREATE INDEX IF NOT EXISTS operations_status_idx ON operations(status, started_at DESC);\n\n  CREATE TABLE IF NOT EXISTS oauth_clients (\n    client_id TEXT PRIMARY KEY,\n    name TEXT NOT NULL,\n    redirect_uris_json TEXT NOT NULL,\n    created_at TEXT NOT NULL\n  );\n  CREATE TABLE IF NOT EXISTS oauth_codes (\n    code_hash TEXT PRIMARY KEY,\n    client_id TEXT NOT NULL REFERENCES oauth_clients(client_id) ON DELETE CASCADE,\n    redirect_uri TEXT NOT NULL,\n    code_challenge TEXT NOT NULL,\n    scope TEXT NOT NULL,\n    expires_at TEXT NOT NULL,\n    used_at TEXT\n  );\n  CREATE INDEX IF NOT EXISTS oauth_code_expiry_idx ON oauth_codes(expires_at);\n  CREATE TABLE IF NOT EXISTS oauth_tokens (\n    token_hash TEXT PRIMARY KEY,\n    client_id TEXT NOT NULL REFERENCES oauth_clients(client_id) ON DELETE CASCADE,\n    scope TEXT NOT NULL,\n    expires_at TEXT NOT NULL,\n    revoked_at TEXT,\n    created_at TEXT NOT NULL\n  );\n  CREATE INDEX IF NOT EXISTS oauth_token_expiry_idx ON oauth_tokens(expires_at);\n  CREATE TABLE IF NOT EXISTS oauth_refresh_tokens (\n    token_hash TEXT PRIMARY KEY,\n    client_id TEXT NOT NULL REFERENCES oauth_clients(client_id) ON DELETE CASCADE,\n    scope TEXT NOT NULL,\n    expires_at TEXT NOT NULL,\n    revoked_at TEXT,\n    created_at TEXT NOT NULL\n  );\n  CREATE INDEX IF NOT EXISTS oauth_refresh_expiry_idx ON oauth_refresh_tokens(expires_at);\n\n  CREATE TABLE IF NOT EXISTS web_sessions (\n    token_hash TEXT PRIMARY KEY,\n    expires_at TEXT NOT NULL,\n    created_at TEXT NOT NULL\n  );\n  CREATE INDEX IF NOT EXISTS web_session_expiry_idx ON web_sessions(expires_at);\n\n  CREATE TABLE IF NOT EXISTS passkeys (\n    credential_id TEXT PRIMARY KEY,\n    public_key BLOB NOT NULL,\n    counter INTEGER NOT NULL,\n    transports_json TEXT NOT NULL,\n    device_type TEXT NOT NULL CHECK(device_type IN ('singleDevice','multiDevice')),\n    backed_up INTEGER NOT NULL,\n    name TEXT NOT NULL,\n    created_at TEXT NOT NULL,\n    last_used_at TEXT NOT NULL\n  );\n  CREATE INDEX IF NOT EXISTS passkeys_last_used_idx ON passkeys(last_used_at DESC);\n\n  CREATE TABLE IF NOT EXISTS computer_settings (\n    id INTEGER PRIMARY KEY CHECK(id = 1),\n    enabled INTEGER NOT NULL DEFAULT 0,\n    remote_access INTEGER NOT NULL DEFAULT 1,\n    updated_at TEXT NOT NULL\n  );\n\n  CREATE TABLE IF NOT EXISTS mcp_tool_settings (\n    tool_name TEXT PRIMARY KEY,\n    enabled INTEGER NOT NULL CHECK(enabled IN (0, 1)),\n    updated_at TEXT NOT NULL\n  );\n\n";
+export declare const DATABASE_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS operations (\n    operation_id TEXT PRIMARY KEY,\n    plugin_id TEXT NOT NULL,\n    source TEXT NOT NULL,\n    action TEXT NOT NULL,\n    status TEXT NOT NULL,\n    process_id TEXT,\n    input_json TEXT NOT NULL,\n    output_json TEXT NOT NULL,\n    error_json TEXT NOT NULL,\n    input_truncated INTEGER NOT NULL DEFAULT 0,\n    output_truncated INTEGER NOT NULL DEFAULT 0,\n    started_at TEXT NOT NULL,\n    finished_at TEXT,\n    duration_ms INTEGER\n  );\n  CREATE INDEX IF NOT EXISTS operations_started_idx ON operations(started_at DESC);\n  CREATE INDEX IF NOT EXISTS operations_plugin_idx ON operations(plugin_id, started_at DESC);\n  CREATE INDEX IF NOT EXISTS operations_status_idx ON operations(status, started_at DESC);\n\n  CREATE TABLE IF NOT EXISTS oauth_clients (\n    client_id TEXT PRIMARY KEY,\n    name TEXT NOT NULL,\n    redirect_uris_json TEXT NOT NULL,\n    created_at TEXT NOT NULL\n  );\n  CREATE TABLE IF NOT EXISTS oauth_codes (\n    code_hash TEXT PRIMARY KEY,\n    client_id TEXT NOT NULL REFERENCES oauth_clients(client_id) ON DELETE CASCADE,\n    redirect_uri TEXT NOT NULL,\n    code_challenge TEXT NOT NULL,\n    scope TEXT NOT NULL,\n    expires_at TEXT NOT NULL,\n    used_at TEXT\n  );\n  CREATE INDEX IF NOT EXISTS oauth_code_expiry_idx ON oauth_codes(expires_at);\n  CREATE TABLE IF NOT EXISTS oauth_tokens (\n    token_hash TEXT PRIMARY KEY,\n    client_id TEXT NOT NULL REFERENCES oauth_clients(client_id) ON DELETE CASCADE,\n    scope TEXT NOT NULL,\n    expires_at TEXT NOT NULL,\n    revoked_at TEXT,\n    created_at TEXT NOT NULL\n  );\n  CREATE INDEX IF NOT EXISTS oauth_token_expiry_idx ON oauth_tokens(expires_at);\n  CREATE TABLE IF NOT EXISTS oauth_refresh_tokens (\n    token_hash TEXT PRIMARY KEY,\n    client_id TEXT NOT NULL REFERENCES oauth_clients(client_id) ON DELETE CASCADE,\n    scope TEXT NOT NULL,\n    expires_at TEXT NOT NULL,\n    revoked_at TEXT,\n    created_at TEXT NOT NULL\n  );\n  CREATE INDEX IF NOT EXISTS oauth_refresh_expiry_idx ON oauth_refresh_tokens(expires_at);\n\n  CREATE TABLE IF NOT EXISTS web_sessions (\n    token_hash TEXT PRIMARY KEY,\n    expires_at TEXT NOT NULL,\n    created_at TEXT NOT NULL\n  );\n  CREATE INDEX IF NOT EXISTS web_session_expiry_idx ON web_sessions(expires_at);\n\n  CREATE TABLE IF NOT EXISTS passkeys (\n    credential_id TEXT PRIMARY KEY,\n    public_key BLOB NOT NULL,\n    counter INTEGER NOT NULL,\n    transports_json TEXT NOT NULL,\n    device_type TEXT NOT NULL CHECK(device_type IN ('singleDevice','multiDevice')),\n    backed_up INTEGER NOT NULL,\n    name TEXT NOT NULL,\n    created_at TEXT NOT NULL,\n    last_used_at TEXT NOT NULL\n  );\n  CREATE INDEX IF NOT EXISTS passkeys_last_used_idx ON passkeys(last_used_at DESC);\n\n  CREATE TABLE IF NOT EXISTS computer_settings (\n    id INTEGER PRIMARY KEY CHECK(id = 1),\n    enabled INTEGER NOT NULL DEFAULT 0,\n    remote_access INTEGER NOT NULL DEFAULT 1,\n    updated_at TEXT NOT NULL\n  );\n\n  CREATE TABLE IF NOT EXISTS mcp_tool_settings (\n    tool_name TEXT PRIMARY KEY,\n    enabled INTEGER NOT NULL CHECK(enabled IN (0, 1)),\n    updated_at TEXT NOT NULL\n  );\n\n  CREATE TABLE IF NOT EXISTS agent_sessions (\n    id TEXT PRIMARY KEY,\n    workspace_root TEXT NOT NULL,\n    provider TEXT NOT NULL,\n    status TEXT NOT NULL CHECK(status IN ('idle','running','waiting_input','error')),\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL\n  );\n  CREATE INDEX IF NOT EXISTS agent_sessions_updated_idx ON agent_sessions(updated_at DESC);\n\n  CREATE TABLE IF NOT EXISTS agent_turns (\n    id TEXT PRIMARY KEY,\n    session_id TEXT NOT NULL REFERENCES agent_sessions(id) ON DELETE CASCADE,\n    provider_turn_id TEXT,\n    provider TEXT NOT NULL,\n    model TEXT,\n    reasoning_effort TEXT,\n    reasoning_summary TEXT CHECK(reasoning_summary IN ('auto','concise','detailed','none')),\n    service_tier TEXT,\n    approval_policy_json TEXT,\n    approvals_reviewer TEXT CHECK(approvals_reviewer IN ('user','auto_review','guardian_subagent')),\n    permission_mode TEXT CHECK(permission_mode IN ('default','acceptEdits','bypassPermissions','plan','dontAsk','auto','read-only','workspace-write','danger-full-access')),\n    usage_json TEXT,\n    origin INTEGER NOT NULL CHECK(origin IN (0,1)),\n    status TEXT NOT NULL CHECK(status IN ('running','completed','interrupted','failed')),\n    error_json TEXT NOT NULL,\n    started_at TEXT NOT NULL,\n    completed_at TEXT\n  );\n  CREATE INDEX IF NOT EXISTS agent_turns_session_idx ON agent_turns(session_id, started_at ASC);\n\n  CREATE TABLE IF NOT EXISTS agent_items (\n    id TEXT PRIMARY KEY,\n    turn_id TEXT NOT NULL REFERENCES agent_turns(id) ON DELETE CASCADE,\n    provider_item_id TEXT,\n    type TEXT NOT NULL,\n    sequence INTEGER NOT NULL,\n    status TEXT NOT NULL CHECK(status IN ('running','completed','waiting','interrupted','failed')),\n    payload_json TEXT NOT NULL,\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL\n  );\n  CREATE INDEX IF NOT EXISTS agent_items_turn_idx ON agent_items(turn_id, sequence ASC);\n\n  CREATE TABLE IF NOT EXISTS agent_session_providers (\n    session_id TEXT NOT NULL REFERENCES agent_sessions(id) ON DELETE CASCADE,\n    provider TEXT NOT NULL,\n    provider_session_id TEXT NOT NULL,\n    model TEXT,\n    reasoning_effort TEXT,\n    reasoning_summary TEXT CHECK(reasoning_summary IN ('auto','concise','detailed','none')),\n    service_tier TEXT,\n    approval_policy_json TEXT,\n    approvals_reviewer TEXT CHECK(approvals_reviewer IN ('user','auto_review','guardian_subagent')),\n    permission_mode TEXT CHECK(permission_mode IN ('default','acceptEdits','bypassPermissions','plan','dontAsk','auto','read-only','workspace-write','danger-full-access')),\n    token_usage_json TEXT,\n    continuity_context TEXT NOT NULL DEFAULT '',\n    synced_through_turn_id TEXT REFERENCES agent_turns(id) ON DELETE SET NULL,\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL,\n    PRIMARY KEY(session_id, provider)\n  );\n";

package/dist/infrastructure/database/schema.js

@@ -87,4 +87,66 @@ export const DATABASE_SCHEMA = `
     updated_at TEXT NOT NULL
   );
 
+  CREATE TABLE IF NOT EXISTS agent_sessions (
+    id TEXT PRIMARY KEY,
+    workspace_root TEXT NOT NULL,
+    provider TEXT NOT NULL,
+    status TEXT NOT NULL CHECK(status IN ('idle','running','waiting_input','error')),
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS agent_sessions_updated_idx ON agent_sessions(updated_at DESC);
+
+  CREATE TABLE IF NOT EXISTS agent_turns (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL REFERENCES agent_sessions(id) ON DELETE CASCADE,
+    provider_turn_id TEXT,
+    provider TEXT NOT NULL,
+    model TEXT,
+    reasoning_effort TEXT,
+    reasoning_summary TEXT CHECK(reasoning_summary IN ('auto','concise','detailed','none')),
+    service_tier TEXT,
+    approval_policy_json TEXT,
+    approvals_reviewer TEXT CHECK(approvals_reviewer IN ('user','auto_review','guardian_subagent')),
+    permission_mode TEXT CHECK(permission_mode IN ('default','acceptEdits','bypassPermissions','plan','dontAsk','auto','read-only','workspace-write','danger-full-access')),
+    usage_json TEXT,
+    origin INTEGER NOT NULL CHECK(origin IN (0,1)),
+    status TEXT NOT NULL CHECK(status IN ('running','completed','interrupted','failed')),
+    error_json TEXT NOT NULL,
+    started_at TEXT NOT NULL,
+    completed_at TEXT
+  );
+  CREATE INDEX IF NOT EXISTS agent_turns_session_idx ON agent_turns(session_id, started_at ASC);
+
+  CREATE TABLE IF NOT EXISTS agent_items (
+    id TEXT PRIMARY KEY,
+    turn_id TEXT NOT NULL REFERENCES agent_turns(id) ON DELETE CASCADE,
+    provider_item_id TEXT,
+    type TEXT NOT NULL,
+    sequence INTEGER NOT NULL,
+    status TEXT NOT NULL CHECK(status IN ('running','completed','waiting','interrupted','failed')),
+    payload_json TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS agent_items_turn_idx ON agent_items(turn_id, sequence ASC);
+
+  CREATE TABLE IF NOT EXISTS agent_session_providers (
+    session_id TEXT NOT NULL REFERENCES agent_sessions(id) ON DELETE CASCADE,
+    provider TEXT NOT NULL,
+    provider_session_id TEXT NOT NULL,
+    model TEXT,
+    reasoning_effort TEXT,
+    reasoning_summary TEXT CHECK(reasoning_summary IN ('auto','concise','detailed','none')),
+    service_tier TEXT,
+    approval_policy_json TEXT,
+    approvals_reviewer TEXT CHECK(approvals_reviewer IN ('user','auto_review','guardian_subagent')),
+    permission_mode TEXT CHECK(permission_mode IN ('default','acceptEdits','bypassPermissions','plan','dontAsk','auto','read-only','workspace-write','danger-full-access')),
+    token_usage_json TEXT,
+    continuity_context TEXT NOT NULL DEFAULT '',
+    synced_through_turn_id TEXT REFERENCES agent_turns(id) ON DELETE SET NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY(session_id, provider)
+  );
 `;

package/dist/infrastructure/http/http-server.js

@@ -65,7 +65,7 @@ export class HttpServer {
             this.mcpRequestCount += 1;
             next();
         }, mcpAuthentication(this.auth, this.ingress), (req, res) => {
-            const scope = this.ingress.isExternalMcp(req) ? "remote" : "local";
+            const scope = this.ingress.isRemoteMcp(req) ? "remote" : "local";
             runWithMcpAccessScope(scope, () => {
                 void nodeMcp(req, res, req.body);
             });