vibetunnel
Version:
Terminal sharing server with web interface - supports macOS, Linux, and headless environments
273 lines • 33.4 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ScreenManager = void 0;
const child_process_1 = require("child_process");
const util_1 = require("util");
const logger_js_1 = require("../utils/logger.js");
const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
const logger = (0, logger_js_1.createLogger)('screen-manager');
/**
* GNU Screen manager for terminal multiplexing
*
* Note: GNU Screen has a simpler model than tmux:
* - Sessions (like tmux sessions)
* - Windows (like tmux windows)
* - No panes concept (screen uses split regions but they're not addressable like tmux panes)
*/
class ScreenManager {
static getInstance() {
if (!ScreenManager.instance) {
ScreenManager.instance = new ScreenManager();
}
return ScreenManager.instance;
}
/**
* Validate session name to prevent command injection
*/
validateSessionName(name) {
if (!name || typeof name !== 'string') {
throw new Error('Session name must be a non-empty string');
}
// Allow dots for screen sessions (PID.name format), but still restrict dangerous chars
if (!/^[a-zA-Z0-9._-]+$/.test(name)) {
throw new Error('Session name can only contain letters, numbers, dots, dashes, and underscores');
}
if (name.length > 100) {
throw new Error('Session name too long (max 100 characters)');
}
}
/**
* Validate window index
*/
validateWindowIndex(index) {
if (!Number.isInteger(index) || index < 0 || index > 999) {
throw new Error('Window index must be an integer between 0 and 999');
}
}
/**
* Check if screen is available
*/
async isAvailable() {
try {
await execFileAsync('which', ['screen']);
return true;
}
catch {
return false;
}
}
/**
* List all screen sessions
* Screen output format: <pid>.<sessionname>\t(<status>)
* Example: 12345.my-session (Detached)
*/
async listSessions() {
try {
const { stdout } = await execFileAsync('screen', ['-ls']).catch((error) => {
// Screen returns exit code 1 when there are sessions (non-zero means "has sessions")
// We need to check the output to determine if it's a real error
if (error.stdout && !error.stdout.includes('No Sockets found')) {
return { stdout: error.stdout, stderr: error.stderr };
}
throw error;
});
const lines = stdout.split('\n');
const sessions = [];
for (const line of lines) {
// Match lines like: 12345.session-name (Detached)
// Note: session name may contain dots, so we match until tab character
const match = line.match(/^\s*(\d+)\.([^\t]+)\s*\t\s*\(([^)]+)\)/);
if (match) {
const [, pid, name, status] = match;
sessions.push({
name: `${pid}.${name}`, // Use full name including PID for uniqueness
type: 'screen',
attached: status.toLowerCase().includes('attached'),
exited: status.toLowerCase().includes('dead'),
// Screen doesn't provide window count in list output
});
}
}
return sessions;
}
catch (error) {
// If no sessions exist, screen returns "No Sockets found"
if (error instanceof Error &&
'stdout' in error &&
typeof error.stdout === 'string' &&
error.stdout.includes('No Sockets found')) {
return [];
}
logger.error('Failed to list screen sessions', { error });
throw error;
}
}
/**
* Create a new screen session
*/
async createSession(sessionName, command) {
this.validateSessionName(sessionName);
try {
// Remove PID prefix if present (for creating new sessions)
const cleanName = sessionName.includes('.')
? sessionName.split('.').slice(1).join('.')
: sessionName;
const args = ['screen', '-dmS', cleanName];
// If command is provided, validate and add it
if (command) {
if (typeof command !== 'string') {
throw new Error('Command must be a string');
}
// For screen, we need to pass the command as a single argument
// Screen expects the command and its args as separate elements
args.push(command);
}
await execFileAsync(args[0], args.slice(1));
logger.info('Created screen session', { sessionName: cleanName });
}
catch (error) {
logger.error('Failed to create screen session', { sessionName, error });
throw error;
}
}
/**
* Attach to a screen session
* For programmatic use, we'll create a new window in the session
*/
async attachToSession(sessionName, command) {
try {
// For newly created sessions, we might need to wait a bit or handle differently
// First check if this looks like a full session name with PID
const isFullName = /^\d+\./.test(sessionName);
if (!isFullName) {
// This is a simple name, we need to find the full name with PID
const sessions = await this.listSessions();
const session = sessions.find((s) => {
// Check if the session name ends with our provided name
const parts = s.name.split('.');
const simpleName = parts.slice(1).join('.');
return simpleName === sessionName;
});
if (session) {
sessionName = session.name;
}
else {
// Session might have just been created, use -R flag which is more forgiving
return ['screen', '-R', sessionName];
}
}
// Create a new window in the session if command is provided
if (command) {
if (typeof command !== 'string') {
throw new Error('Command must be a string');
}
await execFileAsync('screen', ['-S', sessionName, '-X', 'screen', command]);
}
// Return a command array that can be used to attach
// Use -r for existing sessions with full name
return ['screen', '-r', sessionName];
}
catch (error) {
logger.error('Failed to attach to screen session', { sessionName, error });
throw error;
}
}
/**
* Kill a screen session
*/
async killSession(sessionName) {
this.validateSessionName(sessionName);
try {
// Screen can be killed using the full name with PID or just the PID
await execFileAsync('screen', ['-S', sessionName, '-X', 'quit']);
logger.info('Killed screen session', { sessionName });
}
catch (error) {
logger.error('Failed to kill screen session', { sessionName, error });
throw error;
}
}
/**
* Check if inside a screen session
*/
isInsideScreen() {
return !!process.env.STY;
}
/**
* Get the current screen session name if inside screen
*/
getCurrentSession() {
const sty = process.env.STY;
if (!sty)
return null;
// STY format is pid.sessionname or pid.tty.host
const parts = sty.split('.');
if (parts.length >= 2) {
return parts.slice(1).join('.');
}
return null;
}
/**
* List windows in a screen session
* Note: This is more limited than tmux - screen doesn't provide easy machine-readable output
*/
async listWindows(sessionName) {
try {
// Screen doesn't have a good way to list windows programmatically
// We could parse the windowlist output but it's not reliable
// For now, return empty array
logger.warn('Window listing not fully implemented for screen');
return [];
}
catch (error) {
logger.error('Failed to list screen windows', { sessionName, error });
return [];
}
}
/**
* Create a new window in a screen session
*/
async createWindow(sessionName, windowName, command) {
this.validateSessionName(sessionName);
try {
const args = ['screen', '-S', sessionName, '-X', 'screen'];
if (windowName) {
if (typeof windowName !== 'string' || windowName.length > 50) {
throw new Error('Window name must be a string (max 50 characters)');
}
args.push('-t', windowName);
}
if (command) {
if (typeof command !== 'string') {
throw new Error('Command must be a string');
}
args.push(command);
}
await execFileAsync(args[0], args.slice(1));
logger.info('Created window in screen session', { sessionName, windowName });
}
catch (error) {
logger.error('Failed to create window', { sessionName, windowName, error });
throw error;
}
}
/**
* Kill a window in a screen session
* Note: Screen uses window numbers, not names for targeting
*/
async killWindow(sessionName, windowIndex) {
this.validateSessionName(sessionName);
this.validateWindowIndex(windowIndex);
try {
// First select the window, then kill it
await execFileAsync('screen', ['-S', sessionName, '-p', String(windowIndex), '-X', 'kill']);
logger.info('Killed window in screen session', { sessionName, windowIndex });
}
catch (error) {
logger.error('Failed to kill window', { sessionName, windowIndex, error });
throw error;
}
}
}
exports.ScreenManager = ScreenManager;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"screen-manager.js","sourceRoot":"","sources":["../../../src/server/services/screen-manager.ts"],"names":[],"mappings":";;;AAAA,iDAAyC;AACzC,+BAAiC;AAEjC,kDAAkD;AAElD,MAAM,aAAa,GAAG,IAAA,gBAAS,EAAC,wBAAQ,CAAC,CAAC;AAC1C,MAAM,MAAM,GAAG,IAAA,wBAAY,EAAC,gBAAgB,CAAC,CAAC;AAE9C;;;;;;;GAOG;AACH,MAAa,aAAa;IAGxB,MAAM,CAAC,WAAW;QAChB,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;YAC5B,aAAa,CAAC,QAAQ,GAAG,IAAI,aAAa,EAAE,CAAC;QAC/C,CAAC;QACD,OAAO,aAAa,CAAC,QAAQ,CAAC;IAChC,CAAC;IAED;;OAEG;IACK,mBAAmB,CAAC,IAAY;QACtC,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YACtC,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;QAC7D,CAAC;QACD,uFAAuF;QACvF,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YACpC,MAAM,IAAI,KAAK,CACb,+EAA+E,CAChF,CAAC;QACJ,CAAC;QACD,IAAI,IAAI,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;QAChE,CAAC;IACH,CAAC;IAED;;OAEG;IACK,mBAAmB,CAAC,KAAa;QACvC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,GAAG,GAAG,EAAE,CAAC;YACzD,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;QACvE,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,WAAW;QACf,IAAI,CAAC;YACH,MAAM,aAAa,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;YACzC,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,YAAY;QAChB,IAAI,CAAC;YACH,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,aAAa,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;gBACxE,qFAAqF;gBACrF,gEAAgE;gBAChE,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC;oBAC/D,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;gBACxD,CAAC;gBACD,MAAM,KAAK,CAAC;YACd,CAAC,CAAC,CAAC;YAEH,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACjC,MAAM,QAAQ,GAAyB,EAAE,CAAC;YAE1C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,kDAAkD;gBAClD,uEAAuE;gBACvE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,wCAAwC,CAAC,CAAC;gBACnE,IAAI,KAAK,EAAE,CAAC;oBACV,MAAM,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;oBACpC,QAAQ,CAAC,IAAI,CAAC;wBACZ,IAAI,EAAE,GAAG,GAAG,IAAI,IAAI,EAAE,EAAE,6CAA6C;wBACrE,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC;wBACnD,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC;wBAC7C,qDAAqD;qBACtD,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;YAED,OAAO,QAAQ,CAAC;QAClB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,0DAA0D;YAC1D,IACE,KAAK,YAAY,KAAK;gBACtB,QAAQ,IAAI,KAAK;gBACjB,OAAO,KAAK,CAAC,MAAM,KAAK,QAAQ;gBAChC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EACzC,CAAC;gBACD,OAAO,EAAE,CAAC;YACZ,CAAC;YACD,MAAM,CAAC,KAAK,CAAC,gCAAgC,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;YAC1D,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,aAAa,CAAC,WAAmB,EAAE,OAAgB;QACvD,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;QAEtC,IAAI,CAAC;YACH,2DAA2D;YAC3D,MAAM,SAAS,GAAG,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC;gBACzC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;gBAC3C,CAAC,CAAC,WAAW,CAAC;YAEhB,MAAM,IAAI,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;YAE3C,8CAA8C;YAC9C,IAAI,OAAO,EAAE,CAAC;gBACZ,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;oBAChC,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;gBAC9C,CAAC;gBACD,+DAA+D;gBAC/D,+DAA+D;gBAC/D,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACrB,CAAC;YAED,MAAM,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YAC5C,MAAM,CAAC,IAAI,CAAC,wBAAwB,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC,CAAC;QACpE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,iCAAiC,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC;YACxE,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,eAAe,CAAC,WAAmB,EAAE,OAAgB;QACzD,IAAI,CAAC;YACH,gFAAgF;YAChF,8DAA8D;YAC9D,MAAM,UAAU,GAAG,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAE9C,IAAI,CAAC,UAAU,EAAE,CAAC;gBAChB,gEAAgE;gBAChE,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;gBAC3C,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;oBAClC,wDAAwD;oBACxD,MAAM,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;oBAChC,MAAM,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;oBAC5C,OAAO,UAAU,KAAK,WAAW,CAAC;gBACpC,CAAC,CAAC,CAAC;gBAEH,IAAI,OAAO,EAAE,CAAC;oBACZ,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;gBAC7B,CAAC;qBAAM,CAAC;oBACN,4EAA4E;oBAC5E,OAAO,CAAC,QAAQ,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;gBACvC,CAAC;YACH,CAAC;YAED,4DAA4D;YAC5D,IAAI,OAAO,EAAE,CAAC;gBACZ,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;oBAChC,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;gBAC9C,CAAC;gBACD,MAAM,aAAa,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;YAC9E,CAAC;YAED,oDAAoD;YACpD,8CAA8C;YAC9C,OAAO,CAAC,QAAQ,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;QACvC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,oCAAoC,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC;YAC3E,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,WAAW,CAAC,WAAmB;QACnC,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;QAEtC,IAAI,CAAC;YACH,oEAAoE;YACpE,MAAM,aAAa,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;YACjE,MAAM,CAAC,IAAI,CAAC,uBAAuB,EAAE,EAAE,WAAW,EAAE,CAAC,CAAC;QACxD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,+BAA+B,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC;YACtE,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,OAAO,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,iBAAiB;QACf,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;QAC5B,IAAI,CAAC,GAAG;YAAE,OAAO,IAAI,CAAC;QAEtB,gDAAgD;QAChD,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC7B,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;YACtB,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAClC,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,WAAW,CAAC,WAAmB;QACnC,IAAI,CAAC;YACH,kEAAkE;YAClE,6DAA6D;YAC7D,8BAA8B;YAC9B,MAAM,CAAC,IAAI,CAAC,iDAAiD,CAAC,CAAC;YAC/D,OAAO,EAAE,CAAC;QACZ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,+BAA+B,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC;YACtE,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,YAAY,CAAC,WAAmB,EAAE,UAAmB,EAAE,OAAgB;QAC3E,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;QAEtC,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,CAAC,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;YAE3D,IAAI,UAAU,EAAE,CAAC;gBACf,IAAI,OAAO,UAAU,KAAK,QAAQ,IAAI,UAAU,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;oBAC7D,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;gBACtE,CAAC;gBACD,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;YAC9B,CAAC;YAED,IAAI,OAAO,EAAE,CAAC;gBACZ,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;oBAChC,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;gBAC9C,CAAC;gBACD,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACrB,CAAC;YAED,MAAM,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YAC5C,MAAM,CAAC,IAAI,CAAC,kCAAkC,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC;QAC/E,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,yBAAyB,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;YAC5E,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,UAAU,CAAC,WAAmB,EAAE,WAAmB;QACvD,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;QACtC,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;QAEtC,IAAI,CAAC;YACH,wCAAwC;YACxC,MAAM,aAAa,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;YAC5F,MAAM,CAAC,IAAI,CAAC,iCAAiC,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC,CAAC;QAC/E,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,uBAAuB,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC;YAC3E,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;CACF;AAxRD,sCAwRC","sourcesContent":["import { execFile } from 'child_process';\nimport { promisify } from 'util';\nimport type { MultiplexerSession } from '../../shared/multiplexer-types.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst execFileAsync = promisify(execFile);\nconst logger = createLogger('screen-manager');\n\n/**\n * GNU Screen manager for terminal multiplexing\n *\n * Note: GNU Screen has a simpler model than tmux:\n * - Sessions (like tmux sessions)\n * - Windows (like tmux windows)\n * - No panes concept (screen uses split regions but they're not addressable like tmux panes)\n */\nexport class ScreenManager {\n  private static instance: ScreenManager;\n\n  static getInstance(): ScreenManager {\n    if (!ScreenManager.instance) {\n      ScreenManager.instance = new ScreenManager();\n    }\n    return ScreenManager.instance;\n  }\n\n  /**\n   * Validate session name to prevent command injection\n   */\n  private validateSessionName(name: string): void {\n    if (!name || typeof name !== 'string') {\n      throw new Error('Session name must be a non-empty string');\n    }\n    // Allow dots for screen sessions (PID.name format), but still restrict dangerous chars\n    if (!/^[a-zA-Z0-9._-]+$/.test(name)) {\n      throw new Error(\n        'Session name can only contain letters, numbers, dots, dashes, and underscores'\n      );\n    }\n    if (name.length > 100) {\n      throw new Error('Session name too long (max 100 characters)');\n    }\n  }\n\n  /**\n   * Validate window index\n   */\n  private validateWindowIndex(index: number): void {\n    if (!Number.isInteger(index) || index < 0 || index > 999) {\n      throw new Error('Window index must be an integer between 0 and 999');\n    }\n  }\n\n  /**\n   * Check if screen is available\n   */\n  async isAvailable(): Promise<boolean> {\n    try {\n      await execFileAsync('which', ['screen']);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * List all screen sessions\n   * Screen output format: <pid>.<sessionname>\\t(<status>)\n   * Example: 12345.my-session\t(Detached)\n   */\n  async listSessions(): Promise<MultiplexerSession[]> {\n    try {\n      const { stdout } = await execFileAsync('screen', ['-ls']).catch((error) => {\n        // Screen returns exit code 1 when there are sessions (non-zero means \"has sessions\")\n        // We need to check the output to determine if it's a real error\n        if (error.stdout && !error.stdout.includes('No Sockets found')) {\n          return { stdout: error.stdout, stderr: error.stderr };\n        }\n        throw error;\n      });\n\n      const lines = stdout.split('\\n');\n      const sessions: MultiplexerSession[] = [];\n\n      for (const line of lines) {\n        // Match lines like: 12345.session-name\t(Detached)\n        // Note: session name may contain dots, so we match until tab character\n        const match = line.match(/^\\s*(\\d+)\\.([^\\t]+)\\s*\\t\\s*\\(([^)]+)\\)/);\n        if (match) {\n          const [, pid, name, status] = match;\n          sessions.push({\n            name: `${pid}.${name}`, // Use full name including PID for uniqueness\n            type: 'screen',\n            attached: status.toLowerCase().includes('attached'),\n            exited: status.toLowerCase().includes('dead'),\n            // Screen doesn't provide window count in list output\n          });\n        }\n      }\n\n      return sessions;\n    } catch (error) {\n      // If no sessions exist, screen returns \"No Sockets found\"\n      if (\n        error instanceof Error &&\n        'stdout' in error &&\n        typeof error.stdout === 'string' &&\n        error.stdout.includes('No Sockets found')\n      ) {\n        return [];\n      }\n      logger.error('Failed to list screen sessions', { error });\n      throw error;\n    }\n  }\n\n  /**\n   * Create a new screen session\n   */\n  async createSession(sessionName: string, command?: string): Promise<void> {\n    this.validateSessionName(sessionName);\n\n    try {\n      // Remove PID prefix if present (for creating new sessions)\n      const cleanName = sessionName.includes('.')\n        ? sessionName.split('.').slice(1).join('.')\n        : sessionName;\n\n      const args = ['screen', '-dmS', cleanName];\n\n      // If command is provided, validate and add it\n      if (command) {\n        if (typeof command !== 'string') {\n          throw new Error('Command must be a string');\n        }\n        // For screen, we need to pass the command as a single argument\n        // Screen expects the command and its args as separate elements\n        args.push(command);\n      }\n\n      await execFileAsync(args[0], args.slice(1));\n      logger.info('Created screen session', { sessionName: cleanName });\n    } catch (error) {\n      logger.error('Failed to create screen session', { sessionName, error });\n      throw error;\n    }\n  }\n\n  /**\n   * Attach to a screen session\n   * For programmatic use, we'll create a new window in the session\n   */\n  async attachToSession(sessionName: string, command?: string): Promise<string[]> {\n    try {\n      // For newly created sessions, we might need to wait a bit or handle differently\n      // First check if this looks like a full session name with PID\n      const isFullName = /^\\d+\\./.test(sessionName);\n\n      if (!isFullName) {\n        // This is a simple name, we need to find the full name with PID\n        const sessions = await this.listSessions();\n        const session = sessions.find((s) => {\n          // Check if the session name ends with our provided name\n          const parts = s.name.split('.');\n          const simpleName = parts.slice(1).join('.');\n          return simpleName === sessionName;\n        });\n\n        if (session) {\n          sessionName = session.name;\n        } else {\n          // Session might have just been created, use -R flag which is more forgiving\n          return ['screen', '-R', sessionName];\n        }\n      }\n\n      // Create a new window in the session if command is provided\n      if (command) {\n        if (typeof command !== 'string') {\n          throw new Error('Command must be a string');\n        }\n        await execFileAsync('screen', ['-S', sessionName, '-X', 'screen', command]);\n      }\n\n      // Return a command array that can be used to attach\n      // Use -r for existing sessions with full name\n      return ['screen', '-r', sessionName];\n    } catch (error) {\n      logger.error('Failed to attach to screen session', { sessionName, error });\n      throw error;\n    }\n  }\n\n  /**\n   * Kill a screen session\n   */\n  async killSession(sessionName: string): Promise<void> {\n    this.validateSessionName(sessionName);\n\n    try {\n      // Screen can be killed using the full name with PID or just the PID\n      await execFileAsync('screen', ['-S', sessionName, '-X', 'quit']);\n      logger.info('Killed screen session', { sessionName });\n    } catch (error) {\n      logger.error('Failed to kill screen session', { sessionName, error });\n      throw error;\n    }\n  }\n\n  /**\n   * Check if inside a screen session\n   */\n  isInsideScreen(): boolean {\n    return !!process.env.STY;\n  }\n\n  /**\n   * Get the current screen session name if inside screen\n   */\n  getCurrentSession(): string | null {\n    const sty = process.env.STY;\n    if (!sty) return null;\n\n    // STY format is pid.sessionname or pid.tty.host\n    const parts = sty.split('.');\n    if (parts.length >= 2) {\n      return parts.slice(1).join('.');\n    }\n    return null;\n  }\n\n  /**\n   * List windows in a screen session\n   * Note: This is more limited than tmux - screen doesn't provide easy machine-readable output\n   */\n  async listWindows(sessionName: string): Promise<Array<{ index: number; name: string }>> {\n    try {\n      // Screen doesn't have a good way to list windows programmatically\n      // We could parse the windowlist output but it's not reliable\n      // For now, return empty array\n      logger.warn('Window listing not fully implemented for screen');\n      return [];\n    } catch (error) {\n      logger.error('Failed to list screen windows', { sessionName, error });\n      return [];\n    }\n  }\n\n  /**\n   * Create a new window in a screen session\n   */\n  async createWindow(sessionName: string, windowName?: string, command?: string): Promise<void> {\n    this.validateSessionName(sessionName);\n\n    try {\n      const args = ['screen', '-S', sessionName, '-X', 'screen'];\n\n      if (windowName) {\n        if (typeof windowName !== 'string' || windowName.length > 50) {\n          throw new Error('Window name must be a string (max 50 characters)');\n        }\n        args.push('-t', windowName);\n      }\n\n      if (command) {\n        if (typeof command !== 'string') {\n          throw new Error('Command must be a string');\n        }\n        args.push(command);\n      }\n\n      await execFileAsync(args[0], args.slice(1));\n      logger.info('Created window in screen session', { sessionName, windowName });\n    } catch (error) {\n      logger.error('Failed to create window', { sessionName, windowName, error });\n      throw error;\n    }\n  }\n\n  /**\n   * Kill a window in a screen session\n   * Note: Screen uses window numbers, not names for targeting\n   */\n  async killWindow(sessionName: string, windowIndex: number): Promise<void> {\n    this.validateSessionName(sessionName);\n    this.validateWindowIndex(windowIndex);\n\n    try {\n      // First select the window, then kill it\n      await execFileAsync('screen', ['-S', sessionName, '-p', String(windowIndex), '-X', 'kill']);\n      logger.info('Killed window in screen session', { sessionName, windowIndex });\n    } catch (error) {\n      logger.error('Failed to kill window', { sessionName, windowIndex, error });\n      throw error;\n    }\n  }\n}\n"]}