@vibe-forge/tsconfigs 0.7.2 → 0.9.0

package/dist/apps/server/src/db/sessions/schema.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionsSchemaModule = void 0;
+exports.sessionsSchemaModule = {
+    name: 'sessions',
+    apply({ exec, ensureColumn }) {
+        exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        parentSessionId TEXT,
+        title TEXT,
+        lastMessage TEXT,
+        lastUserMessage TEXT,
+        createdAt INTEGER NOT NULL,
+        isStarred INTEGER DEFAULT 0,
+        isArchived INTEGER DEFAULT 0,
+        status TEXT,
+        model TEXT,
+        adapter TEXT,
+        permissionMode TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        sessionId TEXT NOT NULL,
+        data TEXT NOT NULL,
+        createdAt INTEGER NOT NULL,
+        FOREIGN KEY(sessionId) REFERENCES sessions(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS tags (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT UNIQUE NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS session_tags (
+        sessionId TEXT NOT NULL,
+        tagId INTEGER NOT NULL,
+        PRIMARY KEY (sessionId, tagId),
+        FOREIGN KEY(sessionId) REFERENCES sessions(id) ON DELETE CASCADE,
+        FOREIGN KEY(tagId) REFERENCES tags(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_messages_sessionId ON messages(sessionId);
+    `);
+        ensureColumn('sessions', 'isStarred', 'INTEGER DEFAULT 0');
+        ensureColumn('sessions', 'isArchived', 'INTEGER DEFAULT 0');
+        ensureColumn('sessions', 'parentSessionId', 'TEXT');
+        ensureColumn('sessions', 'lastMessage', 'TEXT');
+        ensureColumn('sessions', 'lastUserMessage', 'TEXT');
+        ensureColumn('sessions', 'status', 'TEXT');
+        ensureColumn('sessions', 'model', 'TEXT');
+        ensureColumn('sessions', 'adapter', 'TEXT');
+        ensureColumn('sessions', 'permissionMode', 'TEXT');
+    }
+};

package/dist/apps/server/src/db/sessions/tags.repo.d.ts

@@ -0,0 +1,5 @@
+import type { SqliteDatabase } from '../sqlite';
+export declare function createTagsRepo(db: SqliteDatabase): {
+    replace: (sessionId: string, tags: string[]) => void;
+};
+export type TagsRepo = ReturnType<typeof createTagsRepo>;

package/dist/apps/server/src/db/sessions/tags.repo.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTagsRepo = createTagsRepo;
+function createTagsRepo(db) {
+    const replace = (sessionId, tags) => {
+        const transaction = db.transaction(() => {
+            db.prepare('DELETE FROM session_tags WHERE sessionId = ?').run(sessionId);
+            for (const tagName of tags) {
+                db.prepare('INSERT OR IGNORE INTO tags (name) VALUES (?)').run(tagName);
+                const tag = db.prepare('SELECT id FROM tags WHERE name = ?').get(tagName);
+                db.prepare('INSERT OR IGNORE INTO session_tags (sessionId, tagId) VALUES (?, ?)').run(sessionId, tag.id);
+            }
+        });
+        transaction();
+    };
+    return {
+        replace
+    };
+}

package/dist/apps/server/src/db/sqlite.d.ts

@@ -0,0 +1,44 @@
+type DatabaseSyncOptions = import('node:sqlite').DatabaseSyncOptions;
+type StatementSync = import('node:sqlite').StatementSync;
+export type SqliteBindValue = null | number | bigint | string | NodeJS.ArrayBufferView;
+export interface SqliteRunResult {
+    changes: number;
+    lastInsertRowid: number | bigint;
+}
+export interface SqliteStatement {
+    all: (...params: SqliteBindValue[]) => Record<string, unknown>[];
+    get: (...params: SqliteBindValue[]) => Record<string, unknown> | undefined;
+    run: (...params: SqliteBindValue[]) => SqliteRunResult;
+}
+type SqliteTransactionFn = (...args: unknown[]) => unknown;
+export interface SqliteDatabase {
+    close: () => void;
+    exec: (sql: string) => void;
+    prepare: (sql: string) => SqliteStatement;
+    transaction: <T extends SqliteTransactionFn>(fn: T) => T;
+}
+declare class NodeSqliteStatement implements SqliteStatement {
+    private readonly statement;
+    constructor(statement: StatementSync);
+    all(...params: SqliteBindValue[]): {
+        [x: string]: unknown;
+    }[];
+    get(...params: SqliteBindValue[]): {
+        [x: string]: unknown;
+    } | undefined;
+    run(...params: SqliteBindValue[]): {
+        changes: number;
+        lastInsertRowid: number | bigint;
+    };
+}
+declare class NodeSqliteDatabase implements SqliteDatabase {
+    private readonly database;
+    private savepointId;
+    constructor(database: DatabaseSync);
+    close(): void;
+    exec(sql: string): void;
+    prepare(sql: string): NodeSqliteStatement;
+    transaction<T extends SqliteTransactionFn>(fn: T): T;
+}
+export declare function createSqliteDatabase(path: string, options?: DatabaseSyncOptions): NodeSqliteDatabase;
+export {};

package/dist/apps/server/src/db/sqlite.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSqliteDatabase = createSqliteDatabase;
+const node_module_1 = require("node:module");
+const require = (0, node_module_1.createRequire)(import.meta.url);
+const { DatabaseSync } = require('node:sqlite');
+function cloneRow(row) {
+    return { ...row };
+}
+class NodeSqliteStatement {
+    statement;
+    constructor(statement) {
+        this.statement = statement;
+    }
+    all(...params) {
+        return this.statement
+            .all(...params)
+            .map(row => cloneRow(row));
+    }
+    get(...params) {
+        const row = this.statement.get(...params);
+        return row == null ? undefined : cloneRow(row);
+    }
+    run(...params) {
+        const result = this.statement.run(...params);
+        return {
+            changes: Number(result.changes),
+            lastInsertRowid: result.lastInsertRowid
+        };
+    }
+}
+class NodeSqliteDatabase {
+    database;
+    savepointId = 0;
+    constructor(database) {
+        this.database = database;
+    }
+    close() {
+        if (this.database.isOpen) {
+            this.database.close();
+        }
+    }
+    exec(sql) {
+        this.database.exec(sql);
+    }
+    prepare(sql) {
+        return new NodeSqliteStatement(this.database.prepare(sql));
+    }
+    transaction(fn) {
+        return ((...args) => {
+            const savepointName = this.database.isTransaction
+                ? `vf_tx_${++this.savepointId}`
+                : undefined;
+            this.database.exec(savepointName == null ? 'BEGIN' : `SAVEPOINT ${savepointName}`);
+            try {
+                const result = fn(...args);
+                this.database.exec(savepointName == null ? 'COMMIT' : `RELEASE SAVEPOINT ${savepointName}`);
+                return result;
+            }
+            catch (error) {
+                if (savepointName == null) {
+                    if (this.database.isTransaction) {
+                        this.database.exec('ROLLBACK');
+                    }
+                }
+                else {
+                    this.database.exec(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+                    this.database.exec(`RELEASE SAVEPOINT ${savepointName}`);
+                }
+                throw error;
+            }
+        });
+    }
+}
+const defaultDatabaseOptions = {
+    enableForeignKeyConstraints: false
+};
+function createSqliteDatabase(path, options = {}) {
+    return new NodeSqliteDatabase(new DatabaseSync(path, {
+        ...defaultDatabaseOptions,
+        ...options
+    }));
+}

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

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

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

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_http_1 = __importDefault(require("node:http"));
+const node_process_1 = require("node:process");
+const koa_1 = __importDefault(require("koa"));
+const core_1 = require("@vibe-forge/core");
+const index_js_1 = require("#~/services/config/index.js");
+const channels_1 = require("./channels");
+const middlewares_1 = require("./middlewares");
+const routes_1 = require("./routes");
+const logger_1 = require("./utils/logger");
+const websocket_1 = require("./websocket");
+async function init() {
+    const env = (0, core_1.loadEnv)();
+    const app = new koa_1.default();
+    // HTTP & WebSocket Server
+    const handler = app.callback();
+    const server = node_http_1.default.createServer((req, res) => {
+        void handler(req, res);
+    });
+    const { projectConfig, userConfig } = await (0, index_js_1.loadConfigState)();
+    const configs = [projectConfig, userConfig];
+    return { app, env, server, configs };
+}
+async function bootstrap() {
+    const { app, env, server, configs } = await init();
+    await (0, middlewares_1.initMiddlewares)(app);
+    const { onListen: mountRoutesOnListen } = await (0, routes_1.mountRoutes)(app, env);
+    (0, websocket_1.setupWebSocket)(server, env);
+    await (0, channels_1.initChannels)(configs);
+    const { __VF_PROJECT_AI_SERVER_HOST__: serverHost, __VF_PROJECT_AI_SERVER_PORT__: serverPort, __VF_PROJECT_AI_SERVER_WS_PATH__: serverWSPath } = env;
+    server.listen(serverPort, serverHost, () => {
+        const host = `${serverHost}:${serverPort}`;
+        const httpHost = `http://${host}`;
+        logger_1.logger.info(`[server] listening on ${httpHost}`);
+        logger_1.logger.info(`[server]              ws://${host}${serverWSPath}`);
+        mountRoutesOnListen(httpHost);
+    });
+}
+bootstrap().catch((err) => {
+    logger_1.logger.error('[server] bootstrap failed:', err);
+    (0, node_process_1.exit)(1);
+});

package/dist/apps/server/src/middlewares/api-envelope.d.ts

@@ -0,0 +1,2 @@
+import type Koa from 'koa';
+export declare const apiEnvelopeMiddleware: () => Koa.Middleware;

package/dist/apps/server/src/middlewares/api-envelope.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiEnvelopeMiddleware = void 0;
+const node_http_1 = require("node:http");
+const http_js_1 = require("#~/utils/http.js");
+const logger_js_1 = require("#~/utils/logger.js");
+const isRecord = (value) => {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+};
+const getStatusMessage = (status) => node_http_1.STATUS_CODES[status] ?? 'Internal Server Error';
+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 toApiErrorResponse = (error) => ({
+    success: false,
+    error: {
+        code: error.code,
+        message: error.expose ? error.message : getStatusMessage(error.status),
+        ...(error.details !== undefined ? { details: error.details } : {})
+    }
+});
+const isApiResponseEnvelope = (body) => {
+    if (!isRecord(body) || typeof body.success !== 'boolean') {
+        return false;
+    }
+    if (body.success === true) {
+        return 'data' in body;
+    }
+    return isRecord(body.error);
+};
+const toLegacyErrorResponse = (body, status) => {
+    if (isRecord(body)) {
+        const message = typeof body.error === 'string'
+            ? body.error
+            : typeof body.message === 'string'
+                ? body.message
+                : getStatusMessage(status);
+        const code = typeof body.code === 'string' ? body.code : defaultCodeForStatus(status);
+        return {
+            success: false,
+            error: {
+                code,
+                message,
+                ...(body.details !== undefined ? { details: body.details } : {})
+            }
+        };
+    }
+    if (typeof body === 'string' && body.trim() !== '') {
+        return {
+            success: false,
+            error: {
+                code: defaultCodeForStatus(status),
+                message: body
+            }
+        };
+    }
+    return {
+        success: false,
+        error: {
+            code: defaultCodeForStatus(status),
+            message: getStatusMessage(status)
+        }
+    };
+};
+const ok = (data) => ({ success: true, data });
+const normalizeHttpError = (error) => {
+    if (error instanceof http_js_1.HttpError) {
+        return error;
+    }
+    if (isRecord(error)) {
+        const status = typeof error.status === 'number' ? error.status : 500;
+        const expose = error.expose === true || status < 500;
+        const message = typeof error.message === 'string' && expose
+            ? error.message
+            : getStatusMessage(status);
+        return new http_js_1.HttpError(status, typeof error.code === 'string' ? error.code : defaultCodeForStatus(status), message, error.details, { cause: error, expose });
+    }
+    return new http_js_1.HttpError(500, 'internal_server_error', 'Internal Server Error', undefined, {
+        cause: error,
+        expose: false
+    });
+};
+const apiEnvelopeMiddleware = () => {
+    return async (ctx, next) => {
+        try {
+            await next();
+        }
+        catch (error) {
+            if (!ctx.path.startsWith('/api')) {
+                throw error;
+            }
+            const httpError = normalizeHttpError(error);
+            if (httpError.status >= 500) {
+                logger_js_1.logger.error({ err: error, method: ctx.method, path: ctx.path }, '[api] request failed');
+            }
+            ctx.status = httpError.status;
+            ctx.type = 'application/json';
+            ctx.body = toApiErrorResponse(httpError);
+            return;
+        }
+        if (!ctx.path.startsWith('/api')) {
+            return;
+        }
+        if (ctx.status === 204 || ctx.status === 304) {
+            return;
+        }
+        ctx.type = 'application/json';
+        if (isApiResponseEnvelope(ctx.body)) {
+            return;
+        }
+        if (ctx.status >= 400) {
+            ctx.body = toLegacyErrorResponse(ctx.body, ctx.status);
+            return;
+        }
+        if (ctx.body === undefined) {
+            if (ctx.status === 404) {
+                ctx.body = toApiErrorResponse((0, http_js_1.notFound)());
+                return;
+            }
+            ctx.body = ok(null);
+            return;
+        }
+        ctx.body = ok(ctx.body);
+    };
+};
+exports.apiEnvelopeMiddleware = apiEnvelopeMiddleware;

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

@@ -0,0 +1,2 @@
+import type Koa from 'koa';
+export declare function initMiddlewares(app: Koa): Promise<void>;

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

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initMiddlewares = initMiddlewares;
+const cors_1 = __importDefault(require("@koa/cors"));
+const koa_bodyparser_1 = __importDefault(require("koa-bodyparser"));
+const api_envelope_1 = require("./api-envelope");
+async function initMiddlewares(app) {
+    app.use((0, cors_1.default)({ origin: '*', credentials: true }));
+    app.use((0, api_envelope_1.apiEnvelopeMiddleware)());
+    app.use((0, koa_bodyparser_1.default)());
+}

package/dist/apps/server/src/routes/ai.d.ts

@@ -0,0 +1,2 @@
+import Router from '@koa/router';
+export declare function aiRouter(): Router;