@vibe-forge/tsconfigs 0.7.1 → 0.8.0

package/dist/apps/server/src/services/session/runtime.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pendingSessionInteractionStore = exports.sessionSubscriberSockets = exports.externalSessionStore = exports.adapterSessionStore = void 0;
+exports.createSessionConnectionState = createSessionConnectionState;
+exports.bindAdapterSessionRuntime = bindAdapterSessionRuntime;
+exports.getAdapterSessionRuntime = getAdapterSessionRuntime;
+exports.setAdapterSessionRuntime = setAdapterSessionRuntime;
+exports.deleteAdapterSessionRuntime = deleteAdapterSessionRuntime;
+exports.getExternalSessionRuntime = getExternalSessionRuntime;
+exports.takeExternalSessionRuntime = takeExternalSessionRuntime;
+exports.ensureExternalSessionRuntime = ensureExternalSessionRuntime;
+exports.deleteExternalSessionRuntime = deleteExternalSessionRuntime;
+exports.getSessionConnectionState = getSessionConnectionState;
+exports.emitRuntimeEvent = emitRuntimeEvent;
+exports.broadcastSessionEvent = broadcastSessionEvent;
+exports.notifySessionUpdated = notifySessionUpdated;
+exports.addSessionSubscriberSocket = addSessionSubscriberSocket;
+exports.removeSessionSubscriberSocket = removeSessionSubscriberSocket;
+exports.attachSocketToSession = attachSocketToSession;
+exports.detachSocketFromSession = detachSocketFromSession;
+exports.interruptAdapterSession = interruptAdapterSession;
+exports.getPendingSessionInteraction = getPendingSessionInteraction;
+exports.setPendingSessionInteraction = setPendingSessionInteraction;
+exports.deletePendingSessionInteraction = deletePendingSessionInteraction;
+const ws_1 = require("ws");
+const json_js_1 = require("#~/utils/json.js");
+exports.adapterSessionStore = new Map();
+exports.externalSessionStore = new Map();
+exports.sessionSubscriberSockets = new Set();
+exports.pendingSessionInteractionStore = new Map();
+function createSessionConnectionState() {
+    return {
+        sockets: new Set(),
+        messages: []
+    };
+}
+function bindAdapterSessionRuntime(connectionState, session, config) {
+    return Object.assign(connectionState, { session, config });
+}
+function getAdapterSessionRuntime(sessionId) {
+    return exports.adapterSessionStore.get(sessionId);
+}
+function setAdapterSessionRuntime(sessionId, runtime) {
+    exports.adapterSessionStore.set(sessionId, runtime);
+    return runtime;
+}
+function deleteAdapterSessionRuntime(sessionId) {
+    exports.adapterSessionStore.delete(sessionId);
+}
+function getExternalSessionRuntime(sessionId) {
+    return exports.externalSessionStore.get(sessionId);
+}
+function takeExternalSessionRuntime(sessionId) {
+    const runtime = exports.externalSessionStore.get(sessionId);
+    if (runtime == null) {
+        return undefined;
+    }
+    exports.externalSessionStore.delete(sessionId);
+    return runtime;
+}
+function ensureExternalSessionRuntime(sessionId) {
+    const existing = exports.externalSessionStore.get(sessionId);
+    if (existing != null) {
+        return existing;
+    }
+    const created = createSessionConnectionState();
+    exports.externalSessionStore.set(sessionId, created);
+    return created;
+}
+function deleteExternalSessionRuntime(sessionId) {
+    exports.externalSessionStore.delete(sessionId);
+}
+function getSessionConnectionState(sessionId) {
+    return exports.adapterSessionStore.get(sessionId) ?? exports.externalSessionStore.get(sessionId);
+}
+function emitRuntimeEvent(runtime, event, options = {}) {
+    if (options.recordMessage !== false) {
+        runtime.messages.push(event);
+    }
+    const payload = (0, json_js_1.safeJsonStringify)(event);
+    for (const socket of runtime.sockets) {
+        if (socket.readyState === ws_1.WebSocket.OPEN) {
+            socket.send(payload);
+        }
+    }
+}
+function broadcastSessionEvent(sessionId, event) {
+    const adapterRuntime = exports.adapterSessionStore.get(sessionId);
+    if (adapterRuntime != null) {
+        emitRuntimeEvent(adapterRuntime, event);
+    }
+    const externalRuntime = exports.externalSessionStore.get(sessionId);
+    if (externalRuntime != null) {
+        emitRuntimeEvent(externalRuntime, event);
+    }
+}
+function notifySessionUpdated(sessionId, session) {
+    const event = { type: 'session_updated', session };
+    const payload = (0, json_js_1.safeJsonStringify)(event);
+    const runtime = getSessionConnectionState(sessionId);
+    for (const socket of runtime?.sockets ?? []) {
+        if (socket.readyState === ws_1.WebSocket.OPEN) {
+            socket.send(payload);
+        }
+    }
+    for (const socket of exports.sessionSubscriberSockets) {
+        if (socket.readyState === ws_1.WebSocket.OPEN) {
+            socket.send(payload);
+        }
+    }
+}
+function addSessionSubscriberSocket(socket) {
+    exports.sessionSubscriberSockets.add(socket);
+}
+function removeSessionSubscriberSocket(socket) {
+    exports.sessionSubscriberSockets.delete(socket);
+}
+function attachSocketToSession(sessionId, socket, mode) {
+    if (mode === 'external') {
+        const runtime = ensureExternalSessionRuntime(sessionId);
+        runtime.sockets.add(socket);
+        return runtime;
+    }
+    const runtime = exports.adapterSessionStore.get(sessionId);
+    runtime?.sockets.add(socket);
+    return runtime;
+}
+function detachSocketFromSession(sessionId, socket) {
+    const adapterRuntime = exports.adapterSessionStore.get(sessionId);
+    if (adapterRuntime != null) {
+        adapterRuntime.sockets.delete(socket);
+        return adapterRuntime;
+    }
+    const externalRuntime = exports.externalSessionStore.get(sessionId);
+    if (externalRuntime != null) {
+        externalRuntime.sockets.delete(socket);
+        if (externalRuntime.sockets.size === 0) {
+            exports.externalSessionStore.delete(sessionId);
+        }
+    }
+    return externalRuntime;
+}
+function interruptAdapterSession(sessionId) {
+    exports.adapterSessionStore.get(sessionId)?.session.emit({ type: 'interrupt' });
+}
+function getPendingSessionInteraction(interactionId) {
+    return exports.pendingSessionInteractionStore.get(interactionId);
+}
+function setPendingSessionInteraction(interactionId, interaction) {
+    exports.pendingSessionInteractionStore.set(interactionId, interaction);
+}
+function deletePendingSessionInteraction(interactionId) {
+    exports.pendingSessionInteractionStore.delete(interactionId);
+}

package/dist/apps/server/src/utils/compose.d.ts

@@ -0,0 +1,3 @@
+type Middleware<T> = (ctx: T, next: () => Promise<void>) => Promise<void>;
+export declare const compose: <T>(...middlewares: Middleware<T>[]) => (ctx: T) => Promise<void>;
+export {};

package/dist/apps/server/src/utils/compose.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compose = void 0;
+const compose = (...middlewares) => async (ctx) => {
+    let index = 0;
+    const next = async () => {
+        const fn = middlewares[index++];
+        if (fn)
+            await fn(ctx, next);
+    };
+    await next();
+};
+exports.compose = compose;

package/dist/apps/server/src/utils/http.d.ts

@@ -0,0 +1,35 @@
+export interface ApiSuccessResponse<T> {
+    success: true;
+    data: T;
+}
+export interface ApiErrorPayload {
+    code: string;
+    message: string;
+    details?: unknown;
+}
+export interface ApiErrorResponse {
+    success: false;
+    error: ApiErrorPayload;
+}
+export declare class HttpError extends Error {
+    status: number;
+    code: string;
+    details?: unknown;
+    expose: boolean;
+    constructor(status: number, code: string, message: string, details?: unknown, options?: {
+        cause?: unknown;
+        expose?: boolean;
+    });
+}
+export declare const badRequest: (message?: string, details?: unknown, code?: string) => HttpError;
+export declare const unauthorized: (message?: string, details?: unknown, code?: string) => HttpError;
+export declare const notFound: (message?: string, details?: unknown, code?: string) => HttpError;
+export declare const methodNotAllowed: (message?: string, details?: unknown, code?: string) => HttpError;
+export declare const requestTimeout: (message?: string, details?: unknown, code?: string) => HttpError;
+export declare const conflict: (message?: string, details?: unknown, code?: string) => HttpError;
+export declare const internalServerError: (message?: string, options?: {
+    code?: string;
+    details?: unknown;
+    cause?: unknown;
+}) => HttpError;
+export declare const isHttpError: (error: unknown) => error is HttpError;

package/dist/apps/server/src/utils/http.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHttpError = exports.internalServerError = exports.conflict = exports.requestTimeout = exports.methodNotAllowed = exports.notFound = exports.unauthorized = exports.badRequest = exports.HttpError = void 0;
+class HttpError extends Error {
+    status;
+    code;
+    details;
+    expose;
+    constructor(status, code, message, details, options) {
+        super(message, options?.cause !== undefined ? { cause: options.cause } : undefined);
+        this.name = 'HttpError';
+        this.status = status;
+        this.code = code;
+        this.details = details;
+        this.expose = options?.expose ?? status < 500;
+    }
+}
+exports.HttpError = HttpError;
+const defaultCodeForStatus = (status) => {
+    switch (status) {
+        case 400:
+            return 'bad_request';
+        case 401:
+            return 'unauthorized';
+        case 403:
+            return 'forbidden';
+        case 404:
+            return 'not_found';
+        case 405:
+            return 'method_not_allowed';
+        case 408:
+            return 'request_timeout';
+        case 409:
+            return 'conflict';
+        case 422:
+            return 'unprocessable_entity';
+        default:
+            return status >= 500 ? 'internal_server_error' : 'request_failed';
+    }
+};
+const createHttpError = (status, message, options) => {
+    return new HttpError(status, options?.code ?? defaultCodeForStatus(status), message, options?.details, { cause: options?.cause, expose: options?.expose });
+};
+const badRequest = (message = 'Bad Request', details, code) => createHttpError(400, message, { details, code });
+exports.badRequest = badRequest;
+const unauthorized = (message = 'Unauthorized', details, code) => createHttpError(401, message, { details, code });
+exports.unauthorized = unauthorized;
+const notFound = (message = 'Not Found', details, code) => createHttpError(404, message, { details, code });
+exports.notFound = notFound;
+const methodNotAllowed = (message = 'Method Not Allowed', details, code) => createHttpError(405, message, { details, code });
+exports.methodNotAllowed = methodNotAllowed;
+const requestTimeout = (message = 'Request Timeout', details, code) => createHttpError(408, message, { details, code });
+exports.requestTimeout = requestTimeout;
+const conflict = (message = 'Conflict', details, code) => createHttpError(409, message, { details, code });
+exports.conflict = conflict;
+const internalServerError = (message = 'Internal Server Error', options) => createHttpError(500, message, { ...options, expose: true });
+exports.internalServerError = internalServerError;
+const isHttpError = (error) => error instanceof HttpError;
+exports.isHttpError = isHttpError;

package/dist/apps/server/src/utils/json.d.ts

@@ -0,0 +1,2 @@
+export declare function toSerializable(value: unknown, seen?: WeakSet<object>): unknown;
+export declare function safeJsonStringify(value: unknown, space?: number): string;

package/dist/apps/server/src/utils/json.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSerializable = toSerializable;
+exports.safeJsonStringify = safeJsonStringify;
+function toSerializable(value, seen = new WeakSet()) {
+    if (value == null) {
+        return value;
+    }
+    const valueType = typeof value;
+    if (valueType === 'bigint') {
+        return value.toString();
+    }
+    if (valueType === 'symbol') {
+        return value.toString();
+    }
+    if (valueType === 'function') {
+        return '[Function]';
+    }
+    if (valueType !== 'object') {
+        return value;
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            stack: value.stack
+        };
+    }
+    if (value instanceof Map) {
+        return Array.from(value.entries()).map(([k, v]) => [toSerializable(k, seen), toSerializable(v, seen)]);
+    }
+    if (value instanceof Set) {
+        return Array.from(value.values()).map(v => toSerializable(v, seen));
+    }
+    if (ArrayBuffer.isView(value)) {
+        return Array.from(value);
+    }
+    if (value instanceof ArrayBuffer) {
+        return Array.from(new Uint8Array(value));
+    }
+    if (Array.isArray(value)) {
+        return value.map(v => toSerializable(v, seen));
+    }
+    const obj = value;
+    if (seen.has(obj)) {
+        return '[Circular]';
+    }
+    seen.add(obj);
+    if (typeof obj.toJSON === 'function') {
+        try {
+            return toSerializable(obj.toJSON(), seen);
+        }
+        catch {
+            return String(obj);
+        }
+    }
+    const output = {};
+    for (const [k, v] of Object.entries(obj)) {
+        output[k] = toSerializable(v, seen);
+    }
+    return output;
+}
+function safeJsonStringify(value, space = 0) {
+    try {
+        const serialized = toSerializable(value);
+        return JSON.stringify(serialized, null, space) ?? 'null';
+    }
+    catch {
+        return JSON.stringify(String(value)) ?? 'null';
+    }
+}

package/dist/apps/server/src/utils/logger.d.ts

@@ -0,0 +1,6 @@
+import pino from 'pino';
+/**
+ * Get a logger instance for a specific session and log type
+ */
+export declare function getSessionLogger(sessionId: string, type: 'server' | 'claude.cli.spawn'): pino.Logger<never, boolean>;
+export declare const logger: pino.Logger<never, boolean>;

package/dist/apps/server/src/utils/logger.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+exports.getSessionLogger = getSessionLogger;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = require("node:process");
+const pino_1 = __importDefault(require("pino"));
+const core_1 = require("@vibe-forge/core");
+const log_level_1 = require("@vibe-forge/utils/log-level");
+const env = (0, core_1.loadEnv)();
+const logLevel = (0, log_level_1.resolveServerLogLevel)(env);
+const __VF_PROJECT_AI_SERVER_LOG_DIR__ = node_path_1.default.isAbsolute(env.__VF_PROJECT_AI_SERVER_LOG_DIR__)
+    ? env.__VF_PROJECT_AI_SERVER_LOG_DIR__
+    : node_path_1.default.join((0, node_process_1.cwd)(), env.__VF_PROJECT_AI_SERVER_LOG_DIR__);
+// Ensure base log directory exists
+if (!node_fs_1.default.existsSync(__VF_PROJECT_AI_SERVER_LOG_DIR__)) {
+    node_fs_1.default.mkdirSync(__VF_PROJECT_AI_SERVER_LOG_DIR__, { recursive: true });
+}
+/**
+ * Get a logger instance for a specific session and log type
+ */
+function getSessionLogger(sessionId, type) {
+    const sessionDir = node_path_1.default.join(__VF_PROJECT_AI_SERVER_LOG_DIR__, sessionId);
+    if (!node_fs_1.default.existsSync(sessionDir)) {
+        node_fs_1.default.mkdirSync(sessionDir, { recursive: true });
+    }
+    const logFile = node_path_1.default.join(sessionDir, `${type}.log.jsonl`);
+    return (0, pino_1.default)({
+        level: logLevel,
+        base: null, // Remove default pid and hostname for cleaner jsonl
+        timestamp: pino_1.default.stdTimeFunctions.isoTime
+    }, pino_1.default.destination({
+        dest: logFile,
+        sync: true // 使用同步写入确保实时性，且避免丢失
+    }));
+}
+// Default global logger for general server logs (not session-specific)
+exports.logger = (0, pino_1.default)({
+    level: logLevel,
+    transport: {
+        target: 'pino-pretty',
+        options: {
+            colorize: true
+        }
+    }
+});

package/dist/apps/server/src/websocket/index.d.ts

@@ -0,0 +1 @@
+export { setupWebSocket } from './server';

package/dist/apps/server/src/websocket/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupWebSocket = void 0;
+var server_1 = require("./server");
+Object.defineProperty(exports, "setupWebSocket", { enumerable: true, get: function () { return server_1.setupWebSocket; } });

package/dist/apps/server/src/websocket/server.d.ts

@@ -0,0 +1,3 @@
+import type { Server } from 'node:http';
+import type { ServerEnv } from '@vibe-forge/core';
+export declare function setupWebSocket(server: Server, env: ServerEnv): import("ws").Server<typeof import("ws"), typeof import("http").IncomingMessage>;

package/dist/apps/server/src/websocket/server.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupWebSocket = setupWebSocket;
+const node_url_1 = require("node:url");
+const uuid_1 = require("uuid");
+const ws_1 = require("ws");
+const index_js_1 = require("#~/db/index.js");
+const index_js_2 = require("#~/services/session/index.js");
+const interaction_js_1 = require("#~/services/session/interaction.js");
+const runtime_js_1 = require("#~/services/session/runtime.js");
+const json_js_1 = require("#~/utils/json.js");
+const logger_js_1 = require("#~/utils/logger.js");
+function setupWebSocket(server, env) {
+    const wss = new ws_1.WebSocketServer({ server, path: env.__VF_PROJECT_AI_SERVER_WS_PATH__ });
+    wss.on('connection', async (ws, req) => {
+        const url = new node_url_1.URL(req.url ?? '', `http://${req.headers.host ?? 'localhost'}`);
+        const params = url.searchParams;
+        const subscribeMode = params.get('subscribe');
+        if (subscribeMode === 'sessions') {
+            (0, runtime_js_1.addSessionSubscriberSocket)(ws);
+            ws.on('close', () => {
+                (0, runtime_js_1.removeSessionSubscriberSocket)(ws);
+            });
+            return;
+        }
+        const sessionId = params.get('sessionId') ?? (0, uuid_1.v4)();
+        const model = params.get('model') ?? undefined;
+        const systemPrompt = params.get('systemPrompt') ?? undefined;
+        const appendSystemPrompt = params.get('appendSystemPrompt') !== 'false';
+        const permissionMode = params.get('permissionMode') ?? undefined;
+        const promptTypeRaw = params.get('type') ?? undefined;
+        const promptType = promptTypeRaw === 'spec' || promptTypeRaw === 'entity'
+            ? promptTypeRaw
+            : undefined;
+        const promptName = params.get('name') ?? undefined;
+        const adapter = params.get('adapter') ?? undefined;
+        const serverLogger = (0, logger_js_1.getSessionLogger)(sessionId, 'server');
+        serverLogger.info({ sessionId }, '[server] Connection established');
+        try {
+            const db = (0, index_js_1.getDb)();
+            const sessionData = db.getSession(sessionId);
+            const isExternalSession = sessionData?.parentSessionId != null;
+            const cachedRuntime = (0, runtime_js_1.getAdapterSessionRuntime)(sessionId);
+            const shouldAutoStartAdapter = sessionData == null ||
+                sessionData.status === 'running' ||
+                sessionData.status === 'waiting_input';
+            if (isExternalSession) {
+                (0, runtime_js_1.attachSocketToSession)(sessionId, ws, 'external');
+            }
+            else if (cachedRuntime != null) {
+                (0, runtime_js_1.attachSocketToSession)(sessionId, ws, 'adapter');
+            }
+            else if (shouldAutoStartAdapter) {
+                const cached = await (0, index_js_2.startAdapterSession)(sessionId, {
+                    model,
+                    systemPrompt,
+                    appendSystemPrompt,
+                    permissionMode: permissionMode,
+                    promptType,
+                    promptName,
+                    adapter
+                });
+                (0, runtime_js_1.attachSocketToSession)(sessionId, ws, 'adapter');
+                if (cached == null) {
+                    throw new Error(`Failed to initialize session runtime for ${sessionId}`);
+                }
+            }
+            else {
+                (0, runtime_js_1.attachSocketToSession)(sessionId, ws, 'external');
+            }
+        }
+        catch (err) {
+            if (ws.readyState === WebSocket.OPEN) {
+                const message = err instanceof Error ? err.message : String(err);
+                ws.send((0, json_js_1.safeJsonStringify)({
+                    type: 'error',
+                    data: { message, fatal: true },
+                    message
+                }));
+            }
+            return;
+        }
+        ws.on('message', (raw) => {
+            try {
+                const msg = JSON.parse(String(raw));
+                if (msg.type === 'interaction_response') {
+                    const { id, data } = msg;
+                    (0, interaction_js_1.handleInteractionResponse)(sessionId, id, data);
+                    return;
+                }
+                serverLogger.info({ event: 'user_input', data: msg }, 'Received user message');
+                if (msg.type === 'user_message') {
+                    const content = msg.content ?? msg.text;
+                    void (0, index_js_2.processUserMessage)(sessionId, content);
+                }
+                else if (msg.type === 'interrupt') {
+                    serverLogger.info({ sessionId }, '[server] Received interrupt request');
+                    const sessionData = (0, index_js_1.getDb)().getSession(sessionId);
+                    if (sessionData?.parentSessionId == null) {
+                        (0, index_js_2.interruptSession)(sessionId);
+                    }
+                }
+                else if (msg.type === 'terminate_session') {
+                    serverLogger.info({ sessionId }, '[server] Received terminate_session request');
+                    (0, index_js_2.killSession)(sessionId);
+                }
+            }
+            catch (err) {
+                if (ws.readyState === WebSocket.OPEN) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    ws.send((0, json_js_1.safeJsonStringify)({
+                        type: 'error',
+                        data: { message, fatal: true },
+                        message
+                    }));
+                }
+            }
+        });
+        ws.on('close', () => {
+            const runtime = (0, runtime_js_1.detachSocketFromSession)(sessionId, ws);
+            const cached = runtime != null && 'session' in runtime ? runtime : undefined;
+            if (cached != null) {
+                if (cached.sockets.size === 0) {
+                    serverLogger.info({ sessionId }, '[server] All sockets closed, but keeping adapter process alive');
+                }
+                else {
+                    serverLogger.info({ sessionId, activeSockets: cached.sockets.size }, '[server] Socket closed, but session still has active sockets');
+                }
+            }
+        });
+    });
+    return wss;
+}

package/dist/packages/adapter/src/index.d.ts

@@ -0,0 +1,4 @@
+import type { Adapter } from './type';
+export * from './loader';
+export * from './type';
+export declare const defineAdapter: <T extends Adapter>(adapter: T) => Adapter;

package/dist/packages/adapter/src/index.js

@@ -0,0 +1,3 @@
+export * from './loader';
+export * from './type';
+export const defineAdapter = (adapter) => adapter;

package/dist/packages/adapter/src/loader.d.ts

@@ -0,0 +1,2 @@
+import type { Adapter } from './type';
+export declare const loadAdapter: (type: string) => Promise<Adapter>;

package/dist/packages/adapter/src/loader.js

@@ -0,0 +1,4 @@
+const resolveAdapterPackageName = (type) => (type.startsWith('@') ? type : `@vibe-forge/adapter-${type}`);
+export const loadAdapter = async (type) => (
+// eslint-disable-next-line ts/no-require-imports
+require(resolveAdapterPackageName(type))).default;