SwissKnife : Scriptable VSCode Extension To Generate Or Manipulate Data

The developers SwissKnife. Do conversions and generations right out of vs code. Extendable with user scripts.

Currently Available Scripts

  • Base64 decode
  • Base64 encode
  • Binary To Text
  • Bip39 Mnemonic
  • CSV to Markdown
  • Count characters
  • Count words
  • Crypto currency value
  • Date to Timestamp
  • Eliptic Curve Key Pair
  • Generate Password
  • HTML Encode (AlL)
  • Hex decode
  • Hex encode
  • Hex to RGB
  • Identify hash
  • JWT Decode
  • Join lines
  • Lorem Ipsum
  • Markdown to HTML
  • Md5 hash
  • New Swissknife Script (JS)
  • New Swissknife Script (TS)
  • Password strength
  • RGB To Hex
  • RSA Key pair
  • Random String
  • Request to fetch
  • SHA1 hash
  • SHA256 hash
  • SHA512 hash
  • Self Signed Certificate
  • Start Local HTTP Server
  • Start Local HTTPS Server
  • Stop HTTP Server
  • Text To Binary
  • Text to String
  • Timestamp to Date
  • To Camel Case
  • To Lower Case
  • To Morse code
  • To Upper Case
  • UUIDv4
  • Unicode decode
  • Unicode encode (js format)
  • Unix/Linux Permission To Human Readable
  • Url Decode
  • Url Encode
  • Url Encode (All Characters)
  • Url Shorten
  • Url Unshorten (url expand)


You can invoke the dedicated command pallete with ctrl+shift+9 for windows or cmd+shift+9 for mac (when focusing the editor)

The conversions will only use the selected text by default. If no text is selected the entire content of the editor will be used. It supports multi selection and will run the script for each selection individually

Macbook Touchbar Support You can also invoke the swissknife extension directly from the macbook’s touchbar.

Scripts Details

Crypto Currency Value

Uses the API from Cryptonator. You can specify conversions directly from the text like:

1btc to eur

For a list of supported currencies check here

Identify Hash

The outcome of the operation may return multiple values, as a hashes from different algorithms have the same output format. Still we organize the hashes from top down by most relevant.

HTTP(S) Server

The servers log all requests received into the “Output” window of VSCode (You can show it by going to view -> Output in the menu). Then on the right of the window (where usually has the value “Tasks”), filter by “Swissknife Server”

Privacy Note

One of the main purposes of this extension is to stop pasting data, or trusting generated data from random websites. The extension avoids doing external web requests or logging data, for privacy. But there are some operations where external requests are needed:

  • Crypto Currency Value – Does a request to the cryptonator api to get the available cryptocurrencies and a request to get the current price for a specific pair. The amount being converted is not sent, this is calculated on the local machine.
  • Url Unshorten – This one really needs to do the request to the short url, so it can get the redirect (full) url. But keep in mind that the full url is never reached, the extension does not follow the redirect.
  • URL Shortening – The shortening feature uses to register a new short URL.

Writing Scripts

Swissknife will automatically load all scripts in its user scripting folder and you can find it by executing a command. Open you command pallete and type “Open swissknife users script folder”. Or just start typing it as it will eventually be suggested. This is the folder where you can create your custom scripts.

To start a new script you can also use a command provided by the extension. Open swissknife picker and type “New swissknife script”.

Script Reloading

Scripts are loaded into the extension when initializing VS Code, so when you create a custom script you’ll need to reload the scripts. To make it easier for development, the extension has a command “Reload Swissknife Scripts” that you can call from the VS Code command pallette (do not confuse with the swissknife’s script launcher).

Remember that everytime you do a change in a script in the user script folder you need to reload scripts.

Starting Template

You can chose the TS or JS version according to what you’re more comfortable with. TS will be more complex as you need to transpile it to JS. We’ll go with Javascript. This is the base structure of the script:

Object.defineProperty(exports, “__esModule”, { value: true });
exports.doSomething = async (text, context) => {
return new Promise((resolve, reject) => {
resolve(text.replace(/a/g, “b”));
const scripts = [
title: “My Script”,
detail: “This script does something”,
cb: (context) => context.replaceRoutine(exports.doSomething)
exports.default = scripts;

This is the basic template to create scripts. In this file we created a script called “My Script”. You can have as much scripts as you want per file. Its just a way of organization 🙂 As you can see at the end, the structure for a script consists on 3 properties: title, detail and cb. The first two are self explanatory. cb is the code that will be called when you script runs. And by default swissknife gives you a few methods to help getting started, through the variable ‘context’. The method doSomething is just replacing a’s with b’s


In context you have some nice methods to help you out, and you should use them whenever possible.

  • insertRoutine(cb) – This method will insert the resolved content into the cursor on editor. It will call cb and send context as a parameter. cb is expected to be async
  • informationRoutine(cb) – This method will create a notification with the resolved content. It will call cb and send selected text in editor (all text if no selection) and context as a parameter. cb is expected to be async
  • replaceRoutine(cb) – This method will replace selected text in editor, with the resolved content from cb (if no text selected it replaces all text). It will call cb and send selected text in editor (all text if no selection) and context as a parameter. cb is expected to be async
  • vscode – This variable holds the vscode api.
  • modules – This variable is an array of all JS modules inside the script (and lib) folder. You can use them to call methods from the native scripts, to reuse code logic. Ex: context.modules.passwords.generateSecureCharCode())

The use of this methods is optional. If you feel that its easier to just work directly with vscode api you can also do it:

Object.defineProperty(exports, “__esModule”, { value: true });
const scripts = [
title: “My Script2”,
detail: “This script does something”,
cb: (context) => {
const editor = context.vscode.window.activeTextEditor;
editor.edit((edit) => {
edit.insert(editor.selection.myactive, “Doing stuff”)
exports.default = scripts;

More Examples

Object.defineProperty(exports, “__esModule”, { value: true });
//Uses the context.modules to reuse existing code. Starts an http server
exports.startServer = async (context) => {
context.modules.lib.server.start({ port: 1234 })
//uses context.userModules to invoke another user script
//there will be an entry in context.userModules with the name of the file with scripts loaded
//all exported methods are accessible…
//If invoking a script remember to send the right params, like the context
exports.anotherUserScript = async (context) => {
//Ask user for input
exports.askInput = async (context) => {
return new Promise((resolve, reject) => {
context.vscode.window.showInputBox({ prompt: “Say something” }).then(answer => {
const scripts = [
title: “Ask Input”,
detail: “Asks user input and adds it to the editor”,
cb: (context) => context.insertRoutine(this.askInput)
title: “Start server on port 1234”,
detail: “Starts a server on port 1234”,
cb: (context) => this.startServer(context)
title: “Call Another User script”,
detail: “Calls Another User script”,
cb: (context) => context.insertRoutine(this.anotherUserScript)
exports.default = scripts;