Improvements to source command to support macros and breakpoints

Author: Your Name

.cshellrc

@@ -10,3 +10,15 @@ test malloc
 # show the first instruction of exit
 l exit 1
 
+# set up a macro
+m test2
+  l main
+  q
+
+# set up a breakpoint
+@f malloc 1 ?
+  != $eip 0
+  q
+  bt
+  @f #1 #
+  q

.devcontainer/Dockerfile

@@ -1,4 +1,5 @@
 FROM cshell AS frida-cshell
 RUN apt-get update && \
     apt-get install -y \
-    nano
+    nano \
+    psmisc

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "frida-cshell",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "description": "Frida's CShell",
   "scripts": {
     "prepare": "npm run build && npm run version && npm run package && npm run copy",

package.json

@@ -4,10 +4,14 @@ return {
   help: "test command",
 
   usage: function() {
-    Output.writeln("USAGE");
+    Output.writeln("test command usage");
     return Var.ZERO;
   },
 
+  run: function(tokens) {
+    return this.runSync(tokens);
+  },
+
   runSync: function(tokens) {
     if (tokens.length !== 1) return this.usage();
     const address = tokens[0].toVar().toPointer();

src.js

@@ -1,11 +1,10 @@
 import { CmdLet } from '../../commands/cmdlet.js';
-import { Command } from '../../commands/command.js';
+import { CharCode } from '../../io/char.js';
 import { Input } from '../../io/input.js';
 import { Output } from '../../io/output.js';
-import { Parser } from '../../io/parser.js';
 import { Token } from '../../io/token.js';
+import { History } from '../../terminal/history.js';
 import { Var } from '../../vars/var.js';
-import { Vars } from '../../vars/vars.js';
 
 export class SrcCmdLet extends CmdLet {
   name = 'src';
@@ -19,55 +18,57 @@ src path - run commands from file
 
   private static lastPath: string | null = null;
 
-  public static loadInitScript(path: string) {
+  public static async loadInitScript(path: string) {
     this.lastPath = path;
     const src = new SrcCmdLet();
-    src.runScript(path);
+    await src.runScript(path);
   }
 
-  public runSync(tokens: Token[]): Var {
+  public override runSync(_tokens: Token[]): Var {
+    throw new Error("can't run in synchronous mode");
+  }
+
+  public override async run(tokens: Token[]): Promise<Var> {
     const vars = this.transformOptional(tokens, [], [this.parseLiteral]);
     if (vars === null) return this.usage();
     // eslint-disable-next-line prefer-const
     let [_, [name]] = vars as [[], [string | null]];
     if (name === null) {
       if (SrcCmdLet.lastPath === null) throw new Error('path not initialized');
 
-      Output.writeln(`Loading: ${SrcCmdLet.lastPath}`);
-      this.runScript(SrcCmdLet.lastPath);
+      await this.runScript(SrcCmdLet.lastPath);
       return Var.ZERO;
     } else {
       if (name.length > 1 && name.startsWith('"') && name.endsWith('"')) {
         name = name.slice(1, name.length - 1);
       }
 
-      Output.writeln(`Loading: ${name}`);
       SrcCmdLet.lastPath = name;
-      this.runScript(name);
+      await this.runScript(name);
 
       return Var.ZERO;
     }
   }
 
-  private runScript(path: string) {
+  private async runScript(path: string) {
     try {
+      Output.writeln(`Loading: ${Output.green(path)}`);
+
       const initScript = File.readAllText(path);
       const lines = initScript.split('\n');
+
+      History.clearLine();
+      Input.prompt();
+
       for (const line of lines) {
         if (line.length === 0) continue;
         if (line.charAt(0) === '#') continue;
-
-        Output.writeln(`${Output.bold(Input.PROMPT)}${line}`);
-
-        if (line.trim().length === 0) continue;
-
-        const parser = new Parser(line.toString());
-        const tokens = parser.tokenize();
-        const ret = Command.runSync(tokens);
-        Vars.setRet(ret);
-        Output.writeRet();
-        Output.writeln();
+        Output.write(line);
+        await Input.read(`${line}${String.fromCharCode(CharCode.CR)}`);
       }
+
+      Output.clearLine();
+      Output.writeln(`Loaded: ${Output.green(path)}`);
     } catch (_) {
       /* Ignore the error */
     }

src/cmdlets/files/src.ts

@@ -112,7 +112,7 @@ m name ${CmdLet.DELETE_CHAR} - delete a macro
 
   public static runSync(macro: Macro): Var {
     let ret = Var.ZERO;
-    for (const command of macro.commands) {
+    for (const [idx, command] of macro.commands.entries()) {
       if (command.length === 0) continue;
       if (command.charAt(0) === '#') continue;
 
@@ -124,8 +124,15 @@ m name ${CmdLet.DELETE_CHAR} - delete a macro
       const tokens = parser.tokenize();
       ret = Command.runSync(tokens);
       Vars.setRet(ret);
-      Output.writeRet();
-      Output.writeln();
+
+      /*
+       * Don't print the return as the last command as we will print it as the
+       * result of the macro command itself
+       */
+      if (idx !== macro.commands.length - 1) {
+        Output.writeRet();
+        Output.writeln();
+      }
     }
     return ret;
   }

src/cmdlets/misc/macro.ts

@@ -60,8 +60,9 @@ export class Command {
     const t0 = tokens[0] as Token;
     const v0 = t0.toVar();
     if (v0 === null) {
+      const command = tokens.map(t => t.getLiteral()).join(' ');
       throw new Error(
-        'request was not understood as an internal command or a detected symbol',
+        `request was not understood as an internal command or a detected symbol: '${command}'`,
       );
     }
     const addr = v0.toPointer();

src/commands/command.ts

@@ -22,13 +22,13 @@ type InitParams = {
 };
 
 rpc.exports = {
-  init(stage: string, params: InitParams | null = null) {
+  async init(stage: string, params: InitParams | null = null) {
     const debug = params?.debug ?? false;
     Output.setDebugging(debug);
     Output.debug(`init - stage: ${stage}, debug: ${debug}`);
     Output.banner();
     Process.setExceptionHandler(exceptionHandler);
-    SrcCmdLet.loadInitScript(DEFAULT_SRC_PATH);
+    await SrcCmdLet.loadInitScript(DEFAULT_SRC_PATH);
     Input.prompt();
   },
   /**

src/entrypoint.ts

@@ -160,15 +160,17 @@ export class Input {
     Output.clearLine();
     Output.writeln(`- ${line}`);
 
-    if (line === Input.QUIT_CHAR) {
+    const trimmed = line.trim();
+
+    if (trimmed === Input.QUIT_CHAR) {
       /* Notify the commandlet we are done and exit edit mode */
       this.interceptLine = null;
       edit.saveLines();
-    } else if (line === Input.CLEAR_CHAR) {
+    } else if (trimmed === Input.CLEAR_CHAR) {
       /* Notify the commandlet we cleared and exit edit mode */
       this.interceptLine = null;
       edit.clearLines();
-    } else if (line === Input.KEEP_CHAR) {
+    } else if (trimmed === Input.KEEP_CHAR) {
       /* Notify the commandlet we aborted and exit edit mode */
       this.interceptLine = null;
       edit.cancelLines();