@zhijianma/studio 1.0.10

package/dist/server/src/database.js

@@ -0,0 +1,54 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeDatabase = void 0;
+const typeorm_1 = require("typeorm");
+const InputRequest_1 = require("./dao/InputRequest");
+const Run_1 = require("./dao/Run");
+const migrations_1 = require("./migrations");
+const FridayApp_1 = require("./models/FridayApp");
+const FridayAppView_1 = require("./models/FridayAppView");
+const InputRequest_2 = require("./models/InputRequest");
+const Message_1 = require("./models/Message");
+const ModelInvocationView_1 = require("./models/ModelInvocationView");
+const Reply_1 = require("./models/Reply");
+const Run_2 = require("./models/Run");
+const RunView_1 = require("./models/RunView");
+const Trace_1 = require("./models/Trace");
+const initializeDatabase = (databaseConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const options = Object.assign(Object.assign({}, databaseConfig), { entities: [
+                Run_2.RunTable,
+                RunView_1.RunView,
+                Message_1.MessageTable,
+                Reply_1.ReplyTable,
+                InputRequest_2.InputRequestTable,
+                Trace_1.SpanTable,
+                ModelInvocationView_1.ModelInvocationView,
+                FridayApp_1.FridayAppMessageTable,
+                FridayApp_1.FridayAppReplyTable,
+                FridayAppView_1.FridayAppReplyView,
+            ], synchronize: true, migrations: migrations_1.migrations, migrationsRun: true, logging: false });
+        const dataSource = new typeorm_1.DataSource(options);
+        yield dataSource.initialize();
+        const printingOptions = Object.assign(Object.assign({}, options), { entities: undefined, migrations: undefined });
+        console.debug(`Database initialized with options: ${JSON.stringify(printingOptions, null, 2)}`);
+        console.debug('Refresh the database ...');
+        yield Run_1.RunDao.updateRunStatusAtBeginning();
+        yield InputRequest_1.InputRequestDao.updateInputRequests();
+        console.debug('Done');
+    }
+    catch (error) {
+        console.error('Error initializing database', error);
+        throw error;
+    }
+});
+exports.initializeDatabase = initializeDatabase;

package/dist/server/src/index.js

@@ -0,0 +1,211 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const trpcExpress = __importStar(require("@trpc/server/adapters/express"));
+const express_1 = __importDefault(require("express"));
+const http_1 = require("http");
+const opener_1 = __importDefault(require("opener"));
+const path_1 = __importDefault(require("path"));
+const portfinder_1 = __importDefault(require("portfinder"));
+const config_1 = require("../../shared/src/config");
+const banner_1 = require("../../shared/src/utils/banner");
+const terminal_1 = require("../../shared/src/utils/terminal");
+const database_1 = require("./database");
+const grpc_server_1 = require("./otel/grpc-server");
+const router_1 = __importDefault(require("./otel/router"));
+const router_2 = require("./trpc/router");
+const socket_1 = require("./trpc/socket");
+function initializeServer() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // Initialize the configuration
+            const configManager = config_1.ConfigManager.getInstance();
+            const config = configManager.getConfig();
+            portfinder_1.default.basePort = config.port;
+            portfinder_1.default.highestPort = portfinder_1.default.basePort + 2000;
+            // Handle HTTP port
+            const availableHttpPort = yield portfinder_1.default.getPortPromise();
+            if (availableHttpPort !== config.port) {
+                console.log(`HTTP port ${config.port} is already in use.`);
+                // Check if running in interactive environment
+                const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+                let useNewPort;
+                if (isInteractive) {
+                    useNewPort = yield (0, terminal_1.promptUser)(`Would you like to start the HTTP server on port ${availableHttpPort} instead? (y/n): `);
+                }
+                else {
+                    // Non-interactive mode: automatically use available port
+                    console.log(`Automatically using available HTTP port ${availableHttpPort} (non-interactive mode)`);
+                    useNewPort = true;
+                }
+                if (useNewPort) {
+                    yield configManager.setPort(availableHttpPort);
+                    console.log(`HTTP server will start on port ${availableHttpPort}`);
+                }
+                else {
+                    console.log('Exiting...');
+                    process.exit(1);
+                }
+            }
+            // Handle gRPC port
+            portfinder_1.default.basePort = config.otelGrpcPort;
+            portfinder_1.default.highestPort = portfinder_1.default.basePort + 2000;
+            const availableGrpcPort = yield portfinder_1.default.getPortPromise();
+            if (availableGrpcPort !== config.otelGrpcPort) {
+                console.log(`[OTEL gRPC] port ${config.otelGrpcPort} is already in use.`);
+                // Check if running in interactive environment
+                const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+                let useNewPort;
+                if (isInteractive) {
+                    useNewPort = yield (0, terminal_1.promptUser)(`Would you like to start the OTEL gRPC server on port ${availableGrpcPort} instead? (y/n): `);
+                }
+                else {
+                    // Non-interactive mode: automatically use available port
+                    console.log(`Automatically using available OTEL gRPC port ${availableGrpcPort} (non-interactive mode)`);
+                    useNewPort = true;
+                }
+                if (useNewPort) {
+                    yield configManager.setOtelGrpcPort(availableGrpcPort);
+                    console.log(`OTEL gRPC server will start on port ${availableGrpcPort}`);
+                }
+                else {
+                    console.log('Exiting...');
+                    process.exit(1);
+                }
+            }
+            // Create APP instance
+            const app = (0, express_1.default)();
+            const httpServer = (0, http_1.createServer)(app);
+            // Initialize the database
+            yield (0, database_1.initializeDatabase)(config.database);
+            // Set TRPC router
+            app.use('/trpc', trpcExpress.createExpressMiddleware({
+                router: router_2.appRouter,
+            }));
+            app.use('/v1', express_1.default.raw({
+                type: [
+                    'application/x-protobuf',
+                    'application/vnd.google.protobuf',
+                    'application/protobuf',
+                    'application/octet-stream',
+                    'application/json',
+                ],
+                limit: '10mb',
+            }), router_1.default);
+            // Initialize SocketManager
+            socket_1.SocketManager.init(httpServer);
+            // Initialize and start OTEL gRPC server on a separate port
+            const actualGrpcPort = configManager.getConfig().otelGrpcPort;
+            const otelGrpcServer = new grpc_server_1.OtelGrpcServer();
+            try {
+                yield otelGrpcServer.start(actualGrpcPort);
+            }
+            catch (error) {
+                console.warn(`Failed to start OTEL gRPC server on port ${actualGrpcPort}, ` +
+                    'traces will be received via HTTP endpoint /v1/traces:', error instanceof Error ? error.message : error);
+            }
+            // Serve static files in development mode
+            if (process.env.NODE_ENV === 'production') {
+                const publicPath = path_1.default.join(__dirname, '../../public');
+                app.use(express_1.default.static(publicPath));
+                app.use((req, res, next) => {
+                    if (!req.path.startsWith('/trpc')) {
+                        res.sendFile(path_1.default.join(publicPath, 'index.html'), {
+                            dotfiles: 'allow',
+                        });
+                    }
+                    else {
+                        next();
+                    }
+                });
+            }
+            httpServer.listen(configManager.getConfig().port, () => {
+                const actualPort = configManager.getConfig().port;
+                const config = configManager.getConfig();
+                const mode = (process.env.NODE_ENV || 'production');
+                // Display startup banner
+                (0, banner_1.displayBanner)(config_1.APP_INFO.name.replace('-', '\n'), config_1.APP_INFO.version, actualPort, actualGrpcPort, config.database.database, mode);
+                if (process.env.NODE_ENV === 'production') {
+                    (0, opener_1.default)(`http://localhost:${actualPort}/home`);
+                }
+            });
+            return { httpServer, otelGrpcServer };
+        }
+        catch (error) {
+            console.error('Error initializing server:', error);
+            console.error('Error stack:', error.stack);
+            throw error;
+        }
+    });
+}
+// Set up the server and start listening
+initializeServer()
+    .then(({ httpServer, otelGrpcServer }) => {
+    // Handle graceful shutdown
+    const cleanup = () => __awaiter(void 0, void 0, void 0, function* () {
+        console.debug('Closing Socket.IO connections');
+        socket_1.SocketManager.close();
+        console.debug('Stopping gRPC server');
+        try {
+            yield otelGrpcServer.stop();
+        }
+        catch (error) {
+            console.error('Error stopping gRPC server:', error);
+            otelGrpcServer.forceShutdown();
+        }
+        console.debug('Closing HTTP server');
+        httpServer.close(() => {
+            console.debug('HTTP server closed');
+            process.exit(0);
+        });
+    });
+    process.on('SIGTERM', cleanup);
+    process.on('SIGINT', cleanup);
+})
+    .catch(() => {
+    process.exit(1);
+});

package/dist/server/src/migrations/1730000000000-AddMessageReplyForeignKey.js

@@ -0,0 +1,216 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddMessageReplyForeignKey1730000000000 = void 0;
+const typeorm_1 = require("typeorm");
+/**
+ * Migration: Add Reply table and establish foreign key relationship with Message
+ *
+ * Tasks:
+ * 1. Create reply_table
+ * 2. Migrate historical data: create Reply records for all replyIds
+ * 3. Change message_table.replyId to a non-nullable foreign key
+ */
+class AddMessageReplyForeignKey1730000000000 {
+    constructor() {
+        this.name = 'AddMessageReplyForeignKey1730000000000';
+    }
+    up(queryRunner) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('Starting migration: Adding Reply table and establishing foreign key relationship...');
+            // ========================================
+            // Step 0: Check current database state
+            // ========================================
+            const messageTableExists = yield queryRunner.hasTable('message_table');
+            console.log(`Database state check:`);
+            console.log(`  - message_table exists: ${messageTableExists}`);
+            // Scenario 1: First-time installation - message_table does not exist
+            // TypeORM will create all tables from entity definitions, including foreign key relationships
+            if (!messageTableExists) {
+                console.log('⏭️  message_table does not exist. Skipping migration (first-time installation).');
+                console.log('   TypeORM will create all tables from entity definitions.');
+                return;
+            }
+            // Scenario 2: Check if migration is already completed
+            // If foreign key constraint exists, migration has already been completed
+            const messageTable = yield queryRunner.getTable('message_table');
+            const hasForeignKey = messageTable === null || messageTable === void 0 ? void 0 : messageTable.foreignKeys.some((fk) => fk.columnNames.includes('replyId') &&
+                fk.referencedTableName === 'reply_table');
+            if (hasForeignKey) {
+                console.log('✅ Foreign key constraint already exists. Migration already completed.');
+                return;
+            }
+            // ========================================
+            // Step 1: Create reply_table
+            // ========================================
+            console.log('Step 1: Creating reply_table...');
+            yield queryRunner.createTable(new typeorm_1.Table({
+                name: 'reply_table',
+                columns: [
+                    {
+                        name: 'replyId', // Keep camelCase, consistent with message_table
+                        type: 'varchar',
+                        isPrimary: true,
+                    },
+                    {
+                        name: 'replyRole',
+                        type: 'varchar',
+                    },
+                    {
+                        name: 'replyName',
+                        type: 'varchar',
+                    },
+                    {
+                        name: 'run_id', // Keep underscore, consistent with other tables
+                        type: 'varchar',
+                    },
+                    {
+                        name: 'createdAt',
+                        type: 'varchar',
+                    },
+                    {
+                        name: 'finishedAt',
+                        type: 'varchar',
+                        isNullable: true,
+                    },
+                ],
+            }), true);
+            // Add foreign key for run_id
+            yield queryRunner.createForeignKey('reply_table', new typeorm_1.TableForeignKey({
+                name: 'FK_reply_run',
+                columnNames: ['run_id'],
+                referencedTableName: 'run_table',
+                referencedColumnNames: ['id'],
+                onDelete: 'CASCADE',
+            }));
+            console.log('reply_table created successfully');
+            // ========================================
+            // Step 2: Migrate historical data
+            // ========================================
+            console.log('Step 2: Migrating historical data to reply_table...');
+            // Query all messages (Note: column name is replyId in camelCase)
+            const allMessages = yield queryRunner.query(`SELECT id, run_id, msg, replyId FROM message_table ORDER BY id`);
+            console.log(`Found ${allMessages.length} messages to process`);
+            // Collect all unique Reply information
+            const replyMap = new Map();
+            let nullReplyCount = 0;
+            for (const message of allMessages) {
+                const msgData = typeof message.msg === 'string'
+                    ? JSON.parse(message.msg)
+                    : message.msg;
+                const role = msgData.role || 'unknown';
+                const name = msgData.name || role;
+                const timestamp = msgData.timestamp || new Date().toISOString();
+                const hasReplyId = message.replyId && message.replyId !== '';
+                const replyIdToUse = hasReplyId ? message.replyId : message.id;
+                if (!replyMap.has(replyIdToUse)) {
+                    replyMap.set(replyIdToUse, {
+                        replyId: replyIdToUse,
+                        role,
+                        name,
+                        runId: message.run_id,
+                        createdAt: timestamp,
+                        finishedAt: timestamp,
+                    });
+                }
+                else {
+                    const existing = replyMap.get(replyIdToUse);
+                    if (timestamp > existing.finishedAt) {
+                        existing.finishedAt = timestamp;
+                        existing.role = role;
+                        existing.name = name;
+                    }
+                }
+                if (!hasReplyId) {
+                    nullReplyCount++;
+                }
+            }
+            console.log(`Need to create ${replyMap.size} Reply records, update ${nullReplyCount} messages`);
+            // Batch insert Reply records
+            let insertedCount = 0;
+            for (const reply of replyMap.values()) {
+                yield queryRunner.query(`INSERT INTO reply_table (replyId, replyRole, replyName, run_id, createdAt, finishedAt) VALUES (?, ?, ?, ?, ?, ?)`, [
+                    reply.replyId,
+                    reply.role,
+                    reply.name,
+                    reply.runId,
+                    reply.createdAt,
+                    reply.finishedAt,
+                ]);
+                insertedCount++;
+                if (insertedCount % 100 === 0) {
+                    console.log(`Progress: Inserted ${insertedCount}/${replyMap.size} Replies`);
+                }
+            }
+            console.log(`Created ${insertedCount} Reply records`);
+            // Batch update messages with NULL replyId
+            if (nullReplyCount > 0) {
+                console.log(`Starting to update replyId for ${nullReplyCount} messages...`);
+                yield queryRunner.query(`UPDATE message_table SET replyId = id WHERE replyId IS NULL OR replyId = ''`);
+                console.log(`Updated ${nullReplyCount} messages`);
+            }
+            // ========================================
+            // Step 3: Validate data integrity
+            // ========================================
+            console.log('Step 3: Validating data...');
+            const nullCount = yield queryRunner.query(`SELECT COUNT(*) as count FROM message_table WHERE replyId IS NULL OR replyId = ''`);
+            const count = nullCount[0].count || nullCount[0].COUNT;
+            if (count > 0) {
+                throw new Error(`Data migration failed: ${count} messages still have empty replyId`);
+            }
+            console.log('Validation passed: All messages have replyId');
+            // ========================================
+            // Step 4: Add foreign key constraint
+            // ========================================
+            console.log('Step 4: Adding foreign key constraint...');
+            // First change column to non-nullable
+            yield queryRunner.changeColumn('message_table', 'replyId', // Note: Keep camelCase naming
+            new typeorm_1.TableColumn({
+                name: 'replyId',
+                type: 'varchar',
+                isNullable: false,
+            }));
+            // Add foreign key constraint
+            yield queryRunner.createForeignKey('message_table', new typeorm_1.TableForeignKey({
+                name: 'FK_message_reply',
+                columnNames: ['replyId'], // Column name in message_table (camelCase)
+                referencedTableName: 'reply_table',
+                referencedColumnNames: ['replyId'], // Column name in reply_table (camelCase)
+                onDelete: 'CASCADE',
+            }));
+            console.log('Foreign key constraint added successfully');
+            console.log('✅ Migration completed!');
+        });
+    }
+    down(queryRunner) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('Starting migration rollback...');
+            // Drop foreign key constraint
+            const messageTable = yield queryRunner.getTable('message_table');
+            const foreignKey = messageTable === null || messageTable === void 0 ? void 0 : messageTable.foreignKeys.find((fk) => fk.columnNames.includes('replyId'));
+            if (foreignKey) {
+                yield queryRunner.dropForeignKey('message_table', foreignKey);
+            }
+            // Change column back to nullable
+            yield queryRunner.changeColumn('message_table', 'replyId', new typeorm_1.TableColumn({
+                name: 'replyId',
+                type: 'varchar',
+                isNullable: true,
+            }));
+            // Set Message replyId to NULL
+            yield queryRunner.query(`UPDATE message_table SET replyId = NULL`);
+            // Drop reply_table
+            yield queryRunner.dropTable('reply_table', true);
+            console.log('✅ Rollback completed');
+        });
+    }
+}
+exports.AddMessageReplyForeignKey1730000000000 = AddMessageReplyForeignKey1730000000000;