local wez = require 'wezterm' local messages = {} local busy = false local waiting = {} local sequence = 0 local mode = 'Session · s save · r restore · Esc cancel' local function feedback( window, message, persistent ) messages[window:window_id()] = { text = message, expires = persistent and math.huge or os.time() + 12, } window:set_right_status( message ) end local function dialog( window, pane, title, message ) window:perform_action( wez.action.InputSelector { title = title, description = message, choices = { { id = 'ok', label = 'OK', }, }, action = wez.action_callback( function () end ), }, pane ) end local function storage( operation, payload ) local args = { 'nu', '--no-config-file', wez.config_dir .. '/bugabinga/session_storage.nu', operation, } if payload then assert( #payload <= 8192, 'Session exceeds the 8 KiB snapshot limit; existing save was not changed.' ) table.insert( args, payload ) end local ok, stdout, stderr = wez.run_child_process( args ) assert( ok, 'Session storage failed.\n' .. (stderr or 'Check that nu and age are installed and on PATH.') ) return stdout end local function bounds( panes ) local left, top, right, bottom = math.huge, math.huge, 0, 0 for _, p in ipairs( panes ) do left = math.min( left, p.left ) top = math.min( top, p.top ) right = math.max( right, p.left + p.width ) bottom = math.max( bottom, p.top + p.height ) end return left, top, right - left, bottom - top end -- Rectangles include a one-cell separator; pane indexes are not split history. local function layout( panes ) assert( #panes > 0, 'Cannot save an empty tab.' ) local left, top, width, height = bounds( panes ) if #panes == 1 then local p = panes[1] return { width = width, height = height, domain = p.domain, cwd = p.cwd, active = p.active, zoomed = p.zoomed, text_source = p.text_source, } end for _, axis in ipairs { 'Right', 'Bottom', } do local horizontal = axis == 'Right' for _, p in ipairs( panes ) do local cut = horizontal and (p.left + p.width) or (p.top + p.height) local start = horizontal and left or top local extent = horizontal and width or height if cut > start and cut < start + extent - 1 then local first, second, crosses = {}, {}, false for _, q in ipairs( panes ) do local position = horizontal and q.left or q.top local size = horizontal and q.width or q.height if position + size <= cut then table.insert( first, q ) elseif position >= cut + 1 then table.insert( second, q ) else crosses = true end end if not crosses and #first > 0 and #second > 0 then local ok_a, a = pcall( layout, first ) local ok_b, b = pcall( layout, second ) if ok_a and ok_b then return { width = width, height = height, direction = axis, first = a, second = b, } end end end end end error 'Cannot reconstruct this pane layout; existing save was not changed.' end local function pane_cwd( pane, domain ) local url = pane:get_current_working_dir() if not url or url.scheme ~= 'file' then return nil end local path = url.file_path if wez.target_triple:find( 'windows', 1, true ) and domain == 'local' then if path:match '^/[A-Za-z]:/' then path = path:sub( 2 ) elseif url.host and url.host ~= '' and not path:match '^/[A-Za-z]:' then path = '//' .. url.host .. path end end return path end local function capture( window ) local snapshot = { version = 1, tabs = {}, active_tab = 1, } local count = 0 for _, info in ipairs( window:mux_window():tabs_with_info() ) do local panes = {} for _, p in ipairs( info.tab:panes_with_info() ) do local domain = p.pane:get_domain_name() table.insert( panes, { left = p.left, top = p.top, width = p.width, height = p.height, domain = domain, cwd = pane_cwd( p.pane, domain ), active = p.is_active, zoomed = p.is_zoomed, text_source = not p.pane:is_alt_screen_active() and { pane_id = p.pane:pane_id(), rows = p.pane:get_dimensions().scrollback_rows, } or nil, } ) count = count + 1 end table.insert( snapshot.tabs, { title = info.tab:get_title(), tree = layout( panes ), } ) if info.is_active then snapshot.active_tab = #snapshot.tabs end end assert( #snapshot.tabs > 0, 'Cannot save an empty window.' ) return snapshot, count end local function validate( snapshot ) assert( type( snapshot ) == 'table' and snapshot.version == 1, 'Unsupported session snapshot.' ) assert( type( snapshot.tabs ) == 'table' and #snapshot.tabs > 0 and #snapshot.tabs <= 100, 'Invalid session tabs.' ) local count = 0 local function node( n, depth ) assert( type( n ) == 'table' and depth <= 100, 'Invalid session layout.' ) for _, key in ipairs { 'width', 'height', } do assert( type( n[key] ) == 'number' and n[key] % 1 == 0 and n[key] >= 1 and n[key] <= 10000, 'Invalid pane dimensions.' ) end if n.direction then assert( n.direction == 'Right' or n.direction == 'Bottom', 'Invalid split direction.' ) node( n.first, depth + 1 ) node( n.second, depth + 1 ) else count = count + 1 assert( count <= 256 and type( n.domain ) == 'string', 'Invalid pane domain or pane count.' ) assert( n.cwd == nil or type( n.cwd ) == 'string', 'Invalid pane directory.' ) assert( n.text == nil or type( n.text ) == 'string', 'Invalid pane history.' ) end end for _, tab in ipairs( snapshot.tabs ) do assert( type( tab.title ) == 'string', 'Invalid tab title.' ) node( tab.tree, 0 ) end assert( type( snapshot.active_tab ) == 'number' and snapshot.active_tab % 1 == 0 and snapshot.active_tab >= 1 and snapshot.active_tab <= #snapshot.tabs, 'Invalid active tab.' ) end local function first_leaf( tree ) return tree.first and first_leaf( tree.first ) or tree end local function minimum( tree, horizontal ) if not tree.direction then return 1 end local a, b = minimum( tree.first, horizontal ), minimum( tree.second, horizontal ) if (tree.direction == 'Right') == horizontal then return a + b + 1 end return math.max( a, b ) end -- C1 controls are UTF-8 C2 80..9F, not arbitrary continuation bytes. local function plain_text( text ) return (text:gsub( '\r\n', '\n' ):gsub( '\t', ' ' ) :gsub( '[%z\1-\8\11-\31\127]', '' ):gsub( '\194[\128-\159]', '' ):gsub( '\n', '\r\n' )) end local function release( gate ) if gate.finished or not gate.context.constructed or not gate.ready then return end gate.finished = true waiting[gate.token] = nil -- The waiting bootstrap reads a framed DATA response, prints it via stdout, -- then starts the shell. No saved text is evaluated or sent to a live shell. -- BEL cannot occur in the sanitized payload, so it uniquely ends the frame. local sent, send_error = pcall( function () -- JSON framing preserves newlines across ConPTY input translation. gate.pane:send_text( 'wezterm-session:' .. gate.token .. ':' .. wez.json_encode( plain_text( gate.text ) ) .. '\7' ) end ) if not sent then table.insert( gate.context.warnings, 'Shell startup: ' .. tostring( send_error ) ) end gate.context.remaining = gate.context.remaining - 1 if gate.context.remaining == 0 then gate.context.done() end end wez.on( 'user-var-changed', function ( _, pane, name, value ) if name ~= 'SESSION_RESTORE' then return end local gate = waiting[value] if not gate then return end gate.ready = true gate.pane = pane release( gate ) end ) local function bootstrap( token, program ) -- term query drains old input BEFORE publishing readiness, unlike Nu input. local query = '"1337;SetUserVar=SESSION_RESTORE=" + ("' .. token .. '" | encode base64)' return 'let history = (term query ((ansi --osc (' .. query .. ')) + (char bel)) ' .. '--prefix "wezterm-session:' .. token .. ':" --terminator (char bel) | decode utf-8 | from json); ' .. 'print --no-newline $history; print ""; print "──────── New session ────────"; let shell = (' .. wez.json_encode( wez.json_encode( program or { 'nu', '--login', } ) ) .. ' | from json); exec ...$shell' end local function restore( snapshot, source_window, done ) validate( snapshot ) local warnings, restored_tabs, restored_panes = {}, 0, 0 local target, active_tab local context = { gates = {}, remaining = 0, constructed = false, warnings = warnings, done = function () end, } local function options( leaf ) local cwd = leaf.cwd if leaf.domain == 'local' and cwd then local exists = pcall( wez.read_dir, cwd ) if not exists then table.insert( warnings, 'Directory unavailable: ' .. cwd .. '; using home.' ) cwd = wez.home_dir end end local opts = { domain = { DomainName = leaf.domain, }, cwd = cwd, } if leaf.text and leaf.text ~= '' then if leaf.domain == 'local' or leaf.domain:match '^WSL:' then sequence = sequence + 1 local token = tostring( os.time() ) .. '-' .. tostring( sequence ) local gate = { token = token, text = leaf.text, context = context, } leaf.gate = gate waiting[token] = gate table.insert( context.gates, gate ) context.remaining = context.remaining + 1 local program = leaf.domain == 'local' and source_window:effective_config().default_prog or nil opts.args = { 'nu', '--no-config-file', '--commands', bootstrap( token, program ), } else table.insert( warnings, 'History skipped for unsupported domain: ' .. leaf.domain ) end end return opts end local function bind( leaf, pane ) if leaf.gate then leaf.gate.pane = pane end end local function build( tree, pane, selected ) if not tree.direction then restored_panes = restored_panes + 1 if tree.active then selected.pane = pane end if tree.zoomed then selected.zoomed = pane end return end local horizontal = tree.direction == 'Right' local size for _, info in ipairs( pane:tab():panes_with_info() ) do if info.pane:pane_id() == pane:pane_id() then size = horizontal and info.width or info.height end end assert( size, 'Cannot determine restored pane size.' ) local dimension = horizontal and 'width' or 'height' local a, b = tree.first[dimension], tree.second[dimension] local min_a, min_b = minimum( tree.first, horizontal ), minimum( tree.second, horizontal ) assert( size >= min_a + min_b + 1, 'Window too small for saved splits.' ) local split = options( first_leaf( tree.second ) ) split.direction = tree.direction split.size = math.max( min_b, math.min( size - 1 - min_a, math.floor( (size - 1) * b / (a + b) + 0.5 ) ) ) local other = pane:split( split ) bind( first_leaf( tree.second ), other ) build( tree.first, pane, selected ) build( tree.second, other, selected ) end for index, saved in ipairs( snapshot.tabs ) do local ok, err = pcall( function () local opts = options( first_leaf( saved.tree ) ) local tab, pane if not target then opts.width, opts.height = saved.tree.width, saved.tree.height opts.workspace = source_window:active_workspace() tab, pane, target = wez.mux.spawn_window( opts ) else tab, pane = target:spawn_tab( opts ) end bind( first_leaf( saved.tree ), pane ) tab:set_title( saved.title ) local selected = {} build( saved.tree, pane, selected ) if selected.pane then selected.pane:activate() end if selected.zoomed then selected.zoomed:activate() tab:set_zoomed( true ) end if index == snapshot.active_tab then active_tab = tab end restored_tabs = restored_tabs + 1 end ) if not ok then table.insert( warnings, 'Tab ' .. index .. ': ' .. tostring( err ) ) end end if active_tab then active_tab:activate() end assert( target, 'No tabs could be restored.\n' .. table.concat( warnings, '\n' ) ) context.done = function () done( restored_tabs, restored_panes, warnings, target:gui_window() ) end context.constructed = true for _, gate in ipairs( context.gates ) do if not gate.pane then waiting[gate.token] = nil gate.finished = true context.remaining = context.remaining - 1 end end if context.remaining == 0 then context.done() else for _, gate in ipairs( context.gates ) do release( gate ) end wez.time.call_after( 20, function () if context.remaining == 0 then return end for _, gate in ipairs( context.gates ) do if not gate.finished then gate.finished = true waiting[gate.token] = nil pcall( gate.pane.inject_output, gate.pane, '\r\nHistory restore timed out. Close this pane and retry restore.\r\n' ) table.insert( warnings, 'History startup timed out; close the waiting pane and retry restore.' ) end end context.remaining = 0 context.done() end ) end end local function run( operation, window, pane ) if busy then dialog( window, pane, 'Session busy', 'A session operation is already running.' ) return end busy = true feedback( window, operation == 'save' and 'Saving session…' or 'Restoring session…', true ) -- Let the GUI render the progress label before starting storage work. wez.time.call_after( 0.1, function () local ok, err = pcall( function () if operation == 'save' then local snapshot, count = capture( window ) storage( 'save', wez.json_encode( snapshot ) ) feedback( window, string.format( 'Saved %d tabs, %d panes', #snapshot.tabs, count ) ) else local snapshot = wez.json_parse( storage 'load' ) restore( snapshot, window, function ( tabs, panes, warnings, target ) busy = false local message = string.format( 'Restored %d tabs, %d panes', tabs, panes ) if #warnings > 0 then message = message .. ' · warnings' end feedback( window, message ) if target then feedback( target, message ) end if #warnings > 0 then dialog( window, pane, 'Session restored partially', table.concat( warnings, '\n' ) ) end end ) end end ) if operation == 'save' or not ok then busy = false end if not ok then feedback( window, 'Session ' .. operation .. ' failed', true ) dialog( window, pane, 'Session ' .. operation .. ' failed', tostring( err ) ) end end ) end return { mode = mode, save = function ( window, pane ) run( 'save', window, pane ) end, restore = function ( window, pane ) run( 'restore', window, pane ) end, cancel = function ( window ) feedback( window, 'Session cancelled' ) end, status = function ( window ) local message = messages[window:window_id()] return message and message.expires >= os.time() and message.text or nil end, -- Pure functions also exercised by the layout regression tests. layout = layout, validate = validate, plain_text = plain_text, bootstrap = bootstrap, }