From 89342210f27ecd2118c9b6ce4d11ae8b7ab0070e Mon Sep 17 00:00:00 2001 From: Howard Abrams Date: Sat, 1 Mar 2025 11:03:37 -0800 Subject: [PATCH] Fix PUD connect working with multiple worlds --- pud.org | 366 +++++++++++++++++++++++++++++++++----------------------- 1 file changed, 219 insertions(+), 147 deletions(-) diff --git a/pud.org b/pud.org index 0b8405c..08b21e6 100644 --- a/pud.org +++ b/pud.org @@ -2,7 +2,7 @@ #+author: Howard X. Abrams #+date: 2025-01-18 #+filetags: emacs hamacs -#+lastmod: [2025-02-14 Fri] +#+lastmod: [2025-03-01 Sat] A literate programming file for a Comint-based MUD client. @@ -28,14 +28,7 @@ A literate programming file for a Comint-based MUD client. * Introduction -This project is a simple MUD client for Emacs, based on COM-INT MUD client based on Mickey Petersen’s [[https://www.masteringemacs.org/article/comint-writing-command-interpreter][essay on Comint]]. - -The default connects to *Moss ‘n Puddles*, my own MUD which I invite you to join. - -#+BEGIN_SRC emacs-lisp - (defvar pud-default-world "moss-n-puddles" - "The default world to connect.") -#+END_SRC +This project is a simple MUD client for Emacs, based on COM-INT MUD client I learn about on Mickey Petersen’s [[https://www.masteringemacs.org/article/comint-writing-command-interpreter][essay on Comint]]. This uses =telnet= (at the moment) for the connection, so you will need to install that first. On Mac, this would be: @@ -44,9 +37,10 @@ This uses =telnet= (at the moment) for the connection, so you will need to insta #+END_SRC And use a similar command on Linux. -* User Credentials +** Customization You may want to customize your connections to more worlds. +The default connects to *Moss ‘n Puddles*, my own MUD which I invite you to join. #+BEGIN_SRC emacs-lisp (defgroup pud nil @@ -54,108 +48,82 @@ You may want to customize your connections to more worlds. :group 'processes) (defcustom pud-worlds - (list (vector pud-default-world "howardabrams.com" "4000" "guest" "guest")) + '(["Moss-n-Puddles" "howardabrams.com" 4000 "" ""]) "List of worlds you play in. - You need to define the worlds you play in before you can get - started. In most worlds, you can start playing using a guest account. + You need to define the worlds you play in before you can get + started. In most worlds, you can start playing using a guest account. - Each element WORLD of the list has the following form: + Each element WORLD of the list has the following form: - \[NAME HOST PORT CHARACTER PASSWORD] + \[NAME HOST PORT CHARACTER PASSWORD CONNECTION-STR] - NAME identifies the connection, HOST and PORT specify the network - connection, CHARACTER and PASSWORD are used to connect automatically. + NAME identifies the connection, HOST and PORT specify the network + connection, CHARACTER and PASSWORD are used to connect automatically. - Note that this will be saved in your `custom-file' -- including your - passwords! If you don't want that, specify nil as your password." + The CONNECTION-STR is a string with two `%s' where this substitutes + the username and password respectively. Sends this to the server after + establishing a connection. This can be blank for the default. + If given, make sure to have a trailing `\n' to automatically send. + + Note that this will be saved in your `custom-file' -- including your + passwords! If you don't want that, specify nil as your password." :type '(repeat - (vector :tag "World" + (vector :tag "Server World" (string :tag "Name") (string :tag "Host") (integer :tag "Port") (string :tag "Char" :value "guest") - (string :tag "Pwd" :value "guest"))) + (string :tag "Pass") + (string :tag "Connect String" :value "connect %s %s"))) :group 'pud) #+END_SRC -Next, open [[file:~/.authinfo.gpg][your authinfo file]], and insert the following line, substituting =[user]= and =[pass]= with your credentials as well as the first entry to match your world: +For instance: + +#+BEGIN_SRC emacs-lisp :tangle no :eval no + (use-package pud + :custom + (pud-worlds + '(["Remote Moss-n-Puddles" "howardabrams" 4000 "bobby"] + ; ↑ No password? Should be in .authinfo.gpg + + ["Local Root" "localhost" 4000 "suzy" "some-pass"] + ; ↑ This has the password in your custom settings. + + ; ↓ Password from authinfo, special connection string: + ["Local User" "localhost" 4000 "rick" nil "login %s %s"]))) +#+END_SRC + +Hidden: +#+BEGIN_SRC emacs-lisp :tangle no :eval no +(setq pud-worlds + '(["moss-n-puddles" "howardabrams.com" 4000 "howard"] + ["moss-n-puddles" "howardabrams.com" 4000 "rick"] + ["moss-n-puddles" "howardabrams.com" 4000 "darol"] + ["local-evennia" "localhost" 4000 "howard"] + ["local-evennia" "localhost" 4000 "rick"])) +#+END_SRC + +Seems like MUDs have a standard login sequence, but they don’t have to. Here is the default that a user can override in their =pud-worlds= listing: + +#+BEGIN_SRC emacs-lisp + (defcustom pud-default-connection-string "connect %s %s\n" + "The standard connection string to substitute the username and password." + :type '(string :tag "Connect String" :value "connect %s %s\n") + :group 'pud) +#+END_SRC + +** User Credentials +Next, open [[file:~/.authinfo.gpg][your authinfo file]], and insert the following line, substituting =[user]= and =[pass]= with your credentials as well as the first entry to match each host name in your =pud-worlds= entries: #+BEGIN_SRC conf :tangle no :eval no - machine moss-n-puddles login [name] password [pass] + machine howardabrams.com login [name] port 4000 password [pass] #+END_SRC Now, let’s play! Type =run-pud=, and optionally select a world. If you get disconnected, re-run it, or even =pud-reconnect=. -The rest of this file describes the code to implement this project. +The rest of this file describes the code implementing this project. * Code -The following function will return the default world: - -#+BEGIN_SRC emacs-lisp - (defun pud-get-default-world () - "Return the connection information for the `pud-default-world'. - If only one world listed in `pud-worlds', return that." - (if (length= pud-worlds 1) - (seq-first pud-worlds) - (seq-find - (lambda (w) (string-equal (aref w 0) pud-default-world)) - pud-worlds))) -#+END_SRC - -And accessibility functions. - -#+BEGIN_SRC emacs-lisp - (defun pud-world-name (&optional world) - "Return the name for WORLD as a string." - ;; (concat (aref world 3) "@" (aref world 0)) - (if (vectorp world) - (aref world 0) - world)) - - (defun pud-world-network (&optional world) - "Return the network details for WORLD as a cons cell (HOST . PORT)." - (unless world - (setq world (pud-get-default-world))) - (list (aref world 1) (aref world 2))) - - (defun pud-world-character (&optional world) - "Return the character for WORLD as a string. - Override the customized setting if the world has an entry in authinfo." - (unless world - (setq world (pud-get-default-world))) - - (if-let ((auth-results (auth-source-search :host (aref world 0)))) - (thread-first auth-results - (first) - (plist-get :user)) - (aref world 3))) - - (defun pud-world-password (&optional world) - "Return the password for WORLD as a string." - (unless world - (setq world (pud-get-default-world))) - (if-let ((auth-results (auth-source-search :host (aref world 0)))) - (thread-first auth-results - (first) - (plist-get :secret) - (funcall)) - (aref world 4))) -#+END_SRC - -And some basic functions that really need to be expanded. - -#+BEGIN_SRC emacs-lisp :tangle no - (ert-deftest pud-world-name-test () - (should (string-equal (pud-world-name "foobar") "foobar")) - (should (string-equal (pud-world-name ["foobar" "localhost" "4000" "guest" "guest"]) "foobar"))) - - (ert-deftest pud-world-network-test () - (should (equal (pud-world-network) '("localhost" "4000"))) - (should (equal (pud-world-network ["foobar" "overthere" "4000" "guest" "guest"]) '("overthere" "4000")))) - - (ert-deftest pud-world-character-test () - (should (equal (pud-world-character) "guest"))) -#+END_SRC - Choosing a world… er, connection using a =completing-read= allowing you to choose a world. If =pud-worlds= contains a single value, might as well just return that. #+BEGIN_SRC emacs-lisp @@ -186,14 +154,61 @@ Choosing a world… er, connection using a =completing-read= allowing you to cho (t (customize-option 'pud-worlds))))) #+END_SRC -And a function for the full credentials, which just happens to be what we need to pass to =telnet=. + +The following functions are accessibility functions to the world entry. #+BEGIN_SRC emacs-lisp - (defun pud-credentials (&optional world) - "Reset the credentials from WORLD from the authinfo system." - (setf (elt 3 world) (pud-world-character world)) - (setf (elt 4 world) (pud-world-password world)) - world) + (defun pud-world-name (world) + "Return the name for WORLD as a string." + (if (vectorp world) + (if (or (length< world 4) (null (aref world 3)) (string-blank-p (aref world 3))) + (aref world 0) + (concat (aref world 3) "@" (aref world 0))) + world)) + + (defun pud-world-network (world) + "Return the network details for WORLD as a cons cell (HOST . PORT)." + (list (aref world 1) (format "%s" (aref world 2)))) + + (defun pud-world-creds (world) + "Return the username and password from WORLD. + Multiple search queries for the .authinfo file." + (seq-let (label host port user) world + (if-let ((auth-results (first (auth-source-search + :host host + :port port + :user user + :max 1)))) + (list (plist-get auth-results :user) + (funcall (plist-get auth-results :secret))) + ;; No match? Just return values from world: + (list (aref world 3) (aref world 4))))) +#+END_SRC + +And some basic functions I should expand. + +#+BEGIN_SRC emacs-lisp :tangle no + (ert-deftest pud-world-name-test () + (should (string-equal (pud-world-name "foobar") "foobar")) + (should (string-equal (pud-world-name ["foobar" "localhost" "4000"]) "foobar")) + (should (string-equal (pud-world-name ["foobar" "localhost" "4000" nil]) "foobar")) + (should (string-equal (pud-world-name ["foobar" "localhost" "4000" ""]) "foobar")) + (should (string-equal (pud-world-name ["foobar" "localhost" "4000" "guest" "guest"]) "guest@foobar"))) + + (ert-deftest pud-world-network-test () + (should (equal (pud-world-network ["foobar" "overthere" "4000" "guest" "guest"]) '("overthere" "4000"))) + (should (equal (pud-world-network ["foobar" "overthere" 4000 "guest" "guest"]) '("overthere" "4000")))) + + (ert-deftest pud-world-creds-test () + ;; Test with no match in authinfo! + (should (equal + (pud-world-creds ["first" "some-home" 4000 "a-user" "a-pass"]) + '("a-user" "a-pass"))) + ;; This test works if the following line is in .authinfo: + ;; machine localhost port 4000 login george password testpass + (should (equal + (pud-world-creds ["first" "localhost" 4000 "george"]) + '("george" "testpass")))) #+END_SRC * Basics @@ -207,14 +222,14 @@ Using Comint, and hoping to have the ANSI colors displayed. I’m going to use good ‘ol fashion =telnet= for the connection: #+BEGIN_SRC emacs-lisp - (defvar pud-cli-file-path "ssh" + (defvar pud-cli-file-path "telnet" ; ssh!? "Path to the program used by `run-pud'.") #+END_SRC The pud-cli-arguments, holds a list of commandline arguments: the port. #+BEGIN_SRC emacs-lisp - (defvar pud-cli-arguments '("gremlin.howardabrams.com" "telnet") + (defvar pud-cli-arguments nil "A list of arguments to use before the telnet location.") #+END_SRC @@ -223,7 +238,6 @@ The empty and currently disused mode map for storing our custom keybindings inhe #+BEGIN_SRC emacs-lisp (defvar pud-mode-map (let ((map (nconc (make-sparse-keymap) comint-mode-map))) - ;; example definition (define-key map "\t" 'completion-at-point) map) "Basic mode map for `run-pud'.") @@ -239,18 +253,12 @@ This holds a regular expression that matches the prompt style for the MUD. Not s The name of the buffer: #+BEGIN_SRC emacs-lisp - (defvar pud-buffer-name "*Moss and Puddles*" - "Name of the buffer to use for the `run-pud' comint instance.") + (defun pud-buffer-name (world) + "Return the buffer name associated with WORLD." + (format "*%s*" (pud-world-name world))) #+END_SRC -#+BEGIN_SRC emacs-lisp - (defun pud-buffer-name (&optional world) - "Return the buffer name associated with WORLD." - (format "*%s*" (if world - (pud-world-name world) - pud-default-world))) - #+END_SRC - +** Run and Connect The main entry point to the program is the =run-pud= function: #+BEGIN_SRC emacs-lisp @@ -263,7 +271,6 @@ The main entry point to the program is the =run-pud= function: - username (can be overridden) - password (should be overridden)" (interactive (list (pud-get-world))) - (let* ((pud-program pud-cli-file-path) (pud-args (append pud-cli-arguments (pud-world-network world))) (buffer (get-buffer-create (pud-buffer-name world))) @@ -287,19 +294,27 @@ Connection and/or re-connection: #+BEGIN_SRC emacs-lisp (defun pud-reconnect (world) "Collect and send a `connect' sequence to WORLD. - Where WORLD is a vector of world information." + Where WORLD is a vector of world information. NOP if the buffer has no + connection or no password could be found." (interactive (list (pud-get-world))) - (pop-to-buffer (pud-buffer-name world)) + (when (called-interactively-p) + (pop-to-buffer (pud-buffer-name world))) (sit-for 1) - ;; (setq world (pud-get-world)) - (let* ((username (pud-world-character world)) - (password (pud-world-password world)) - (conn-str (format "connect %s %s\n" username password)) - (process (get-buffer-process (current-buffer)))) - (if process - (comint-send-string process conn-str) - (insert conn-str)))) - #+END_SRC + + (message "Attempting to log in...") + (seq-let (username password) (pud-world-creds world) + (let* ((conn-str (if (length> world 5) + (aref world 5) + pud-default-connection-string)) + (conn-full (format conn-str username password)) + (process (get-buffer-process (current-buffer)))) + + (message "proc: %s str: '%s'" process conn-full) + (goto-char (point-max)) + (if process + (comint-send-string process conn-full) + (insert conn-full))))) +#+END_SRC * Pud Mode Note that =comint-process-echoes=, depending on the mode and the circumstances, may result in prompts appearing twice. Setting =comint-process-echoes= to =t= helps with that. @@ -342,10 +357,90 @@ Note that =comint-process-echoes=, depending on the mode and the circumstances, "Additional expressions to highlight in `pud-mode'.") #+END_SRC +* Org Babel +Wouldn’t it be nice to be able to write commands in an Org file, and send the command to the connected Mud? + +Since I’m connected to more than one MUD, or at least, I often log in with two different characters as two different characters. Let’s have a function that can return all PUD buffers: + +#+BEGIN_SRC emacs-lisp + (defun pud-get-all-buffers () + "Return a list of all buffers with a live PUD connection." + (save-window-excursion + (seq-filter (lambda (buf) + (switch-to-buffer buf) + (and + (eq major-mode 'pud-mode) + (get-buffer-process (current-buffer)))) + (buffer-list)))) +#+END_SRC + +And a wrapper around =completing-read= for choosing one of the buffers: + +#+BEGIN_SRC emacs-lisp + (defun pud-current-world () + "Return buffer based on user choice of current PUD connections." + (let ((pud-buffers (pud-get-all-buffers))) + (cond + ((null pud-buffers) nil) + ((length= pud-buffers 1) (car pud-buffers)) + (t + (completing-read "Choose connection: " + (seq-map (lambda (buf) (buffer-name buf)) + pud-buffers)))))) +#+END_SRC + +Given a buffer and a string, use the =comint-send-string=: + +#+BEGIN_SRC emacs-lisp + (defun pud-send-string (buf-name text) + "Send TEXT to a comint buffer, BUF-NAME." + (save-window-excursion + (save-excursion + (pop-to-buffer buf-name) + (goto-char (point-max)) + (comint-send-string (get-buffer-process (current-buffer)) + (format "%s\n" text))))) +#+END_SRC + +Let’s send the current line or region. + +#+BEGIN_SRC emacs-lisp :results silent + (defun pud-send-line (world) + "Send the current line or region to WORLD." + (interactive (list (pud-current-world))) + (unless world + (error "No current MUD connection.")) + + (let ((text (buffer-substring-no-properties + (if (region-active-p) (region-beginning) + (beginning-of-line-text) (point)) + (if (region-active-p) (region-end) + (end-of-line) (point))))) + (pud-send-string world text))) + + (global-set-key (kbd "") 'pud-send-line) +#+END_SRC + +Let’s be able to send the current Org block, where all lines in the block are smooshed together to create a single line: + +#+BEGIN_SRC emacs-lisp + (defun pud-send-block (world) + "Send the current Org block to WORLD." + (interactive (list (pud-current-world))) + (unless world + (error "No current MUD connection.")) + (let ((text (thread-last (org-element-at-point) + (org-src--contents-area) + (nth 2)))) + (pud-send-string world + (replace-regexp-in-string + (rx (one-or-more space)) " " text)))) + #+END_SRC + * Evennia Mode Make a simple mode for basic highlighting of =ev= code. -#+BEGIN_SRC emacs-lisp +#+BEGIN_SRC emacs-lisp :tangle no (define-derived-mode evennia-mode nil "Evennia" "Major mode for editing evennia batch command files. \\{evennia-mode-map} @@ -361,29 +456,6 @@ Make a simple mode for basic highlighting of =ev= code. ) "Additional things to highlight in evennia output.") #+END_SRC - -* Org Babel -Wouldn’t it be nice to be able to write commands in an Org file, and send the command to the connected Mud? - -#+BEGIN_SRC emacs-lisp :results silent - (defun pud-send-line (world) - "Send the current line or region to WORLD." - (interactive (list (pud-get-world))) - (save-window-excursion - (save-excursion - (let ((text (buffer-substring-no-properties - (if (region-active-p) (region-beginning) - (beginning-of-line-text) (point)) - (if (region-active-p) (region-end) - (end-of-line) (point)))) - (process (get-buffer-process (current-buffer)))) - (pop-to-buffer (pud-buffer-name world)) - (goto-char (point-max)) - (comint-send-string process (format "%s\n" text)))))) - - (global-set-key (kbd "") 'pud-send-line) -#+END_SRC - * Technical Artifacts :noexport: