index.js

#! /usr/bin/env node

// micli-send: note, renote, quote, and reaction
// Geminiさんにfixをお願いしました maybe it works :p

import { parseArgs } from 'node:util';
import { readFileSync } from 'node:fs';
import { homedir } from 'node:os';

const version = '0.1.0';
const path2env = '~/.config/micli/env.json'

const usage = `
micli Misskey CLI Client: send a note / reaction command v${version}

Usage: $ micli-send --name <profile_name> [options]
  
  --env <path_to_file>: Specify a path to the environment file 
                     (default = ~/.config/micli/env.json)
  
  --name <profile_name>: (Required) Specify the account profile name to use


  ## Reaction
  -s | --shoot <URL>: Send a Reaction to the note (with "-e") specified by the <URL> 

  -e <:custom_emoji_name:>: Specify the emoji to reaction


  ## Note
  -m <"message">: Use the <message> as main text of note, reply or quote
  
  -b | --renote <URL>: Renote (share) the note specified by the <URL> (with '-m' option to quote)

  -r | --reply <URL>: Reply to the specified note
  
  -v <visibility>: Specify the visibility range (default = public)
    * public: Will appear in all timelines
    * home: Will limited to the Home TL
    * follower: Only visible to your follower, and disable renoting (shareing)
  
  -t <user>: Specify the user to send, and limit the visibility to only this user(s)
  
  --localOnly: In this noting (posting), turn off the federation to the ActivityPub Server

  -w | --contentsWarning <explain>: Add a CW hiding with explain


  ## Other
  -d | --delete <URL>: Delete the specified note or reaction

  -h | --help: Show this help

`;

const options = {
  name: { type: 'string' },
  env: { type: 'string' },
  help: { type: 'boolean', short: 'h' },
  delete: { type: 'string', short: 'd' },
  shoot: { type: 'string', short: 's' },
  emote: { type: 'string', short: 'e' },
  message: { type: 'string', short: 'm' },
  renote: { type: 'string', short: 'b' },
  reply: { type: 'string', short: 'r' },
  visibility: { type: 'string', short: 'v' },
  to: { type: 'string', short: 't', multiple: true },
  localOnly: { type: 'boolean' },
  contentsWarning: { type: 'string', short: 'w' }
};

const expandPath = path => path.replace(/^~(?=$|\/|\\)/, homedir());

const file2obj = (path) => {
  let result;

  try {
    const txt = readFileSync(expandPath(path));
    result = JSON.parse(txt);
  } catch (err) {
    console.error(`Error: Could not read or parse ${path}`);
    console.error(err.message);
    process.exit(1);
  }
  return result;
};

const post2mi = async (prof, endpoint, data = {}) => {
  const url = `https://${prof.server}/api/${endpoint}`;
  let response;

  try {
    response = await fetch(url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        ...data,
        i: prof.token,
      }),
    });
     
    if (!response.ok) {
      const errorBody = await response.text();
      throw new Error(`API Error (${response.status}): ${errorBody}`);
    }
  } catch (err) {
    console.error('Failed to request to Misskey server: ', endpoint);
    console.error(err.message);
    process.exit(1);
  }
  
  if (response.status === 204) return {};
  const text = await response.text();
  return text ? JSON.parse(text) : {};
};

const getNoteId = async (prof, uri) => {
  const res = await post2mi(prof, 'ap/show', { uri });
  return res.object.id;
};

const isContained = args => args.some(v => v != null);

const isOwnNote = async (prof, noteId) => {
  const note = await post2mi(prof, 'notes/show', { noteId });
  const me = await post2mi(prof, 'i');
  return note.user.id === me.id;
} 


const main = async () => {
  const { values: args } = parseArgs({ options });
  
  if (args.help || !args.name) {
    console.log(usage);
    process.exit(0);
  }
  const env = file2obj(args.env || path2env);
  const prof = env.profiles.find(p => p.name === args.name);

  if (!prof) {
    console.error(`Error: Profile "${args.name}" not found in ${args.env || path2env}`);
    process.exit(1);
  }

  const visibility = (args.to != null && args.to.length > 0) ? 'specified'
    : args.visibility || 'public';
  
  let noteId;
  if (isContained([ args.shoot, args.renote, args.reply, args.delete ])) {
    noteId = await getNoteId(prof, args.shoot || args.renote || args.reply || args.delete);
  }

  if (args.shoot != null) {
    if (isContained([ args.message, args.renote, args.reply ])) {
      console.error('Error: Cannot reaction and note at the same time!');
      process.exit(1);
    }
    await post2mi(prof, 'notes/reactions/create', {
      noteId: noteId,
      reaction: args.emote
    });
  } else if (args.reply != null) {
    if (args.message == null) {
      console.error('Error: Contents is empty');
      process.exit(1);
    }
    // reply
    await post2mi(prof, 'notes/create', {
      visibility: visibility,
      visibleUserIds: args.to || [],
      cw: args.contentsWarning || null,
      localOnly: args.localOnly || false,
      replyId: noteId,
      text: args.message,
    });
  } else if (args.renote != null) {
    if (args.message != null) {
      // quote
      await post2mi(prof, 'notes/create', {
        visibility: visibility,
        visibleUserIds: args.to || [],
        cw: args.contentsWarning || null,
        localOnly: args.localOnly || false,
        renoteId: noteId,
        text: args.message,
      });
    } else {
      // rn
      await post2mi(prof, 'notes/create', {
        visibility: visibility,
        visibleUserIds: args.to || [],
        localOnly: args.localOnly || false,
        renoteId: noteId
      });
    }
  } else if (args.delete != null) {
    if (!(await isOwnNote(prof, noteId))) {
      await post2mi(prof, 'notes/reactions/delete', {
        noteId: noteId
      });
    } else {
      await post2mi(prof, 'notes/delete', {
        noteId: noteId
      });
    }
  } else {
    if (args.message == null) {
      console.error('Error: Contents is empty');
      process.exit(1);
    }
    // plain-vanilla note
    await post2mi(prof, 'notes/create', {
      visibility: visibility,
      visibleUserIds: args.to || [],
      cw: args.contentsWarning || null,
      localOnly: args.localOnly || false,
      text: args.message,
    });
  }
};

main().catch(err => {
  console.error(err);
  process.exit(1);
});