`lf -remote "query $id maps"` only works in shell spawned from `lf`

[c4rlo]

It seems that lf -remote "query $id maps" only works properly from within a shell spawned from lf. Whereas if you run a new lf instance, note its PID, and then run lf -remote "query $PID maps" in another window, you get an empty result. The same applies for querying cmds etc.

Looking at the code, this appears to be because gState.data, the map from which readExpr serves query requests, only gets populated/refreshed in app.runShell.

Admittedly, I don't have an actual use-case where I'm missing this functionality. However, it confused me for a bit while I was experimenting with things. And the documentation does not explain this limitation.

Therefore, I'd suggest either updating the docs to call this out, or changing the code to remove this limitation. I'd be happy to help with either approach.

[joelim-work]

This is a good point - the code wasn't designed with the intent of being able to expose its internal state via query commands in the first place, it was something that was added later on. Ideally query would directly access the actual internal state, or at least the gState cache should be updated each time the internal state is changed. I haven't thought of a clean way to implement this though.

[joelim-work]

So an idea I had some time back was to change the shell ($) and shell-wait (!) commands (i.e. synchronous shell commands) to become asynchronous, so that only the UI would be suspended but the main loop of the application would continue to run. Then it would be possible for queries to be dispatched to the main loop.

Something like below - the code is roughly written and largely untested, and I'm just leaving it here in case I forget later:

Click to expand

diff --git a/app.go b/app.go
index 2dac232..5ac0d96 100644
--- a/app.go
+++ b/app.go
@@ -37,17 +37,19 @@ type app struct {
 	selectionOut   []string
 	watch          *watch
 	quitting       bool
+	queryRespChan  chan string
 }
 
 func newApp(ui *ui, nav *nav) *app {
 	quitChan := make(chan struct{}, 1)
 
 	app := &app{
-		ui:       ui,
-		nav:      nav,
-		ticker:   new(time.Ticker),
-		quitChan: quitChan,
-		watch:    newWatch(nav.dirChan, nav.fileChan, nav.delChan),
+		ui:            ui,
+		nav:           nav,
+		ticker:        new(time.Ticker),
+		quitChan:      quitChan,
+		watch:         newWatch(nav.dirChan, nav.fileChan, nav.delChan),
+		queryRespChan: make(chan string),
 	}
 
 	sigChan := make(chan os.Signal, 1)
@@ -262,7 +264,7 @@ func (app *app) loop() {
 
 	var serverChan <-chan expr
 	if !gSingleMode {
-		serverChan = readExpr()
+		serverChan = readExpr(app.ui.exprChan, app.queryRespChan)
 	}
 
 	app.ui.readExpr()
@@ -525,22 +527,17 @@ func (app *app) runCmdSync(cmd *exec.Cmd, pause_after bool) {
 	if err := app.ui.suspend(); err != nil {
 		log.Printf("suspend: %s", err)
 	}
-	defer func() {
-		if err := app.ui.resume(); err != nil {
-			app.quit()
-			os.Exit(3)
-		}
-	}()
 
-	if err := cmd.Run(); err != nil {
-		app.ui.echoerrf("running shell: %s", err)
-	}
-	if pause_after {
-		anyKey()
-	}
+	go func() {
+		if err := cmd.Run(); err != nil {
+			app.ui.echoerrf("running shell: %s", err)
+		}
+		if pause_after {
+			anyKey()
+		}
 
-	app.ui.loadFile(app, true)
-	app.nav.renew()
+		app.ui.exprChan <- &callExpr{"resume", []string{""}, 1}
+	}()
 }
 
 // This function is used to run a shell command. Modes are as follows:
diff --git a/client.go b/client.go
index 949e07b..8fbe81d 100644
--- a/client.go
+++ b/client.go
@@ -114,7 +114,7 @@ func writeSelection(filename string, selection []string) {
 	}
 }
 
-func readExpr() <-chan expr {
+func readExpr(queryReqChan chan<- expr, queryRespChan <-chan string) <-chan expr {
 	ch := make(chan expr)
 
 	go func() {
@@ -142,12 +142,8 @@ func readExpr() <-chan expr {
 			// This is important since `query` is often the result of the user
 			// running `$lf -remote "query $id <something>"`.
 			if word, rest := splitWord(s.Text()); word == "query" {
-				gState.mutex.Lock()
-				state, ok := gState.data[rest]
-				gState.mutex.Unlock()
-				if ok {
-					fmt.Fprint(c, state)
-				}
+				queryReqChan <- &callExpr{"query", []string{rest}, 1}
+				fmt.Fprint(c, <-queryRespChan)
 				fmt.Fprintln(c, "")
 			} else {
 				p := newParser(strings.NewReader(s.Text()))
diff --git a/eval.go b/eval.go
index 5b05312..22a9ca1 100644
--- a/eval.go
+++ b/eval.go
@@ -1302,6 +1302,44 @@ func (e *callExpr) eval(app *app, args []string) {
 			app.ui.echoerrf("reload: %s", err)
 		}
 		app.ui.loadFile(app, true)
+	case "resume":
+		if !app.ui.suspended {
+			return
+		}
+		if err := app.ui.resume(); err != nil {
+			app.quit()
+			os.Exit(3)
+		}
+		app.ui.loadFile(app, true)
+		app.nav.renew()
+	case "query":
+		switch e.args[0] {
+		case "maps":
+			app.queryRespChan <- listBinds(map[string]map[string]expr{
+				"n": gOpts.nkeys,
+				"v": gOpts.vkeys,
+			})
+		case "nmaps":
+			app.queryRespChan <- listBinds(map[string]map[string]expr{
+				"n": gOpts.nkeys,
+			})
+		case "vmaps":
+			app.queryRespChan <- listBinds(map[string]map[string]expr{
+				"v": gOpts.vkeys,
+			})
+		case "cmaps":
+			app.queryRespChan <- listBinds(map[string]map[string]expr{
+				"c": gOpts.cmdkeys,
+			})
+		case "cmds":
+			app.queryRespChan <- listCmds(gOpts.cmds)
+		case "jumps":
+			app.queryRespChan <- listJumps(app.nav.jumpList, app.nav.jumpListInd)
+		case "history":
+			app.queryRespChan <- listHistory(app.cmdHistory)
+		case "files":
+			app.queryRespChan <- listFilesInCurrDir(app.nav)
+		}
 	case "delete":
 		if !app.nav.init {
 			return
diff --git a/ui.go b/ui.go
index c35b6f9..a278c5f 100644
--- a/ui.go
+++ b/ui.go
@@ -671,6 +671,7 @@ type ui struct {
 	icons       iconMap
 	currentFile string
 	pasteEvent  bool
+	suspended   bool
 }
 
 func newUI(screen tcell.Screen) *ui {
@@ -1106,6 +1107,9 @@ func (ui *ui) dirOfWin(nav *nav, wind int) *dir {
 }
 
 func (ui *ui) draw(nav *nav) {
+	if ui.suspended {
+		return
+	}
 	st := tcell.StyleDefault
 	context := dirContext{selections: nav.selections, clipboard: nav.clipboard, tags: nav.tags}
 
@@ -1648,15 +1652,25 @@ func (ui *ui) readExpr() {
 
 func (ui *ui) suspend() error {
 	ui.sxScreen.forceClear = true
-	return ui.screen.Suspend()
+	err := ui.screen.Suspend()
+	if err == nil {
+		ui.suspended = true
+	}
+
+	return err
 }
 
 func (ui *ui) resume() error {
 	err := ui.screen.Resume()
+	if err == nil {
+		ui.suspended = false
+	}
+
 	if !ui.polling {
 		go ui.pollEvents()
 		ui.polling = true
 	}
+
 	return err
 }

It does change the way synchronous commands work though, as the main loop will now continue running, though I am not sure if it will break anything in practice.

[CatsDeservePets]

Hello @c4rlo!

Please help me out! I cannot reproduce this at at all.

I do the following steps:

1. Starting lf
2. Executing %echo $id -> 61267
3. Opening a new window
4. Executing `lf -remote "query 61267 maps" -> all my maps

I did go all the way back to version r36 and it still works. So either I am missing the point entirely or you are doing something wrong?

[joelim-work]

Running %echo $id (or any other shell command) populates the data available for query commands. Try omitting step 2 (use ps to figure out the PID) and see what happens.

[c4rlo]

Yes, that's right. Try these steps:

1. Run lf -config /dev/null
2. Note its pid, e.g. using pgrep -a lf
3. Run lf -remote 'query [pid] maps' → empty output

I just confirmed this with version 40.

[CatsDeservePets]

Oh I see, thanks! Now I can reproduce it.