dashcam 0.3.2 → 0.4.0

package/README.md

@@ -1,113 +1,58 @@
-<img src="https://user-images.githubusercontent.com/318295/204898620-922afee0-5415-46a9-a84f-ae6237001bf0.png" height="50" alt="Dashcam"/>
+<img src="https://github.com/replayableio/cli/assets/318295/c8019bca-e4d8-42a2-af55-0f4c83ce133e" height="60px" />
 
-# Dashcam API
+# Dashcam CLI
 
-Add Dashcam to your app or workflow. This package allows you to control the Dashcam desktop application from the via CLI SDK.
+Add Dashcam to your app or workflow. This package allows you to capture logs and control the Dashcam desktop application via CLI.
 
-> Why double-back when you can capture it the first time? Playback and share exactly what happened with Dashcam's desktop replay buffer.
-
-You can easily embed desktop replays within git commits, pull requests, bug reports, jira tickets, and even within log files. Desktop replays are a great way to share context behind problems and document the application state within logs, tickets and more.
-
-Requires that you [install Dashcam Desktop](https://dashcam.io). Dashcam Desktop runs in the background giving you access to a buffer of video.
+Requires that you [install Dashcam Desktop](https://dashcam.io).
 
 ## Table of contents
 
-- [Dashcam API](#dashcam-api)
-  - [Install Dashcam Desktop](#install-dashcam-desktop)
-- [Examples](#examples)
-  - [Web](#web)
-    - [Setup](#setup)
-    - [HTML Anchor Tag](#html-anchor-tag)
-    - [JS Error Handler](#js-error-handler)
-  - [NodeJS SDK](#nodejs-sdk)
-    - [Setup](#setup)
-    - [Create a Replay](#create-a-replay)
-    - [Error Handler](#error-handler)
-  - [CLI](#cli)
-    - [Setup](#setup)
-    - [Create a Replay](#create-a-replay)
-    - [Return a rich markdown link](#return-a-rich-markdown-link)
-    - [Set a replay title](#set-a-replay-title)
-    - [Attach the last 20 CLI commands to the replay](#attach-the-last-20-cli-commands-to-the-replay)
-    - [Attach a logfile to the replay](#attach-a-logfile-to-the-replay)
-  - [GitHub CLI](#github-cli)
-    - [Create a github issue with a replay in the description](#create-a-github-issue-with-a-replay-in-the-description)
-    - [Create a github pull request with a replay in the description](#create-a-github-pull-request-with-a-replay-in-the-description)
-    - [Append a 30 second replay to a commit](#append-a-30-second-replay-to-a-commit)
-- [Advanced Usage](#advanced-usage)
-  - [Ideas](#ideas)
+- [CLI](#cli)
+  - [Setup](#setup)
+  - [Record CLI](#record-cli)
+  - [Create a Dash](#create-a-replay)
+  - [Return a rich markdown link](#return-a-rich-markdown-link)
+  - [Set a Dash title](#set-a-replay-title)
+  - [Attach the last 20 CLI commands to the Dash](#attach-the-last-20-cli-commands-to-the-replay)
+  - [Attach a logfile to the replay](#attach-a-logfile-to-the-replay)
+- [Web SDK](#web)
+  - [Setup](#setup)
+  - [HTML Anchor Tag](#html-anchor-tag)
+  - [JS Error Handler](#js-error-handler)
+- [NodeJS SDK](#nodejs-sdk)
+  - [Setup](#setup)
+  - [Create a Dash](#create-a-replay)
+  - [Error Handler](#error-handler)
+- [GitHub CLI](#github-cli)
+  - [Create a GitHub issue with a Dash in the description](#create-a-github-issue-with-a-replay-in-the-description)
+  - [Create a GitHub pull request with a Dash in the description](#create-a-github-pull-request-with-a-replay-in-the-description)
+  - [Append a 30 second Dash to a commit](#append-a-30-second-replay-to-a-commit)
 
 # Examples
 
 Also see [the examples folder](https://github.com/replayableio/cli/tree/main/examples).
 
-## Web
-
-### Setup
-
-Nothing! The app exposes the protocol to the system natively via `dashcam://`.
-
-### HTML Anchor Tag
-
-```html
-<a href="dashcam://replay/create" target="_blank">Create a Replay</a>
-```
-
-### JS Error Handler
-
-```js
-window.onerror = function myErrorHandler() {
-  window.open("dashcam://replay/create", "_blank");
-};
-
-setTimeout(() => {
-  throw new Error("Throw makes it go boom!");
-}, 3000);
-```
-
-## NodeJS SDK
+## CLI
 
 ### Setup
 
 ```sh
-npm install dashcam
+npm install dashcam -g
 ```
 
-### Create a Replay
+## Record CLI
 
-```js
-const dashcam = require("dashcam");
+To record the CLI in the Dashcam app, use the following command
 
-let replay = await dashcam.createReplay({
-  title: "My New Replay",
-  description: `This **renders markdown** or plaintext in monospace font.`,
-});
 ```
-
-### Error Handler
-
-```js
-const dashcam = require("dashcam");
-
-process.on("uncaughtException", async (err) => {
-  let replay = await dashcam.createReplay({
-    title: "uncaughtException",
-    description: err,
-  });
-  console.log("Dashcam", replay);
-});
-
-setTimeout(() => {
-  throw new Error("Throw makes it go boom!");
-}, 3000);
+dashcam record
 ```
 
-## CLI
-
-### Setup
+Anything you type in your terminal will appear in your dash. To exit, simply type `exit`.
 
-```sh
-npm install dashcam -g
+```
+exit
 ```
 
 ### Create a Replay
@@ -189,6 +134,67 @@ Options:
   -h, --help                display help for command
 ```
 
+## Web
+
+### Setup
+
+Nothing! The app exposes the protocol to the system natively via `dashcam://`.
+
+### HTML Anchor Tag
+
+```html
+<a href="dashcam://replay/create" target="_blank">Create a Replay</a>
+```
+
+### JS Error Handler
+
+```js
+window.onerror = function myErrorHandler() {
+  window.open("dashcam://replay/create", "_blank");
+};
+
+setTimeout(() => {
+  throw new Error("Throw makes it go boom!");
+}, 3000);
+```
+
+## NodeJS SDK
+
+### Setup
+
+```sh
+npm install dashcam
+```
+
+### Create a Replay
+
+```js
+const dashcam = require("dashcam");
+
+let replay = await dashcam.createReplay({
+  title: "My New Replay",
+  description: `This **renders markdown** or plaintext in monospace font.`,
+});
+```
+
+### Error Handler
+
+```js
+const dashcam = require("dashcam");
+
+process.on("uncaughtException", async (err) => {
+  let replay = await dashcam.createReplay({
+    title: "uncaughtException",
+    description: err,
+  });
+  console.log("Dashcam", replay);
+});
+
+setTimeout(() => {
+  throw new Error("Throw makes it go boom!");
+}, 3000);
+```
+
 ## Ideas
 
 It would be possible to string this along in [a git hook](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks) to publish with every commit.

package/examples/crash-test.js

@@ -1,8 +1,8 @@
-const replayable = require("./index");
+const replayable = require("../index");
 
 process.on("uncaughtException", async (err) => {
   console.error(err);
-  let replay = await replayable.createReplay();
+  let replay = await replayable.createReplay({ description: err.stack });
   console.log("Replayable", replay);
 });
 

package/index.js

@@ -1,6 +1,15 @@
 #!/usr/bin/env node
 
+const fs = require("fs");
+const crypto = require("crypto");
 const lib = require("./lib");
+const Recorder = require("./recorder");
+
+if (module.parent) {
+  module.exports = lib;
+  return;
+}
+
 const { program } = require("commander");
 
 let stdin = "";
@@ -47,6 +56,26 @@ program
     process.exit(0);
   });
 
+program
+  .command("record")
+  .description(
+    "Start a recording terminal to be included in your dashcam video recording"
+  )
+  .action(async function (str, options) {
+    try {
+      const dashcam = new lib.PersistantDashcamIPC();
+      const id = crypto.randomUUID();
+      const logFile = lib.getLogFilePath(id);
+
+      dashcam.onConnected = () => dashcam.emit("track-cli", logFile);
+      fs.appendFileSync(logFile, "");
+      const recorder = new Recorder(logFile);
+      recorder.start();
+    } catch (e) {
+      console.log("Error: ", e);
+    }
+  });
+
 if (process.stdin.isTTY) {
   program.parse(process.argv);
 } else {
@@ -62,7 +91,3 @@ if (process.stdin.isTTY) {
     program.parse(process.argv);
   });
 }
-
-if (module.parent) {
-  module.exports = lib;
-}

package/lib.js

@@ -1,11 +1,17 @@
-const ipc = require("node-ipc").default;
+const os = require("os");
+const path = require("path");
 const clc = require("cli-color");
+const ipc = require("node-ipc").default;
 
 ipc.config.id = "dashcam-cli";
 ipc.config.retry = 1500;
 ipc.config.silent = true;
 ipc.config.maxRetries = 0;
 
+const persistantIPC = new ipc.IPC();
+persistantIPC.config.retry = 500;
+persistantIPC.config.silent = true;
+
 const connectToIpc = function () {
   return new Promise((resolve, reject) => {
     ipc.connectTo("dashcam");
@@ -61,4 +67,42 @@ const createReplay = async function (options = {}) {
   });
 };
 
-module.exports = { createReplay };
+let singleInstance = null;
+class PersistantDashcamIPC {
+  #isConnected = false;
+  onConnected = null;
+
+  constructor() {
+    if (singleInstance) return singleInstance;
+    singleInstance = this;
+
+    persistantIPC.connectTo("dashcam");
+
+    persistantIPC.of.dashcam.on("connect", () => {
+      this.#isConnected = true;
+      if (this.onConnected && typeof this.onConnected === "function")
+        this.onConnected();
+    });
+    persistantIPC.of.dashcam.on("disconnect", () => {
+      this.#isConnected = false;
+    });
+    persistantIPC.of.dashcam.on("error", () => {
+      this.#isConnected = false;
+    });
+  }
+
+  emit(event, payload) {
+    if (!this.#isConnected) return;
+    persistantIPC.of.dashcam.emit(event, payload);
+  }
+}
+
+const getLogFilePath = (id) => {
+  return path.join(os.tmpdir(), `dashcam_cli_recording_${id}.log`);
+};
+
+module.exports = {
+  createReplay,
+  getLogFilePath,
+  PersistantDashcamIPC,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dashcam",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Fix bugs, close pulls, and update your team with desktop instant replay.",
   "main": "index.js",
   "scripts": {
@@ -17,6 +17,7 @@
     "commander": "^9.4.0",
     "husky": "^7.0.4",
     "node-ipc": "^10.1.0",
+    "node-pty-prebuilt-multiarch": "^0.10.1-pre.5",
     "yargs": "^17.3.1"
   },
   "devDependencies": {

package/recorder.js

@@ -0,0 +1,66 @@
+const fs = require("fs");
+const pty = require("node-pty-prebuilt-multiarch");
+
+class Recorder {
+  #ptyProcess = null;
+  #logFile = null;
+
+  constructor(logFile) {
+    // This way we don't run the recording script recursively, especially
+    // if it's inside bash/zsh configs
+    if (process.env.DASHCAM_TERMINAL_RECORDING) {
+      console.log("The current terminal is already being recorded");
+      process.exit(0);
+    }
+    this.#logFile = logFile;
+  }
+
+  #onInput(data) {
+    this.#ptyProcess.write(data);
+  }
+
+  #onData(data) {
+    process.stdout.write(data);
+    fs.appendFileSync(this.#logFile, data, "ascii");
+  }
+
+  start() {
+    console.log(
+      "This session is being recorded by Dashcam and dumped to",
+      this.#logFile
+    );
+    console.log("Type `exit` to stop recording");
+
+    // TODO: Find a way to consistently get the current shell this is running from
+    // instead of using the default user shell (Maybe use parent processId to find
+    // the process filepath)
+    const shell = process.env.SHELL;
+    const args = [];
+    if (!shell.toLowerCase().includes("powershell")) args.push("-l");
+    this.#ptyProcess = pty.spawn(shell, args, {
+      // Inject a terminal variable to let the child processes know
+      // of the active recording so they we don't record recursively
+      env: { ...process.env, DASHCAM_TERMINAL_RECORDING: "TRUE" },
+    });
+
+    process.stdin.on("data", this.#onInput.bind(this));
+    this.#ptyProcess.on("data", this.#onData.bind(this));
+    this.#ptyProcess.on("exit", this.stop.bind(this));
+
+    process.stdout.setDefaultEncoding("utf8");
+    process.stdin.setEncoding("utf8");
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+  }
+
+  stop() {
+    process.stdin.removeListener("data", this.#onInput.bind(this));
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+    console.clear();
+    process.kill(process.ppid, "SIGTERM");
+    process.exit();
+  }
+}
+
+module.exports = Recorder;