@chatroomcp/chatroom 0.1.3

package/dist/config/load-config.js

@@ -0,0 +1,182 @@
+import { randomBytes } from "node:crypto";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { z } from "zod";
+import { ChatRoomError } from "../core/errors/chatroom-error.js";
+import { platformPaths } from "./platform-paths.js";
+function rawConfigSchema() {
+    const defaults = defaultConfig();
+    return z
+        .object({
+        allowedRoots: z
+            .array(z.string().min(1))
+            .min(1)
+            .default(defaults.allowedRoots),
+        dataDir: z.string().min(1).default(defaults.dataDir),
+        databasePath: z.string().min(1).optional(),
+        server: z
+            .object({
+            host: z.string().min(1).default(defaults.server.host),
+            port: z
+                .number()
+                .int()
+                .min(1)
+                .max(65535)
+                .default(defaults.server.port),
+        })
+            .strict()
+            .default(defaults.server),
+        auth: z
+            .object({
+            localWebAuth: z.boolean().default(defaults.auth.localWebAuth),
+            ownerToken: z
+                .string()
+                .min(1)
+                .nullable()
+                .default(defaults.auth.ownerToken),
+            mcpPublicBaseUrl: z
+                .string()
+                .url()
+                .nullable()
+                .default(defaults.auth.mcpPublicBaseUrl),
+            webPublicBaseUrl: z
+                .string()
+                .url()
+                .nullable()
+                .default(defaults.auth.webPublicBaseUrl),
+            allowedRedirectHosts: z
+                .array(z.string().min(1))
+                .default(defaults.auth.allowedRedirectHosts),
+        })
+            .strict()
+            .default(defaults.auth),
+        operations: z
+            .object({
+            maxPayloadBytes: z
+                .number()
+                .int()
+                .min(4096)
+                .max(16 * 1024 * 1024)
+                .default(defaults.operations.maxPayloadBytes),
+        })
+            .strict()
+            .default(defaults.operations),
+        process: z
+            .object({
+            maxOutputBytes: z
+                .number()
+                .int()
+                .min(4096)
+                .max(64 * 1024 * 1024)
+                .default(defaults.process.maxOutputBytes),
+            defaultTimeoutMs: z
+                .number()
+                .int()
+                .min(1000)
+                .max(24 * 60 * 60 * 1000)
+                .default(defaults.process.defaultTimeoutMs),
+            maxCompletedProcesses: z
+                .number()
+                .int()
+                .min(0)
+                .max(10_000)
+                .default(defaults.process.maxCompletedProcesses),
+        })
+            .strict()
+            .default(defaults.process),
+    })
+        .strict();
+}
+function defaultConfigPath() {
+    return process.env.CHATROOM_CONFIG ?? platformPaths().configFile;
+}
+export function defaultConfig() {
+    const paths = platformPaths();
+    return {
+        allowedRoots: [path.join(os.homedir(), "Projects")],
+        dataDir: paths.dataDir,
+        databasePath: paths.databaseFile,
+        server: { host: "127.0.0.1", port: 8765 },
+        auth: {
+            localWebAuth: false,
+            ownerToken: null,
+            mcpPublicBaseUrl: null,
+            webPublicBaseUrl: null,
+            allowedRedirectHosts: ["chatgpt.com", "localhost", "127.0.0.1"],
+        },
+        operations: { maxPayloadBytes: 512 * 1024 },
+        process: {
+            maxOutputBytes: 512 * 1024,
+            defaultTimeoutMs: 30 * 60 * 1000,
+            maxCompletedProcesses: 200,
+        },
+    };
+}
+export async function loadConfig(configPath = defaultConfigPath()) {
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(configPath, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            throw new ChatRoomError("NOT_FOUND", `ChatRoom is not initialized: ${configPath}`);
+        throw new ChatRoomError("INVALID_INPUT", `Cannot read config: ${configPath}`, undefined, {
+            cause: error,
+        });
+    }
+    const config = validateConfig(parsed);
+    validateRuntimeSecurity(config);
+    return config;
+}
+export async function initializeConfig() {
+    const configPath = defaultConfigPath();
+    try {
+        await readFile(configPath, "utf8");
+        throw new ChatRoomError("CONFLICT", `Config already exists: ${configPath}`);
+    }
+    catch (error) {
+        if (error instanceof ChatRoomError)
+            throw error;
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const config = defaultConfig();
+    await mkdir(config.allowedRoots[0], { recursive: true, mode: 0o700 });
+    config.auth.ownerToken = randomBytes(32).toString("base64url");
+    await mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+    await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, {
+        mode: 0o600,
+    });
+    await chmod(configPath, 0o600).catch(() => undefined);
+    return { config, configPath };
+}
+function validateConfig(value) {
+    const result = rawConfigSchema().safeParse(value);
+    if (!result.success)
+        throw new ChatRoomError("INVALID_INPUT", "Invalid ChatRoom configuration", {
+            issues: result.error.issues.map((issue) => ({
+                path: issue.path.join("."),
+                message: issue.message,
+            })),
+        });
+    const dataDir = path.resolve(result.data.dataDir);
+    return {
+        ...result.data,
+        allowedRoots: result.data.allowedRoots.map((root) => path.resolve(root)),
+        dataDir,
+        databasePath: path.resolve(result.data.databasePath ?? path.join(dataDir, "chatroom.sqlite")),
+    };
+}
+function validateRuntimeSecurity(config) {
+    const loopback = config.server.host === "127.0.0.1" ||
+        config.server.host === "::1" ||
+        config.server.host === "localhost";
+    if (!loopback && !config.auth.localWebAuth)
+        throw new ChatRoomError("FORBIDDEN", "auth.localWebAuth must be enabled when ChatRoom binds beyond loopback");
+    const authenticationUsed = config.auth.localWebAuth ||
+        Boolean(config.auth.mcpPublicBaseUrl) ||
+        Boolean(config.auth.webPublicBaseUrl);
+    if (authenticationUsed && !config.auth.ownerToken)
+        throw new ChatRoomError("INVALID_INPUT", "auth.ownerToken is required when any authenticated ingress is configured");
+}

package/dist/config/platform-paths.d.ts

@@ -0,0 +1,6 @@
+export interface PlatformPaths {
+    configFile: string;
+    dataDir: string;
+    databaseFile: string;
+}
+export declare function platformPaths(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv, home?: string): PlatformPaths;

package/dist/config/platform-paths.js

@@ -0,0 +1,34 @@
+import os from "node:os";
+import path from "node:path";
+export function platformPaths(platform = process.platform, env = process.env, home = os.homedir()) {
+    if (platform === "win32") {
+        const join = path.win32.join;
+        const roaming = env.APPDATA ?? join(home, "AppData", "Roaming");
+        const local = env.LOCALAPPDATA ?? join(home, "AppData", "Local");
+        return {
+            configFile: join(roaming, "ChatRoom", "config.json"),
+            dataDir: join(local, "ChatRoom", "Data"),
+            databaseFile: join(local, "ChatRoom", "State", "chatroom.sqlite"),
+        };
+    }
+    const join = path.posix.join;
+    if (platform === "darwin") {
+        const applicationSupport = join(home, "Library", "Application Support", "ChatRoom");
+        return {
+            configFile: join(applicationSupport, "config.json"),
+            dataDir: join(applicationSupport, "Data"),
+            databaseFile: join(applicationSupport, "State", "chatroom.sqlite"),
+        };
+    }
+    const configHome = absoluteXdg(env.XDG_CONFIG_HOME) ?? join(home, ".config");
+    const dataHome = absoluteXdg(env.XDG_DATA_HOME) ?? join(home, ".local", "share");
+    const stateHome = absoluteXdg(env.XDG_STATE_HOME) ?? join(home, ".local", "state");
+    return {
+        configFile: join(configHome, "chatroom", "config.json"),
+        dataDir: join(dataHome, "chatroom"),
+        databaseFile: join(stateHome, "chatroom", "chatroom.sqlite"),
+    };
+}
+function absoluteXdg(value) {
+    return value && path.posix.isAbsolute(value) ? value : null;
+}

package/dist/config/types.d.ts

@@ -0,0 +1,25 @@
+/** Runtime configuration after defaults and path normalization have been resolved. */
+export interface ChatRoomConfig {
+    allowedRoots: string[];
+    dataDir: string;
+    databasePath: string;
+    server: {
+        host: string;
+        port: number;
+    };
+    auth: {
+        localWebAuth: boolean;
+        ownerToken: string | null;
+        mcpPublicBaseUrl: string | null;
+        webPublicBaseUrl: string | null;
+        allowedRedirectHosts: string[];
+    };
+    operations: {
+        maxPayloadBytes: number;
+    };
+    process: {
+        maxOutputBytes: number;
+        defaultTimeoutMs: number;
+        maxCompletedProcesses: number;
+    };
+}

package/dist/config/types.js

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

package/dist/core/auth/passkey-repository.d.ts

@@ -0,0 +1,18 @@
+export interface PasskeyRecord {
+    credentialId: string;
+    publicKey: Uint8Array;
+    counter: number;
+    transports: string[];
+    deviceType: "singleDevice" | "multiDevice";
+    backedUp: boolean;
+    name: string;
+    createdAt: string;
+    lastUsedAt: string;
+}
+export interface PasskeyRepository {
+    list(): PasskeyRecord[];
+    get(credentialId: string): PasskeyRecord | null;
+    upsert(record: PasskeyRecord): void;
+    remove(credentialId: string): void;
+    updateCounter(credentialId: string, counter: number): void;
+}

package/dist/core/auth/passkey-repository.js

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

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

@@ -0,0 +1,59 @@
+/**
+ * Persistence contracts for OAuth clients, authorization codes, and access tokens.
+ *
+ * Raw authorization codes and bearer tokens must never cross this boundary. AuthService hashes
+ * those credentials first and repositories store only the resulting digest values.
+ */
+/** Dynamically registered OAuth public client. */
+export interface OAuthClientRecord {
+    clientId: string;
+    name: string;
+    /** Exact redirect URI allowlist registered for the client. */
+    redirectUris: string[];
+    createdAt: string;
+}
+/** Hashed Authorization Code + PKCE state. */
+export interface OAuthCodeRecord {
+    /** SHA-256 digest of the raw one-time authorization code. */
+    codeHash: string;
+    clientId: string;
+    redirectUri: string;
+    /** S256 challenge supplied during authorization. */
+    codeChallenge: string;
+    /** Granted scopes bound to this authorization code. */
+    scope: string;
+    expiresAt: string;
+    /** Consumption timestamp, or null before the code is atomically used. */
+    usedAt: string | null;
+}
+/** Minimal active-token metadata returned after a hashed token lookup. */
+export interface OAuthTokenRecord {
+    clientId: string;
+    scope: string;
+    expiresAt: string;
+}
+/** Storage port used by AuthService for the complete OAuth state machine. */
+export interface OAuthStateRepository {
+    createClient(client: OAuthClientRecord): void;
+    getClient(clientId: string): OAuthClientRecord | null;
+    createCode(code: OAuthCodeRecord): void;
+    /** Read an unconsumed candidate without mutating it so PKCE can be validated first. */
+    getCode(codeHash: string): OAuthCodeRecord | null;
+    /** Atomically consume a valid code; null means it was missing, expired by policy, or already used. */
+    consumeCode(codeHash: string, now: string): OAuthCodeRecord | null;
+    /** Persist only a token hash together with scope and expiry metadata. */
+    createToken(tokenHash: string, clientId: string, scope: string, expiresAt: string): void;
+    /** Persist a hashed refresh token separately from access tokens. */
+    createRefreshToken(tokenHash: string, clientId: string, scope: string, expiresAt: string): void;
+    /** Atomically rotate an active refresh token. */
+    consumeRefreshToken(tokenHash: string, clientId?: string): {
+        clientId: string;
+        scope: string;
+    } | null;
+    /** Resolve active, non-revoked token metadata from a token hash. */
+    tokenInfo(tokenHash: string): OAuthTokenRecord | null;
+    /** Mark a token hash revoked without requiring the raw bearer token to be stored. */
+    revokeToken(tokenHash: string): void;
+    /** Remove expired and terminal OAuth state that no longer participates in the protocol. */
+    prune(now: string): number;
+}

package/dist/core/auth/repository.js

@@ -0,0 +1,7 @@
+/**
+ * Persistence contracts for OAuth clients, authorization codes, and access tokens.
+ *
+ * Raw authorization codes and bearer tokens must never cross this boundary. AuthService hashes
+ * those credentials first and repositories store only the resulting digest values.
+ */
+export {};

package/dist/core/auth/session-repository.d.ts

@@ -0,0 +1,6 @@
+export interface WebSessionRepository {
+    create(tokenHash: string, expiresAt: string): void;
+    valid(tokenHash: string, now: string): boolean;
+    revoke(tokenHash: string): void;
+    prune(now: string): number;
+}

package/dist/core/auth/session-repository.js

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

package/dist/core/errors/chatroom-error.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Typed error vocabulary exposed across ChatRoom application boundaries.
+ *
+ * Presentation adapters translate these stable codes into protocol responses. Domain/application
+ * code should prefer ChatRoomError over parsing message text or leaking implementation-specific
+ * filesystem, SQLite, process, or SDK errors to external callers.
+ */
+export declare const ERROR_CODES: readonly ["INVALID_INPUT", "NOT_FOUND", "FORBIDDEN", "CONFLICT", "UNSUPPORTED", "PROCESS_FAILED", "INTERNAL"];
+export type ErrorCode = (typeof ERROR_CODES)[number];
+/** Error carrying a stable machine-readable code plus optional structured diagnostic details. */
+export declare class ChatRoomError extends Error {
+    readonly code: ErrorCode;
+    readonly details?: unknown;
+    constructor(code: ErrorCode, message: string, details?: unknown, options?: ErrorOptions);
+}
+/**
+ * Normalize an arbitrary thrown value at an application or protocol boundary.
+ *
+ * Existing ChatRoomError instances retain their public code. Native Error values become INTERNAL
+ * while preserving the original error as `cause`; non-Error throws are converted as well so every
+ * external path observes the same error vocabulary.
+ */
+export declare function asChatRoomError(error: unknown): ChatRoomError;

package/dist/core/errors/chatroom-error.js

@@ -0,0 +1,46 @@
+/**
+ * Typed error vocabulary exposed across ChatRoom application boundaries.
+ *
+ * Presentation adapters translate these stable codes into protocol responses. Domain/application
+ * code should prefer ChatRoomError over parsing message text or leaking implementation-specific
+ * filesystem, SQLite, process, or SDK errors to external callers.
+ */
+export const ERROR_CODES = [
+    "INVALID_INPUT",
+    "NOT_FOUND",
+    "FORBIDDEN",
+    "CONFLICT",
+    "UNSUPPORTED",
+    "PROCESS_FAILED",
+    "INTERNAL",
+];
+/** Error carrying a stable machine-readable code plus optional structured diagnostic details. */
+export class ChatRoomError extends Error {
+    code;
+    details;
+    constructor(code, message, details, options) {
+        super(message, options);
+        this.name = "ChatRoomError";
+        this.code = code;
+        this.details = details;
+    }
+}
+/**
+ * Normalize an arbitrary thrown value at an application or protocol boundary.
+ *
+ * Existing ChatRoomError instances retain their public code. Native Error values become INTERNAL
+ * while preserving the original error as `cause`; non-Error throws are converted as well so every
+ * external path observes the same error vocabulary.
+ */
+export function asChatRoomError(error) {
+    if (error instanceof ChatRoomError)
+        return error;
+    if (error instanceof Error) {
+        return new ChatRoomError("INTERNAL", error.message, undefined, {
+            cause: error,
+        });
+    }
+    return new ChatRoomError("INTERNAL", "Unknown internal error", {
+        value: String(error),
+    });
+}

package/dist/core/operations/bounded-value.d.ts

@@ -0,0 +1,6 @@
+/** Utilities for bounding JSON-like operation payloads before persistence. */
+export interface BoundedValue<T = unknown> {
+    value: T;
+    truncated: boolean;
+}
+export declare function boundJson(value: unknown, maxBytes: number): BoundedValue;

package/dist/core/operations/bounded-value.js

@@ -0,0 +1,41 @@
+export function boundJson(value, maxBytes) {
+    // Preserve both the beginning and end of oversized strings because failures commonly appear at the tail.
+    if (value === undefined)
+        return { value: null, truncated: false };
+    const json = safeStringify(value);
+    const size = Buffer.byteLength(json);
+    if (size <= maxBytes)
+        return { value: JSON.parse(json), truncated: false };
+    const marker = "\n…[truncated]…\n";
+    const budget = Math.max(0, maxBytes - Buffer.byteLength(marker));
+    const headBudget = Math.floor(budget / 2);
+    const tailBudget = budget - headBudget;
+    const encoded = Buffer.from(json);
+    const head = encoded.subarray(0, headBudget).toString("utf8");
+    const tail = encoded.subarray(encoded.length - tailBudget).toString("utf8");
+    const text = `${head}${marker}${tail}`;
+    return {
+        value: { truncatedJson: text, originalBytes: size },
+        truncated: true,
+    };
+}
+function safeStringify(value) {
+    const seen = new WeakSet();
+    return (JSON.stringify(value, (_key, current) => {
+        if (typeof current === "bigint")
+            return current.toString();
+        if (current instanceof Error) {
+            return {
+                name: current.name,
+                message: current.message,
+                stack: current.stack,
+            };
+        }
+        if (current && typeof current === "object") {
+            if (seen.has(current))
+                return "[circular]";
+            seen.add(current);
+        }
+        return current;
+    }) ?? "null");
+}

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

@@ -0,0 +1,4 @@
+export declare class SecretRedactor {
+    redact(value: unknown): unknown;
+    private walk;
+}

package/dist/core/operations/redactor.js

@@ -0,0 +1,65 @@
+/** Redacts common credential shapes before values cross the durable operation-log boundary. */
+const SECRET_KEY = new RegExp("(^|[_-])" +
+    "(authorization|cookie|password|passwd|token|access[_-]?token|" +
+    "refresh[_-]?token|api[_-]?key|apikey|secret|private[_-]?key|" +
+    "client[_-]?secret)" +
+    "($|[_-])", "i");
+const BEARER = /\bBearer\s+[A-Za-z0-9._~+\/-]+=*/gi;
+const PEM = /-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/g;
+const INLINE_SECRET = /\b(password|passwd|token|api[_-]?key|secret|client[_-]?secret)\s*[:=]\s*([^\s,;]+)/gi;
+const CLI_SECRET = /(--(?:password|passwd|token|api-key|api_key|secret|client-secret))\s+([^\s]+)/gi;
+export class SecretRedactor {
+    redact(value) {
+        return this.walk(value, new WeakSet());
+    }
+    walk(value, seen) {
+        if (typeof value === "string") {
+            return value
+                .replace(BEARER, "Bearer [redacted]")
+                .replace(PEM, "[redacted]")
+                .replace(INLINE_SECRET, "$1=[redacted]")
+                .replace(CLI_SECRET, "$1 [redacted]");
+        }
+        if (value === null || typeof value !== "object")
+            return value;
+        if (seen.has(value))
+            return "[circular]";
+        seen.add(value);
+        if (Array.isArray(value))
+            return value.map((item) => this.walk(item, seen));
+        const result = {};
+        for (const [key, item] of Object.entries(value)) {
+            result[key] = SECRET_KEY.test(key)
+                ? "[redacted]"
+                : key === "args" && Array.isArray(item)
+                    ? redactArguments(item, (entry) => this.walk(entry, seen))
+                    : this.walk(item, seen);
+        }
+        return result;
+    }
+}
+function redactArguments(args, redactValue) {
+    const output = [];
+    let redactNext = false;
+    for (const arg of args) {
+        if (redactNext) {
+            output.push("[redacted]");
+            redactNext = false;
+            continue;
+        }
+        if (typeof arg === "string") {
+            const equals = /^(--(?:password|passwd|token|api-key|api_key|secret|client-secret))=(.*)$/i.exec(arg);
+            if (equals) {
+                output.push(`${equals[1]}=[redacted]`);
+                continue;
+            }
+            if (/^--(?:password|passwd|token|api-key|api_key|secret|client-secret)$/i.test(arg)) {
+                output.push(arg);
+                redactNext = true;
+                continue;
+            }
+        }
+        output.push(redactValue(arg));
+    }
+    return output;
+}

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

@@ -0,0 +1,19 @@
+import type { Operation, OperationStatus } from "./types.js";
+export interface OperationQuery {
+    limit?: number;
+    offset?: number;
+    pluginId?: string;
+    status?: OperationStatus | string;
+    workspaceId?: string;
+}
+export interface OperationRepository {
+    insert(operation: Operation): void;
+    update(operation: Operation): void;
+    get(operationId: string): Operation | null;
+    list(query?: OperationQuery): Operation[];
+    clearHistory(): {
+        deleted: number;
+        preserved: number;
+    };
+    reconcileRunning(finishedAt: string): number;
+}

package/dist/core/operations/repository.js

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

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

@@ -0,0 +1,31 @@
+/** Persistent plugin operation lifecycle recorded by ChatRoom. */
+export declare const OPERATION_STATUSES: readonly ["running", "success", "error", "cancelled"];
+export type OperationStatus = (typeof OPERATION_STATUSES)[number];
+/** Where an operation was initiated; pluginId identifies which plugin owns the operation. */
+export declare const OPERATION_SOURCES: readonly ["mcp", "gui", "system", "cli"];
+export type OperationSource = (typeof OPERATION_SOURCES)[number];
+export interface Operation {
+    operationId: string;
+    pluginId: string;
+    source: OperationSource;
+    action: string;
+    status: OperationStatus;
+    workspaceId: string | null;
+    processId: string | null;
+    input: unknown;
+    output: unknown;
+    error: unknown;
+    inputTruncated: boolean;
+    outputTruncated: boolean;
+    startedAt: string;
+    finishedAt: string | null;
+    durationMs: number | null;
+}
+export interface OperationStart {
+    pluginId: string;
+    source: OperationSource;
+    action: string;
+    input?: unknown;
+    workspaceId?: string | null;
+    processId?: string | null;
+}

package/dist/core/operations/types.js

@@ -0,0 +1,9 @@
+/** Persistent plugin operation lifecycle recorded by ChatRoom. */
+export const OPERATION_STATUSES = [
+    "running",
+    "success",
+    "error",
+    "cancelled",
+];
+/** Where an operation was initiated; pluginId identifies which plugin owns the operation. */
+export const OPERATION_SOURCES = ["mcp", "gui", "system", "cli"];

package/dist/core/runtime/child-environment.d.ts

@@ -0,0 +1 @@
+export declare function childEnvironment(overrides: Record<string, string> | undefined): NodeJS.ProcessEnv;

package/dist/core/runtime/child-environment.js

@@ -0,0 +1,39 @@
+const CHILD_ENV_KEYS = new Set([
+    "PATH",
+    "HOME",
+    "USER",
+    "LOGNAME",
+    "SHELL",
+    "LANG",
+    "LANGUAGE",
+    "TERM",
+    "COLORTERM",
+    "TMPDIR",
+    "TMP",
+    "TEMP",
+    "XDG_CONFIG_HOME",
+    "XDG_CACHE_HOME",
+    "XDG_DATA_HOME",
+    "XDG_STATE_HOME",
+    "XDG_RUNTIME_DIR",
+    "NVM_DIR",
+    "NVM_BIN",
+    "SystemRoot",
+    "WINDIR",
+    "ComSpec",
+    "PATHEXT",
+    "USERPROFILE",
+    "LOCALAPPDATA",
+    "APPDATA",
+]);
+export function childEnvironment(overrides) {
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value !== undefined &&
+            (CHILD_ENV_KEYS.has(key) || key.startsWith("LC_")))
+            env[key] = value;
+    }
+    for (const [key, value] of Object.entries(overrides ?? {}))
+        env[key] = value;
+    return env;
+}

package/dist/core/runtime/command-runner.d.ts

@@ -0,0 +1,15 @@
+export interface CommandRequest {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+}
+export interface CommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export declare class CommandRunner {
+    run(request: CommandRequest): Promise<CommandResult>;
+}