termdock 1.4.299 → 1.4.301

package/dist/server/entry.js

@@ -1,7 +1,8 @@
+import { IntegrationRuntime, integrationSocketPath } from './agent/integrationServer.js';
 import { CollaborationService } from './agent/collaborationService.js';
 import { X509Certificate } from 'node:crypto';
 import { CollaborationPeerTransport, connectCollaborationRpc } from './agent/collaborationPeerTransport.js';
-import { collaborationStore, collaborationTaskStore, deliverPeerCollaboration, collaborationLocalActivity, collaborationDirectorySessions, prepareCollaborationTaskWorker } from './routes/terminal.js';
+import { collaborationStore, collaborationTaskStore, deliverPeerCollaboration, collaborationLocalActivity, collaborationDirectorySessions, prepareCollaborationTaskWorker, integrationSessionAdapter } from './routes/terminal.js';
 import { CollaborationTaskService } from './agent/collaborationTaskService.js';
 import { setPushTargetPeerId } from './notifications/pushService.js';
 import { desktopDirectTargets } from './federation/desktopTargets.js';
@@ -571,7 +572,7 @@ export function startServer(options = {}) {
             return routeInvitations.consume(code, subjectId);
         },
     });
-    void federation.then(runtime => {
+    void federation.then(async (runtime) => {
         federationServiceId = runtime.serviceId;
         setPushTargetPeerId(runtime.serviceId);
         refreshDirectTargets();
@@ -634,6 +635,21 @@ export function startServer(options = {}) {
         app.locals.collaborationService = collaborationService;
         const collaborationTasks = new CollaborationTaskService(collaborationTaskStore, collaborationStore, collaborationService, deliverPeerCollaboration, (task, template, dependencies) => prepareCollaborationTaskWorker(task, template, dependencies, collaborationService, (taskId, dependencyId, offset) => collaborationTasks.dependencyChunk(taskId, dependencyId, offset)));
         app.locals.collaborationTasks = collaborationTasks;
+        if (options.port !== 0) {
+            let integration;
+            try {
+                const port = options.port ?? DEFAULT_PORT;
+                integration = new IntegrationRuntime({ directory: path.join(homedir(), '.termdock', 'integration-state', String(port)), socketPath: integrationSocketPath(port), adminToken: options.localApiToken,
+                    messages: collaborationStore, taskStore: collaborationTaskStore, tasks: collaborationTasks, peers: collaborationService, sessions: integrationSessionAdapter });
+                await integration.listen();
+                app.locals.integrationRuntime = integration;
+                server.once('close', () => { void integration?.close(); });
+            }
+            catch {
+                await integration?.close();
+                console.error('[integrations] Local integration endpoint could not start; existing terminal service remains available');
+            }
+        }
         collaborationTasks.start();
         server.once('close', () => collaborationTasks.close());
         collaborationService.start();
@@ -786,15 +802,18 @@ export function startServer(options = {}) {
         return;
     });
     server.listen(port, host, () => {
+        const listeningAddress = server.address();
+        const listeningPort = listeningAddress && typeof listeningAddress !== 'string' ? listeningAddress.port : port;
+        const listeningHost = listeningAddress && typeof listeningAddress !== 'string' ? listeningAddress.address : host;
         const displayHost = host === '0.0.0.0' ? 'localhost' : host;
-        console.log(`Termdock server running at ${scheme}://${displayHost}:${port}`);
-        console.log(`Health check: ${scheme}://${displayHost}:${port}/health`);
+        console.log(`Termdock server running at ${scheme}://${displayHost}:${listeningPort}`);
+        console.log(`Health check: ${scheme}://${displayHost}:${listeningPort}/health`);
         const onboardingServerState = scheme === 'https'
-            ? startOnboardingServer({ httpsPort: port, caCertPath: options.httpsCaPath })
+            ? startOnboardingServer({ httpsPort: listeningPort, caCertPath: options.httpsCaPath })
             : { server: null, url: null };
-        void localAccessManager.start({ host, port, scheme, caCertPath: options.httpsCaPath, onboardingPort: options.onboardingPort ?? port }).then((state) => {
+        void localAccessManager.start({ host: listeningHost, port: listeningPort, scheme, caCertPath: options.httpsCaPath, onboardingPort: options.onboardingPort ?? listeningPort }).then((state) => {
             const publishState = () => {
-                const onboardingUrl = onboardingServerState.url ?? state.onboardingUrl;
+                const onboardingUrl = state.status === 'loopback-only' ? null : onboardingServerState.url ?? state.onboardingUrl;
                 latestLocalAccessState = state;
                 latestOnboardingUrl = onboardingUrl;
                 if (state.status === 'active') {

package/dist/server/routes/filesystem.js

@@ -5064,89 +5064,136 @@ router.post('/upload', async (req, res) => {
             res.status(400).json({ error: 'Missing dir query parameter', code: 'MISSING_DIR' });
             return;
         }
+        // New clients can reject an oversized selection before sending any files.
+        // Older clients are still checked against the actual multipart contents.
+        const declaredCount = req.query.fileCount;
+        if (declaredCount !== undefined && (typeof declaredCount !== 'string' || !/^\d+$/.test(declaredCount))) {
+            res.status(400).json({ error: 'Invalid fileCount query parameter', code: 'INVALID_FILE_COUNT' });
+            return;
+        }
+        if (typeof declaredCount === 'string' && Number(declaredCount) > MAX_UPLOAD_FILES) {
+            res.status(413).json({ error: 'Upload limit exceeded', code: 'UPLOAD_LIMIT', files: [], results: [], maxFiles: MAX_UPLOAD_FILES });
+            return;
+        }
         const resolvedDir = await pathValidator.validatePathAsync(dir);
         const stat = await fs.promises.stat(resolvedDir);
         if (!stat.isDirectory()) {
             res.status(400).json({ error: 'Target is not a directory', code: 'NOT_A_DIRECTORY' });
             return;
         }
-        const files = [];
-        let fileCount = 0;
-        let aborted = false;
+        const results = [];
+        const createdPaths = [];
+        let failure;
         let totalSize = 0;
+        const fail = (error, code = 'UPLOAD_FAILED', status = 500) => {
+            failure ??= { error, code, status };
+        };
         const bb = busboy({
             headers: req.headers,
             // Browser FormData sends UTF-8 filenames, while busboy defaults bare
             // multipart filename parameters to latin1. Without this, dropped files
             // named with CJK characters turn into mojibake like "查询".
             defParamCharset: 'utf8',
-            limits: { fileSize: MAX_UPLOAD_SIZE, files: MAX_UPLOAD_FILES },
+            // Enforce the count in the file handler rather than Busboy's files limit:
+            // the latter silently omits the names of files beyond the limit.
+            // Busboy marks a stream truncated as soon as this boundary is reached;
+            // one extra byte lets an exactly-100MB file remain a valid upload.
+            limits: { fileSize: MAX_UPLOAD_SIZE + 1 },
         });
         const writePromises = [];
         bb.on('file', (_fieldname, fileStream, info) => {
-            if (aborted) {
-                fileStream.resume();
-                return;
-            }
-            fileCount++;
-            if (fileCount > MAX_UPLOAD_FILES) {
-                aborted = true;
-                fileStream.resume();
-                return;
-            }
-            const { filename } = info;
-            const destName = sanitizeUploadFilename(filename, `file_${fileCount}`);
+            const index = results.length;
+            const destName = sanitizeUploadFilename(info.filename, `file_${index + 1}`);
+            const result = { index, name: destName, status: 'failed' };
+            results.push(result);
+            if (results.length > MAX_UPLOAD_FILES)
+                fail('Upload limit exceeded', 'UPLOAD_LIMIT', 413);
             const baseDestPath = path.join(resolvedDir, destName);
-            // Resolve unique path asynchronously inside the write promise
+            fileStream.on('limit', () => fail('Upload limit exceeded', 'UPLOAD_LIMIT', 413));
+            // Parsing/cancellation can destroy this stream while exclusive open is
+            // pending. The async iterator below will still observe the same error.
+            fileStream.on('error', () => { });
             const writePromise = (async () => {
-                const destPath = await uniquePath(baseDestPath);
-                return new Promise((resolve, reject) => {
-                    const writeStream = fs.createWriteStream(destPath);
-                    let fileSize = 0;
-                    fileStream.on('data', (chunk) => {
-                        fileSize += chunk.length;
-                        totalSize += chunk.length;
-                        if (totalSize > MAX_UPLOAD_SIZE) {
-                            aborted = true;
-                            fileStream.destroy?.(new Error('File too large'));
-                            writeStream.destroy();
-                            return;
+                let destination;
+                let fileSize = 0;
+                try {
+                    if (!failure) {
+                        destination = await createUniqueUploadFile(baseDestPath);
+                        createdPaths.push(destination.path);
+                    }
+                    // Keep draining rejected files so every multipart item can be
+                    // reported, and Busboy can finish without a dangling write stream.
+                    for await (const chunk of fileStream) {
+                        const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                        fileSize += data.length;
+                        totalSize += data.length;
+                        if (totalSize > MAX_UPLOAD_SIZE)
+                            fail('Upload limit exceeded', 'UPLOAD_LIMIT', 413);
+                        if (destination && !failure) {
+                            try {
+                                await destination.handle.writeFile(data);
+                            }
+                            catch (error) {
+                                // Do not throw from the iterator body: that would destroy the
+                                // multipart source before Busboy can drain the rest of it.
+                                fail(error instanceof Error ? error.message : 'Upload failed');
+                            }
                         }
-                    });
-                    fileStream.pipe(writeStream);
-                    writeStream.on('finish', () => {
-                        files.push({ name: destName, path: destPath, size: fileSize });
-                        resolve();
-                    });
-                    writeStream.on('error', (err) => {
-                        fs.promises.unlink(destPath).catch(() => { });
-                        reject(err);
-                    });
-                });
+                    }
+                    if (destination && !failure) {
+                        result.status = 'uploaded';
+                        result.path = destination.path;
+                        result.size = fileSize;
+                    }
+                }
+                catch (error) {
+                    fail(error instanceof Error ? error.message : 'Upload failed');
+                    fileStream.resume();
+                }
+                finally {
+                    try {
+                        await destination?.handle.close();
+                    }
+                    catch (error) {
+                        fail(error instanceof Error ? error.message : 'Upload failed');
+                    }
+                }
             })();
             writePromises.push(writePromise);
         });
-        bb.on('error', (_err) => {
-            // Will be handled by the promise rejection below
-        });
-        bb.on('filesLimit', () => {
-            aborted = true;
-        });
-        bb.on('finish', async () => {
-            try {
-                await Promise.all(writePromises);
-                if (aborted && files.length === 0) {
-                    res.status(413).json({ error: 'Upload limit exceeded', code: 'UPLOAD_LIMIT' });
-                    return;
-                }
-                res.status(200).json({ files });
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : 'Upload failed';
-                res.status(500).json({ error: message, code: 'UPLOAD_FAILED' });
-            }
-        });
-        req.pipe(bb);
+        const onAborted = () => bb.destroy(new Error('Upload canceled'));
+        req.once('aborted', onAborted);
+        try {
+            await new Promise((resolve, reject) => {
+                bb.once('finish', resolve);
+                bb.once('error', reject);
+                req.pipe(bb);
+            });
+        }
+        catch (error) {
+            fail(error instanceof Error ? error.message : 'Upload failed');
+        }
+        finally {
+            req.off('aborted', onAborted);
+        }
+        await Promise.all(writePromises);
+        if (res.destroyed)
+            fail('Upload canceled');
+        if (failure) {
+            // Paths enter this list only after an exclusive create succeeded. Never
+            // remove an existing file or another concurrent request's destination.
+            await Promise.all(createdPaths.map(filePath => fs.promises.unlink(filePath).catch(error => {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            })));
+            const { error, code, status } = failure;
+            if (!res.destroyed)
+                res.status(status).json({ error, code, files: [], maxFiles: MAX_UPLOAD_FILES,
+                    results: results.map(result => ({ index: result.index, name: result.name, status: 'failed', error, code })) });
+            return;
+        }
+        const files = results.map(result => ({ name: result.name, path: result.path, size: result.size }));
+        res.status(200).json({ files, results });
     }
     catch (error) {
         if (error instanceof Error && error.code === 'PATH_NOT_ALLOWED') {
@@ -5157,32 +5204,18 @@ router.post('/upload', async (req, res) => {
         res.status(500).json({ error: message, code: 'UPLOAD_FAILED' });
     }
 });
-async function uniquePath(filePath) {
-    try {
-        await fs.promises.access(filePath);
-        // File exists — find a unique name
-        const ext = path.extname(filePath);
-        const base = filePath.slice(0, filePath.length - ext.length);
-        let counter = 1;
-        let candidate;
-        do {
-            candidate = `${base}_${counter}${ext}`;
-            counter++;
-        } while (await exists(candidate));
-        return candidate;
-    }
-    catch {
-        // File doesn't exist — use as-is
-        return filePath;
-    }
-}
-async function exists(p) {
-    try {
-        await fs.promises.access(p);
-        return true;
-    }
-    catch {
-        return false;
+async function createUniqueUploadFile(filePath) {
+    const ext = path.extname(filePath);
+    const base = filePath.slice(0, filePath.length - ext.length);
+    for (let counter = 0;; counter++) {
+        const candidate = counter === 0 ? filePath : `${base}_${counter}${ext}`;
+        try {
+            return { path: candidate, handle: await fs.promises.open(candidate, 'wx') };
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+        }
     }
 }
 export default router;