Modules (require)

fs — files & directories

var fs = require('fs');

Synchronous filesystem via AmigaOS DOS. All operations take AmigaOS-style paths (RAM:foo.txt, SYS:s/startup-sequence).

http — HTTP client & server

var http = require('http');

HTTP/1.0 client and server over bsdsocket.library. HTTPS requires AmiSSL (see below).

Client

Server

In the handler:

• req.method, req.url, req.headers (object), req.body (string)
• res.writeHead(status, headers), res.write(chunk), res.end(chunk?)

HTTPS / AmiSSL

net — raw TCP

Currently exposes the same get/request/createServer as http. For a dedicated low-level TCP API, use the FFI module to call bsdsocket.library directly.

buffer

var { Buffer } = require('buffer');  // also available as global

Same Buffer as described in Global API → Buffer. The module export additionally provides Buffer as a named property for Node.js portability.

os — system info

var os = require('os');

Constants: os.EOL = "\n", os.devNull = "NIL:", os.constants.signals.SIGINT=2, os.constants.signals.SIGTERM=15.

path — path manipulation

var path = require('path');

Uses AmigaOS conventions: absolute paths contain : (e.g. SYS:foo/bar), relative don't.

Constants: path.sep = '/', path.delimiter = ';'.

url — URL parsing

var url = require('url');

Legacy API

WHATWG URL

querystring

var qs = require('querystring');

Standard Node.js querystring semantics: repeated keys become arrays on parse; arrays produce multiple key=value pairs on stringify.

events — EventEmitter

var EventEmitter = require('events');
var bus = new EventEmitter();
bus.on('ready', () => console.log('go!'));
bus.emit('ready');

Methods: on(event, fn), off(event, fn), once(event, fn), emit(event, ...args), removeListener, removeAllListeners(event?), listenerCount(event), listeners(event), setMaxListeners(n), eventNames(), prependListener, prependOnceListener. Aliases: addListener = on.

stream

var stream = require('stream');

Pure-JS implementations of Readable, Writable, Duplex, Transform, PassThrough, plus helpers pipeline(...streams, cb) and finished(stream, cb).

var r = new stream.Readable({ read() {} });
r.on('data', chunk => console.log(chunk));
r.push('hello');
r.push(null); // end

Supports pipe(dest), backpressure, highWaterMark (default 16), cork/uncork on Writable.

util

var util = require('util');

Legacy type predicates: util.isArray/isFunction/isString/isNumber/isBoolean/isNull/isUndefined/isNullOrUndefined/isObject/isPrimitive.

Also: util.noop, util.debuglog(section) (currently returns a no-op).

assert

var assert = require('assert');
assert(x > 0, 'x must be positive');

Methods: assert.ok, assert.equal/notEqual, strictEqual/notStrictEqual, deepEqual/notDeepEqual, deepStrictEqual/notDeepStrictEqual, throws(fn, expected?, msg?), doesNotThrow, fail(msg), ifError(err), match(str, re, msg?), doesNotMatch, rejects(p), doesNotReject(p).

The callable module itself behaves as assert.ok.

zlib

var zlib = require('zlib');

crypto

var crypto = require('crypto');
var hash = crypto.createHash('sha256').update('hello').digest('hex');

The hasher has update(data) (returns this, chainable) and digest(encoding?). Only 'hex' encoding is supported — the encoding argument is accepted but ignored for other values.

No HMAC, no ciphers — plain hash functions only.

readline

var readline = require('readline');
var rl = readline.createInterface({ prompt: '> ' });
rl.question('Name? ', name => { console.log('Hi '+name); rl.close(); });

Interface methods: question(prompt, cb), prompt(), setPrompt(str), close(), on('line', fn), on('close', fn).

No line-editing (cursor keys, history) in this module — those work in the REPL via process.stdin at a lower level. Use it for simple input prompts.

dns

var dns = require('dns');

Under the hood, all of these call inet_addr/gethostbyname; the async signatures are for Node.js portability — the resolution is synchronous, the callback fires immediately.

timers (promise-based)

var timers = require('timers/promises');  // or just 'timers'
await timers.setTimeout(500, 'done');

string_decoder

var { StringDecoder } = require('string_decoder');

Converts Buffers to strings while handling multi-byte UTF-8 boundaries. Useful when reading a stream chunk by chunk.

new StringDecoder(encoding?) — default 'utf8'. Methods: write(buf), end(buf?). Incomplete trailing bytes are buffered internally and surfaced as a replacement character \uFFFD on end() if they never complete.

punycode

var punycode = require('punycode');
punycode.toASCII('münchen.de');   // 'xn--mnchen-3ya.de'

RFC 3492 IDN encoder/decoder: encode, decode, toASCII, toUnicode, plus ucs2.decode/ucs2.encode.

console (module), constants

var c = require('console');       // same as global console
var K = require('constants');     // POSIX errno & signal names

require('console') simply re-exports the global console object.

require('constants') exposes POSIX-ish numeric codes: signals (SIGTERM=15, ...), errno (ENOENT=2, ...), fs constants (O_RDONLY=0, O_CREAT=64, ...). Values follow BSD conventions, not Amiga IoErr codes — use them for code portability, not for comparing against actual AmigaDOS errors.

iff — IFF/ILBM/8SVX parser

var iff = require('iff');
var img = iff.parseILBM(iff.parseFile('RAM:pic.iff'));

Pure-JS parser for Amiga's native Interchange File Format. Handles ILBM images and 8SVX audio in particular.

child_process

var cp = require('child_process');
var out = cp.execSync('version');

gui — GadTools widget toolkit

var gui = require('gui');
var win = gui.createWindow({ title: 'Demo', width: 300, height: 150,
    gadgets: [{ kind: 'button', id: 1, label: 'Click me',
                left: 10, top: 10, width: 100, height: 14 }]});
while (true) {
    var evt = gui.waitEvent(win);
    if (evt.type === 'close') break;
    if (evt.type === 'gadgetup' && evt.id === 1) console.log('clicked');
}
gui.closeWindow(win);

High-level GUI using gadtools.library. Handles layout, resizing, events, menus.

Windows

Requesters

Gadget kinds

Pass these in gadgets: array when creating a window. Each has id, left, top, width, height (pixels or 'NN%' strings for layouts relative to the window; negative values anchor from the opposite edge).

Set flex: true on a gadget to make it expand vertically to fill available space (for a listview that grows with the window).

Drawing (gui.gfx)

For custom drawing on a gui window's RastPort:

gui.gfx.setColor, setBColor, setDrawMode (0=JAM1, 1=JAM2, 2=COMPLEMENT/XOR, 4=INVERSVID), moveTo, lineTo, drawLine, drawRect, fillRect, drawCircle, fillCircle, drawEllipse, drawText, setPixel, getPixel, clear, waitTOF (vsync), innerSize, setFont.

intuition — low-level windows

var ui = require('intuition');
var win = ui.openWindow({ title: 'Raw', width: 320, height: 200 });
while (true) {
    var evt = win.waitEvent();
    if (evt.type === 'close') break;
}
win.close();

Low-level wrapper over intuition.library for plain Intuition windows — no GadTools widgets, just a blank surface you can draw on. Use this when gui is too heavy or when you want total control (games, demos, custom toolkits).

Events: close, mousedown, mouseup, mousemove, keypress (with code and key), resize (when window is resized), refresh.

Graphics (ui.gfx)

Same API surface as gui.gfx. Examples: ui.gfx.setColor(win, 1), ui.gfx.drawLine(win, 10,10, 100,50), etc.

clipboard

var clip = require('clipboard');
clip.write('hello');
var text = clip.read();
clip.clear();

Read/write the standard AmigaOS clipboard unit 0. Uses iffparse.library to read/write FTXT/CHRS chunks — compatible with all standard Amiga text editors.

arexx

var arexx = require('arexx');
var r = arexx.send('EDITOR', 'REDRAW');
console.log(r.rc, r.result);

Communicate with ARexx-aware AmigaOS applications via message ports.

amiga — FFI (call any library)

var amiga = require('amiga');
var intBase = amiga.openLibrary('intuition.library', 37);
var version = amiga.peek16(intBase, 20);  // lib_Version
amiga.closeLibrary(intBase);

Escape hatch for calling AmigaOS libraries directly from JavaScript. Useful when a feature you need isn't wrapped in a higher-level NodeAmiga module.

Libraries

Memory

Function calls

// example: exec AvailMem(MEMF_CHIP) via FFI
var execLib = amiga.execBase();
var chip = amiga.call(execLib, -216, { d1: 0x02 });  // MEMF_CHIP
console.log('Chip free:', chip, 'bytes');