kakaoforge 1.0.0

package/dist/net/upload-client.js

@@ -0,0 +1,209 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadMultipartFile = uploadMultipartFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const zlib = __importStar(require("zlib"));
+const crypto = __importStar(require("crypto"));
+const url_1 = require("url");
+function isGzip(headers) {
+    const encoding = headers?.['content-encoding'] || headers?.['Content-Encoding'];
+    if (!encoding)
+        return false;
+    return String(encoding).toLowerCase().includes('gzip');
+}
+function toBuffer(input) {
+    return Buffer.from(input, 'utf-8');
+}
+function collectFieldBuffers(fields, boundary) {
+    const buffers = [];
+    if (!fields)
+        return buffers;
+    const pushField = (key, value) => {
+        const content = value === undefined || value === null ? '' : String(value);
+        const part = `--${boundary}\r\n`
+            + `Content-Disposition: form-data; name="${key}"\r\n\r\n`
+            + `${content}\r\n`;
+        buffers.push(toBuffer(part));
+    };
+    for (const [key, value] of Object.entries(fields)) {
+        if (Array.isArray(value)) {
+            for (const item of value)
+                pushField(key, item);
+        }
+        else {
+            pushField(key, value);
+        }
+    }
+    return buffers;
+}
+function uploadMultipartFile(opts) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const done = (err, res) => {
+            if (settled)
+                return;
+            settled = true;
+            if (err)
+                reject(err);
+            else
+                resolve(res);
+        };
+        if (!opts?.url) {
+            done(new Error('upload url is required'));
+            return;
+        }
+        if (!opts?.filePath) {
+            done(new Error('filePath is required'));
+            return;
+        }
+        if (!fs.existsSync(opts.filePath)) {
+            done(new Error(`file not found: ${opts.filePath}`));
+            return;
+        }
+        let fileStat;
+        try {
+            fileStat = fs.statSync(opts.filePath);
+        }
+        catch (err) {
+            done(err);
+            return;
+        }
+        const boundary = `----KakaoForge${crypto.randomBytes(8).toString('hex')}`;
+        const fieldName = opts.fieldName || 'file_1';
+        const filename = opts.filename || path.basename(opts.filePath);
+        const mime = opts.mime || 'application/octet-stream';
+        const fieldBuffers = collectFieldBuffers(opts.fields || {}, boundary);
+        const fileHeader = `--${boundary}\r\n`
+            + `Content-Disposition: form-data; name="${fieldName}"; filename="${filename}"\r\n`
+            + `Content-Type: ${mime}\r\n\r\n`;
+        const fileHeaderBuf = toBuffer(fileHeader);
+        const fileFooterBuf = toBuffer('\r\n');
+        const closingBuf = toBuffer(`--${boundary}--\r\n`);
+        const totalLength = fieldBuffers.reduce((sum, buf) => sum + buf.length, 0)
+            + fileHeaderBuf.length
+            + fileStat.size
+            + fileFooterBuf.length
+            + closingBuf.length;
+        let url;
+        try {
+            url = new url_1.URL(opts.url);
+        }
+        catch {
+            done(new Error(`invalid upload url: ${opts.url}`));
+            return;
+        }
+        const isHttps = url.protocol === 'https:';
+        const request = (isHttps ? https : http).request({
+            method: 'POST',
+            hostname: url.hostname,
+            port: url.port ? Number(url.port) : (isHttps ? 443 : 80),
+            path: `${url.pathname}${url.search}`,
+            headers: {
+                'Content-Type': `multipart/form-data; boundary=${boundary}`,
+                'Content-Length': totalLength,
+                'Accept': '*/*',
+                ...opts.headers,
+            },
+        }, (res) => {
+            const chunks = [];
+            const stream = isGzip(res.headers) ? res.pipe(zlib.createGunzip()) : res;
+            stream.on('data', (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+            stream.on('error', (err) => done(err));
+            stream.on('end', () => {
+                const body = Buffer.concat(chunks).toString('utf-8');
+                let json;
+                try {
+                    json = JSON.parse(body);
+                }
+                catch {
+                    json = undefined;
+                }
+                const response = {
+                    statusCode: res.statusCode || 0,
+                    headers: res.headers,
+                    body,
+                    json,
+                };
+                if (response.statusCode < 200 || response.statusCode >= 300) {
+                    done(new Error(`upload failed: status=${response.statusCode} body=${body}`));
+                    return;
+                }
+                done(undefined, response);
+            });
+        });
+        request.on('error', (err) => done(err));
+        if (opts.timeoutMs && opts.timeoutMs > 0) {
+            request.setTimeout(opts.timeoutMs, () => {
+                request.destroy(new Error('upload timed out'));
+            });
+        }
+        let sent = 0;
+        const reportProgress = () => {
+            if (opts.onProgress) {
+                opts.onProgress(sent, totalLength);
+            }
+        };
+        const writeBuffer = (buf) => {
+            if (!buf || buf.length === 0)
+                return;
+            request.write(buf);
+            sent += buf.length;
+            reportProgress();
+        };
+        for (const buf of fieldBuffers) {
+            writeBuffer(buf);
+        }
+        writeBuffer(fileHeaderBuf);
+        const stream = fs.createReadStream(opts.filePath);
+        stream.on('data', (chunk) => {
+            sent += chunk.length;
+            reportProgress();
+        });
+        stream.on('error', (err) => {
+            request.destroy();
+            done(err);
+        });
+        stream.on('end', () => {
+            writeBuffer(fileFooterBuf);
+            writeBuffer(closingBuf);
+            request.end();
+        });
+        stream.pipe(request, { end: false });
+    });
+}

package/dist/protocol/loco-packet.d.ts

@@ -0,0 +1,19 @@
+import { BSON } from 'bson';
+export declare const HEADER_SIZE = 22;
+export declare class LocoPacket {
+    packetId: number;
+    status: number;
+    method: string;
+    body: any;
+    constructor(packetId: number, status: number, method: string, body?: any);
+    serialize(): Buffer<ArrayBuffer>;
+    static parseHeader(buf: Buffer): {
+        packetId: number;
+        status: number;
+        method: string;
+        bodyLength: number;
+    };
+    static parseBody(bodyBuf: Buffer): BSON.Document;
+    static fromBuffer(buf: Buffer): LocoPacket;
+    toString(): string;
+}

package/dist/protocol/loco-packet.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocoPacket = exports.HEADER_SIZE = void 0;
+const bson_1 = require("bson");
+exports.HEADER_SIZE = 22;
+const METHOD_LENGTH = 11;
+class LocoPacket {
+    constructor(packetId, status, method, body = {}) {
+        this.packetId = packetId;
+        this.status = status;
+        this.method = method;
+        this.body = body;
+    }
+    serialize() {
+        const bodyBytes = bson_1.BSON.serialize(this.body);
+        const header = Buffer.alloc(exports.HEADER_SIZE);
+        header.writeInt32LE(this.packetId, 0);
+        header.writeInt16LE(this.status, 4);
+        const methodBuf = Buffer.alloc(METHOD_LENGTH, 0);
+        Buffer.from(this.method, 'utf8').copy(methodBuf, 0, 0, METHOD_LENGTH);
+        methodBuf.copy(header, 6);
+        header.writeUInt8(0, 17);
+        header.writeInt32LE(bodyBytes.length, 18);
+        return Buffer.concat([header, bodyBytes]);
+    }
+    static parseHeader(buf) {
+        if (buf.length < exports.HEADER_SIZE)
+            return null;
+        const packetId = buf.readInt32LE(0);
+        const status = buf.readInt16LE(4);
+        const methodRaw = buf.subarray(6, 17);
+        const nullIdx = methodRaw.indexOf(0);
+        const method = methodRaw.subarray(0, nullIdx === -1 ? METHOD_LENGTH : nullIdx).toString('utf8').trim();
+        const bodyLength = buf.readInt32LE(18);
+        return { packetId, status, method, bodyLength };
+    }
+    static parseBody(bodyBuf) {
+        if (bodyBuf.length === 0)
+            return {};
+        return bson_1.BSON.deserialize(bodyBuf);
+    }
+    static fromBuffer(buf) {
+        const header = LocoPacket.parseHeader(buf);
+        if (!header)
+            return null;
+        const bodyBuf = buf.subarray(exports.HEADER_SIZE, exports.HEADER_SIZE + header.bodyLength);
+        const body = LocoPacket.parseBody(bodyBuf);
+        return new LocoPacket(header.packetId, header.status, header.method, body);
+    }
+    toString() {
+        return `LocoPacket(id=${this.packetId}, status=${this.status}, method=${this.method}, bodyLen=${JSON.stringify(this.body).length})`;
+    }
+}
+exports.LocoPacket = LocoPacket;

package/dist/types/attachments.d.ts

@@ -0,0 +1,17 @@
+import type { MessageTypeValue } from './message';
+export declare const AttachmentTypes: {
+    readonly Photo: "photo";
+    readonly Video: "video";
+    readonly Audio: "audio";
+    readonly File: "file";
+    readonly Contact: "contact";
+    readonly Location: "location";
+    readonly Schedule: "schedule";
+    readonly Link: "link";
+    readonly Unknown: "unknown";
+};
+export type AttachmentType = typeof AttachmentTypes[keyof typeof AttachmentTypes];
+export type MessageAttachment = {
+    type: MessageTypeValue;
+    raw: any;
+};

package/dist/types/attachments.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachmentTypes = void 0;
+exports.AttachmentTypes = {
+    Photo: 'photo',
+    Video: 'video',
+    Audio: 'audio',
+    File: 'file',
+    Contact: 'contact',
+    Location: 'location',
+    Schedule: 'schedule',
+    Link: 'link',
+    Unknown: 'unknown',
+};

package/dist/types/member-type.d.ts

@@ -0,0 +1,8 @@
+export declare const MemberType: {
+    readonly OpenChat: {
+        readonly Owner: 1;
+        readonly Manager: 4;
+        readonly Member: 2;
+    };
+};
+export type MemberTypeValue = typeof MemberType.OpenChat[keyof typeof MemberType.OpenChat] | number;

package/dist/types/member-type.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberType = void 0;
+exports.MemberType = {
+    OpenChat: {
+        Owner: 1,
+        Manager: 4,
+        Member: 2,
+    },
+};

package/dist/types/message.d.ts

@@ -0,0 +1,14 @@
+export declare const MessageType: {
+    readonly Text: 1;
+    readonly Photo: 2;
+    readonly Video: 3;
+    readonly Contact: 4;
+    readonly Audio: 5;
+    readonly Link: 9;
+    readonly Schedule: 13;
+    readonly Location: 16;
+    readonly Profile: 17;
+    readonly File: 18;
+    readonly Reply: 26;
+};
+export type MessageTypeValue = typeof MessageType[keyof typeof MessageType] | number;

package/dist/types/message.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageType = void 0;
+exports.MessageType = {
+    Text: 1,
+    Photo: 2,
+    Video: 3,
+    Contact: 4,
+    Audio: 5,
+    Link: 9,
+    Schedule: 13,
+    Location: 16,
+    Profile: 17,
+    File: 18,
+    Reply: 26,
+};

package/dist/types/reaction.d.ts

@@ -0,0 +1,10 @@
+export declare const Reactions: {
+    readonly CANCEL: 0;
+    readonly HEART: 1;
+    readonly LIKE: 2;
+    readonly CHECK: 3;
+    readonly LAUGH: 4;
+    readonly SURPRISE: 5;
+    readonly SAD: 6;
+};
+export type ReactionTypeValue = (typeof Reactions)[keyof typeof Reactions];

package/dist/types/reaction.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reactions = void 0;
+exports.Reactions = {
+    CANCEL: 0,
+    HEART: 1,
+    LIKE: 2,
+    CHECK: 3,
+    LAUGH: 4,
+    SURPRISE: 5,
+    SAD: 6,
+};

package/dist/util/client-msg-id.d.ts

@@ -0,0 +1 @@
+export declare function nextClientMsgId(seed: string, timeMillis?: number): number;

package/dist/util/client-msg-id.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextClientMsgId = nextClientMsgId;
+const MAX_MOD = 2147483547;
+const STEP = 100;
+const stateBySeed = new Map();
+function javaStringHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i += 1) {
+        hash = (hash * 31 + str.charCodeAt(i)) | 0;
+    }
+    return hash;
+}
+function baseId(timeMillis, deviceHash) {
+    const base = Math.floor((timeMillis % MAX_MOD) / STEP) * STEP;
+    return base + deviceHash;
+}
+function getState(seed) {
+    const key = seed || '';
+    let state = stateBySeed.get(key);
+    if (!state) {
+        const deviceHash = javaStringHash(key) % 100;
+        const initial = baseId(Date.now(), deviceHash);
+        state = {
+            deviceHash,
+            lastId: initial,
+            lastGenId: initial,
+        };
+        stateBySeed.set(key, state);
+    }
+    return state;
+}
+function nextClientMsgId(seed, timeMillis = Date.now()) {
+    const state = getState(seed);
+    const gen = baseId(timeMillis, state.deviceHash);
+    if (gen <= state.lastId && gen >= state.lastGenId) {
+        let next = state.lastId + STEP;
+        if (next > 2147483647) {
+            next = baseId(next, state.deviceHash);
+        }
+        state.lastId = next;
+        state.lastGenId = gen;
+        return state.lastId;
+    }
+    state.lastId = gen;
+    state.lastGenId = gen;
+    return state.lastId;
+}

package/dist/util/media.d.ts

@@ -0,0 +1,6 @@
+export type ImageSize = {
+    width: number;
+    height: number;
+};
+export declare function guessMime(filePath: string, fallback?: string): string;
+export declare function readImageSize(filePath: string): ImageSize | null;

package/dist/util/media.js

@@ -0,0 +1,173 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guessMime = guessMime;
+exports.readImageSize = readImageSize;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const MIME_BY_EXT = {
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.bmp': 'image/bmp',
+    '.heic': 'image/heic',
+    '.heif': 'image/heif',
+    '.mp4': 'video/mp4',
+    '.m4v': 'video/x-m4v',
+    '.mov': 'video/quicktime',
+    '.mkv': 'video/x-matroska',
+    '.webm': 'video/webm',
+    '.mp3': 'audio/mpeg',
+    '.m4a': 'audio/mp4',
+    '.wav': 'audio/wav',
+    '.ogg': 'audio/ogg',
+    '.flac': 'audio/flac',
+    '.pdf': 'application/pdf',
+    '.txt': 'text/plain',
+    '.json': 'application/json',
+    '.zip': 'application/zip',
+    '.7z': 'application/x-7z-compressed',
+    '.rar': 'application/x-rar-compressed',
+};
+function guessMime(filePath, fallback = 'application/octet-stream') {
+    const ext = path.extname(filePath || '').toLowerCase();
+    if (!ext)
+        return fallback;
+    return MIME_BY_EXT[ext] || fallback;
+}
+function readPngSize(buffer) {
+    if (buffer.length < 24)
+        return null;
+    const signature = buffer.subarray(0, 8);
+    if (!signature.equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) {
+        return null;
+    }
+    const width = buffer.readUInt32BE(16);
+    const height = buffer.readUInt32BE(20);
+    if (!width || !height)
+        return null;
+    return { width, height };
+}
+function readGifSize(buffer) {
+    if (buffer.length < 10)
+        return null;
+    const header = buffer.toString('ascii', 0, 3);
+    if (header !== 'GIF')
+        return null;
+    const width = buffer.readUInt16LE(6);
+    const height = buffer.readUInt16LE(8);
+    if (!width || !height)
+        return null;
+    return { width, height };
+}
+function isJpegStart(buffer) {
+    return buffer.length >= 2 && buffer[0] === 0xff && buffer[1] === 0xd8;
+}
+function isJpegSof(marker) {
+    return (marker === 0xc0 ||
+        marker === 0xc1 ||
+        marker === 0xc2 ||
+        marker === 0xc3 ||
+        marker === 0xc5 ||
+        marker === 0xc6 ||
+        marker === 0xc7 ||
+        marker === 0xc9 ||
+        marker === 0xca ||
+        marker === 0xcb ||
+        marker === 0xcd ||
+        marker === 0xce ||
+        marker === 0xcf);
+}
+function readJpegSize(buffer) {
+    if (!isJpegStart(buffer))
+        return null;
+    let offset = 2;
+    while (offset + 9 < buffer.length) {
+        if (buffer[offset] !== 0xff) {
+            offset += 1;
+            continue;
+        }
+        let marker = buffer[offset + 1];
+        while (marker === 0xff && offset + 2 < buffer.length) {
+            offset += 1;
+            marker = buffer[offset + 1];
+        }
+        if (marker === 0xd9 || marker === 0xda)
+            break;
+        if (offset + 4 >= buffer.length)
+            break;
+        const segmentLength = buffer.readUInt16BE(offset + 2);
+        if (segmentLength < 2)
+            break;
+        if (isJpegSof(marker)) {
+            if (offset + 7 >= buffer.length)
+                break;
+            const height = buffer.readUInt16BE(offset + 5);
+            const width = buffer.readUInt16BE(offset + 7);
+            if (!width || !height)
+                return null;
+            return { width, height };
+        }
+        offset += 2 + segmentLength;
+    }
+    return null;
+}
+function readImageSize(filePath) {
+    if (!filePath)
+        return null;
+    let fd = null;
+    try {
+        fd = fs.openSync(filePath, 'r');
+        const stat = fs.fstatSync(fd);
+        const length = Math.min(stat.size, 256 * 1024);
+        const buffer = Buffer.alloc(length);
+        fs.readSync(fd, buffer, 0, length, 0);
+        return readPngSize(buffer) || readGifSize(buffer) || readJpegSize(buffer);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== null) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+            }
+        }
+    }
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "kakaoforge",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "build:watch": "tsc -p tsconfig.json --watch",
+    "deploy": "npm run build && npm version patch && npm publish --access public",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aodjo/KakaoForge.git"
+  },
+  "homepage": "https://github.com/aodjo/KakaoForge#readme",
+  "bugs": {
+    "url": "https://github.com/aodjo/KakaoForge/issues"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "type": "commonjs",
+  "dependencies": {
+    "bson": "^7.1.1",
+    "hpack.js": "^2.1.6",
+    "lossless-json": "^4.3.0",
+    "protobufjs": "^8.0.0",
+    "qrcode-terminal": "^0.12.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.3"
+  }
+}