feat: use $EDITOR for creating notes with content

Author: Yukaii

src/commands/notes/create.ts

@@ -1,12 +1,23 @@
-import {CommentPermissionType, CreateNoteOptions, NotePermissionRole} from '@hackmd/api/dist/type'
-import {CliUx, Flags} from '@oclif/core'
+import {
+  CommentPermissionType,
+  CreateNoteOptions,
+  NotePermissionRole,
+} from "@hackmd/api/dist/type";
+import { CliUx, Flags } from "@oclif/core";
+import * as fs from "fs";
 
-import HackMDCommand from '../../command'
-import {commentPermission, noteContent, notePermission, noteTitle} from '../../flags'
-import {safeStdinRead} from '../../utils'
+import HackMDCommand from "../../command";
+import {
+  commentPermission,
+  noteContent,
+  notePermission,
+  noteTitle,
+} from "../../flags";
+import { safeStdinRead, temporaryMD } from "../../utils";
+import openEditor from "../../openEditor";
 
-export default class Create extends HackMDCommand {
-  static description = 'Create a note'
+export default class CreateCommand extends HackMDCommand {
+  static description = "Create a note";
 
   static examples = [
     "notes create --content='# A new note' --readPermission=owner --writePermission=owner --commentPermission=disabled",
@@ -15,54 +26,73 @@ export default class Create extends HackMDCommand {
 ────────────────────── ──────────────────────────────── ──────────────────────  ────────
 raUuSTetT5uQbqQfLnz9lA A new note                       gvfz2UB5THiKABQJQnLs6Q  null`,
 
-    'Or you can pipe content via Unix pipeline:',
-    'cat README.md | hackmd-cli notes create'
-  ]
+    "Or you can pipe content via Unix pipeline:",
+    "cat README.md | hackmd-cli notes create",
+  ];
 
   static flags = {
-    help: Flags.help({char: 'h'}),
+    help: Flags.help({ char: "h" }),
     title: noteTitle(),
     content: noteContent(),
     readPermission: notePermission(),
     writePermission: notePermission(),
     commentPermission: commentPermission(),
+    editor: Flags.boolean({
+      char: "e",
+      description: "create note with $EDITOR",
+    }),
     ...CliUx.ux.table.flags(),
-  }
+  };
 
   async run() {
-    const {flags} = await this.parse(Create)
-    const pipeString = safeStdinRead()
+    const { flags } = await this.parse(CreateCommand);
+    const pipeString = safeStdinRead();
 
     const options: CreateNoteOptions = {
       title: flags.title,
       content: pipeString || flags.content,
       readPermission: flags.readPermission as NotePermissionRole,
       writePermission: flags.writePermission as NotePermissionRole,
-      commentPermission: flags.commentPermission as CommentPermissionType
+      commentPermission: flags.commentPermission as CommentPermissionType,
+    };
+
+    if (flags.editor) {
+      try {
+        const mdFile = temporaryMD();
+        await openEditor(mdFile);
+
+        options.content = fs.readFileSync(mdFile).toString();
+      } catch (e) {
+        this.error(e as Error);
+      }
     }
 
     try {
-      const APIClient = await this.getAPIClient()
-      const note = await APIClient.createNote(options)
+      const APIClient = await this.getAPIClient();
+      const note = await APIClient.createNote(options);
 
-      CliUx.ux.table([note], {
-        id: {
-          header: 'ID',
-        },
-        title: {},
-        userPath: {
-          header: 'User path'
+      CliUx.ux.table(
+        [note],
+        {
+          id: {
+            header: "ID",
+          },
+          title: {},
+          userPath: {
+            header: "User path",
+          },
+          teamPath: {
+            header: "Team path",
+          },
         },
-        teamPath: {
-          header: 'Team path'
+        {
+          printLine: this.log.bind(this),
+          ...flags,
         }
-      }, {
-        printLine: this.log.bind(this),
-        ...flags
-      })
+      );
     } catch (e) {
-      this.log('Create note failed')
-      this.error(e as Error)
+      this.log("Create note failed");
+      this.error(e as Error);
     }
   }
 }

src/openEditor.ts

@@ -0,0 +1,45 @@
+import { spawn, ChildProcess } from "child_process";
+
+interface EditorOptions {
+  editor?: string;
+}
+
+export function openEditor(
+  file: string,
+  opts: EditorOptions = {}
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const editor = getEditor(opts.editor);
+    const args = editor.split(/\s+/);
+    const bin = args.shift();
+
+    if (!bin) {
+      reject(new Error("Editor binary not found"));
+      return;
+    }
+
+    console.debug(`Opening ${file} with ${bin} ${args.join(" ")}`);
+
+    const ps: ChildProcess = spawn(bin, [...args, file], { stdio: "inherit" });
+
+    ps.on("exit", (code: number, sig: NodeJS.Signals) => {
+      resolve();
+    });
+
+    ps.on("error", (err: Error) => {
+      reject(err);
+    });
+  });
+}
+
+function getEditor(editor?: string): string {
+  return (
+    editor || process.env.VISUAL || process.env.EDITOR || getDefaultEditor()
+  );
+}
+
+function getDefaultEditor(): string {
+  return /^win/.test(process.platform) ? "notepad" : "vim";
+}
+
+export default openEditor;

src/utils.ts

@@ -1,5 +1,5 @@
 import fs from 'fs'
-import {homedir} from 'os'
+import {homedir, tmpdir} from 'os'
 import * as path from 'path'
 
 export function getConfigFilePath() {
@@ -32,3 +32,12 @@ export function safeStdinRead() {
   } catch {}
   return result
 }
+
+// generate temporary markdown file in /tmp directory
+export function temporaryMD() {
+  const tmpDir = tmpdir();
+  const filename = `temp_${Math.random().toString(36).substring(2)}.md`;
+  const filePath = path.join(tmpDir, filename);
+
+  return filePath;
+}