kakaoforge 1.0.0

package/dist/net/brewery-client.js

@@ -0,0 +1,419 @@
+"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.BreweryClient = exports.EventProto = exports.BREWERY_PORT = exports.BREWERY_HOST = void 0;
+const http2 = __importStar(require("http2"));
+const events_1 = require("events");
+const protobuf = __importStar(require("protobufjs"));
+exports.BREWERY_HOST = 'talk-pilsner.kakao.com';
+exports.BREWERY_PORT = 443;
+const APP_VER = '26.1.2';
+/**
+ * Protobuf Event schema (from com.kakao.talk.brewery.push.Event)
+ *
+ * message Event {
+ *   string path = 1;
+ *   string type = 2;
+ *   bytes payload = 3;
+ *   bytes padding = 4;
+ * }
+ */
+exports.EventProto = new protobuf.Type('Event')
+    .add(new protobuf.Field('path', 1, 'string'))
+    .add(new protobuf.Field('type', 2, 'string'))
+    .add(new protobuf.Field('payload', 3, 'bytes'))
+    .add(new protobuf.Field('padding', 4, 'bytes'));
+new protobuf.Root().add(exports.EventProto);
+/** Length prefix size: 4-byte big-endian uint32 */
+const LEN_PREFIX_SIZE = 4;
+/**
+ * Brewery HTTP/2 client for KakaoTalk v26.1.2+.
+ *
+ * Replaces the legacy LOCO binary protocol with HTTP/2 Retrofit-style
+ * communication to talk-pilsner.kakao.com.
+ *
+ * Usage:
+ *   const client = new BreweryClient({ oauthToken, lang });
+ *   await client.connect();
+ *   client.on('event', (event) => { ... });
+ *   client.startListen();
+ */
+class BreweryClient extends events_1.EventEmitter {
+    constructor({ oauthToken, deviceUuid = '', lang = 'ko', appVer = APP_VER }) {
+        super();
+        this._oauthToken = oauthToken;
+        this._deviceUuid = deviceUuid;
+        this._lang = lang;
+        this._appVer = appVer;
+        this._session = null;
+        this._listenStream = null;
+        this._pingTimer = null;
+        this._lastSubscribed = 0;
+        this._listenBuffer = Buffer.alloc(0);
+        this._connected = false;
+    }
+    /**
+     * Common headers for all brewery requests (PILSNER auth).
+     */
+    _headers(extra = {}) {
+        return {
+            'authorization': `${this._oauthToken}-${this._deviceUuid}`,
+            'talk-agent': `android/${this._appVer}`,
+            'talk-language': this._lang,
+            ...extra,
+        };
+    }
+    /**
+     * Connect HTTP/2 session to talk-pilsner.kakao.com.
+     */
+    connect() {
+        return new Promise((resolve, reject) => {
+            this._session = http2.connect(`https://${exports.BREWERY_HOST}:${exports.BREWERY_PORT}`);
+            this._session.on('connect', () => {
+                this._connected = true;
+                console.log(`[+] HTTP/2 connected to ${exports.BREWERY_HOST}`);
+                this.emit('connected');
+                resolve();
+            });
+            this._session.on('error', (err) => {
+                console.error('[!] HTTP/2 session error:', err.message);
+                this.emit('error', err);
+                if (!this._connected)
+                    reject(err);
+            });
+            this._session.on('close', () => {
+                this._connected = false;
+                console.log('[!] HTTP/2 session closed');
+                this.emit('disconnected');
+            });
+            this._session.on('goaway', (errorCode) => {
+                console.log(`[!] HTTP/2 GOAWAY received: errorCode=${errorCode}`);
+            });
+        });
+    }
+    /**
+     * Send an HTTP/2 request and return the response.
+     * @param {string} method - HTTP method
+     * @param {string} path - URL path
+     * @param {Object} [headers] - Extra headers
+     * @param {Buffer|string} [body] - Request body
+     * @returns {Promise<{status: number, headers: Object, body: Buffer}>}
+     */
+    request(method, path, { headers = {}, body = null, timeout = 10000 } = {}) {
+        return new Promise((resolve, reject) => {
+            const reqHeaders = {
+                ':method': method,
+                ':path': path,
+                ...this._headers(headers),
+            };
+            if (body && typeof body === 'object' && !(body instanceof Buffer)) {
+                body = JSON.stringify(body);
+                reqHeaders['content-type'] = 'application/json';
+            }
+            const stream = this._session.request(reqHeaders);
+            const chunks = [];
+            const timer = setTimeout(() => {
+                stream.close();
+                reject(new Error(`Request ${method} ${path} timed out`));
+            }, timeout);
+            stream.on('response', (resHeaders) => {
+                stream.on('data', (chunk) => chunks.push(chunk));
+                stream.on('end', () => {
+                    clearTimeout(timer);
+                    const status = resHeaders[':status'];
+                    const respBody = Buffer.concat(chunks);
+                    resolve({ status, headers: resHeaders, body: respBody });
+                });
+            });
+            stream.on('error', (err) => {
+                clearTimeout(timer);
+                reject(err);
+            });
+            if (body) {
+                stream.write(body);
+            }
+            stream.end();
+        });
+    }
+    /**
+     * Send GET /ping keepalive.
+     */
+    async ping() {
+        try {
+            const res = await this.request('GET', '/ping');
+            console.log(`[<] PING response: ${res.status}`);
+            return res;
+        }
+        catch (err) {
+            console.error('[!] PING error:', err.message);
+            throw err;
+        }
+    }
+    /**
+     * Start periodic ping (default 10 min = 600000ms, matching app behavior).
+     */
+    startPing(intervalMs = 600000) {
+        this.stopPing();
+        this._pingTimer = setInterval(() => this.ping().catch(() => { }), intervalMs);
+    }
+    stopPing() {
+        if (this._pingTimer) {
+            clearInterval(this._pingTimer);
+            this._pingTimer = null;
+        }
+    }
+    /**
+     * Start listening for real-time events via GET /listen.
+     * Events are emitted as 'event' with parsed Event protobuf.
+     */
+    startListen() {
+        if (this._listenStream) {
+            console.log('[*] Listen stream already active');
+            return;
+        }
+        const reqHeaders = {
+            ':method': 'GET',
+            ':path': '/listen',
+            ...this._headers({
+                'talk-last-subscribed': String(this._lastSubscribed),
+            }),
+        };
+        console.log(`[*] Starting listen stream (lastSubscribed=${this._lastSubscribed})...`);
+        this._listenStream = this._session.request(reqHeaders);
+        this._listenBuffer = Buffer.alloc(0);
+        this._listenStream.on('response', (resHeaders) => {
+            const status = resHeaders[':status'];
+            console.log(`[+] Listen stream opened: status=${status}`);
+            if (status !== 200) {
+                console.error(`[!] Listen stream rejected: status=${status}`);
+                this._listenStream = null;
+                this.emit('listenError', new Error(`Listen returned ${status}`));
+                return;
+            }
+            this.emit('listening');
+        });
+        this._listenStream.on('data', (chunk) => {
+            this._listenBuffer = Buffer.concat([this._listenBuffer, chunk]);
+            this._processListenBuffer();
+        });
+        this._listenStream.on('end', () => {
+            console.log('[!] Listen stream ended');
+            this._listenStream = null;
+            this.emit('listenEnd');
+        });
+        this._listenStream.on('error', (err) => {
+            console.error('[!] Listen stream error:', err.message);
+            this._listenStream = null;
+            this.emit('listenError', err);
+        });
+    }
+    /**
+     * Process buffered listen data.
+     * Events arrive as length-delimited protobuf messages (varint length prefix).
+     */
+    _processListenBuffer() {
+        while (this._listenBuffer.length >= LEN_PREFIX_SIZE) {
+            // Read 4-byte big-endian length prefix
+            const msgLen = this._listenBuffer.readUInt32BE(0);
+            // Check if we have the full message
+            if (this._listenBuffer.length < LEN_PREFIX_SIZE + msgLen)
+                break;
+            // Extract the message bytes
+            const msgBytes = this._listenBuffer.slice(LEN_PREFIX_SIZE, LEN_PREFIX_SIZE + msgLen);
+            this._listenBuffer = this._listenBuffer.slice(LEN_PREFIX_SIZE + msgLen);
+            try {
+                const event = exports.EventProto.decode(msgBytes);
+                const payloadStr = event.payload && event.payload.length > 0
+                    ? Buffer.from(event.payload).toString('utf8')
+                    : null;
+                let payloadJson = null;
+                if (payloadStr) {
+                    try {
+                        payloadJson = JSON.parse(payloadStr);
+                    }
+                    catch {
+                        payloadJson = payloadStr;
+                    }
+                }
+                const parsed = {
+                    path: event.path,
+                    type: event.type,
+                    payload: payloadJson,
+                    raw: event,
+                };
+                this._lastSubscribed = Date.now();
+                this.emit('event', parsed);
+                // Emit specific event by path
+                if (event.path) {
+                    this.emit(`event:${event.path}`, parsed);
+                }
+            }
+            catch (err) {
+                // Only log non-trivial parse errors
+                if (msgBytes.length > 1) {
+                    console.error('[!] Protobuf parse error (%d bytes):', msgBytes.length, err.message);
+                    console.error('[!] Hex:', msgBytes.slice(0, 100).toString('hex'));
+                }
+            }
+        }
+    }
+    /**
+     * Stop the listen stream.
+     */
+    stopListen() {
+        if (this._listenStream) {
+            this._listenStream.close();
+            this._listenStream = null;
+        }
+    }
+    /**
+     * Send push acknowledgment.
+     * @param {Object} body - Ack payload
+     */
+    async pushAck(body) {
+        return this.request('POST', '/push-tracker/pushAck', {
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+    }
+    /**
+     * Generic GET request to a brewery path.
+     */
+    async get(path, headers = {}) {
+        return this.request('GET', path, { headers });
+    }
+    /**
+     * Generic POST request to a brewery path.
+     */
+    async post(path, body, headers = {}) {
+        return this.request('POST', path, {
+            headers: { 'content-type': 'application/json', ...headers },
+            body: typeof body === 'string' ? body : JSON.stringify(body),
+        });
+    }
+    /**
+     * Parse JSON response body, returning null on failure.
+     */
+    _parseJson(res) {
+        try {
+            return JSON.parse(res.body.toString('utf8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Fetch message metadata from a chat using bubble/sync-meta.
+     * Used by sub-devices to sync messages via REST polling.
+     *
+     * @param {number|string} chatId - Chat room ID
+     * @param {Object} [opts]
+     * @param {number} [opts.cur=0] - Current cursor position (start from this logId)
+     * @param {number} [opts.max=0] - Max logId to fetch up to (0 = latest)
+     * @param {number} [opts.cnt=50] - Number of messages to fetch
+     * @returns {Promise<{content: Array, size: number, last: boolean}>}
+     */
+    async syncMessages(chatId, { cur = 0, max = 0, cnt = 50 } = {}) {
+        const path = `/messaging/chats/${chatId}/bubble/sync-meta?cur=${cur}&max=${max}&cnt=${cnt}`;
+        const res = await this.request('GET', path, { timeout: 15000 });
+        if (res.status !== 200) {
+            throw new Error(`syncMessages failed: status=${res.status}`);
+        }
+        return this._parseJson(res) || { content: [], size: 0, last: true };
+    }
+    /**
+     * Fetch message metadata for a range of logIds.
+     *
+     * @param {number|string} chatId - Chat room ID
+     * @param {number} from - Start logId
+     * @param {number} to - End logId
+     * @param {boolean} [desc=false] - Descending order
+     * @returns {Promise<{content: Array, size: number, last: boolean}>}
+     */
+    async getMessages(chatId, from, to, desc = false) {
+        const path = `/messaging/chats/${chatId}/bubble/meta?from=${from}&to=${to}&desc=${desc}`;
+        const res = await this.request('GET', path, { timeout: 15000 });
+        if (res.status !== 200) {
+            throw new Error(`getMessages failed: status=${res.status}`);
+        }
+        return this._parseJson(res) || { content: [], size: 0, last: true };
+    }
+    /**
+     * Fetch chat tab settings (used to detect new messages across chats).
+     *
+     * @param {number} [revision=0] - Last known revision
+     * @returns {Promise<Object>}
+     */
+    async getChatTabSettings(revision = 0) {
+        const path = `/chat/tab/settings?revision=${revision}`;
+        const res = await this.request('GET', path, { timeout: 15000 });
+        if (res.status !== 200) {
+            throw new Error(`getChatTabSettings failed: status=${res.status}`);
+        }
+        return this._parseJson(res);
+    }
+    /**
+     * Fetch chat room list via GET /messaging/chats.
+     * Uses standard PILSNER auth.
+     *
+     * Returns:
+     *   { chats: [ChatInfo] }
+     * ChatInfo:
+     *   { chatId, type, title, isEnterAllowed, unreadCount,
+     *     lastMessageId, lastSeenLogId, displayMembers, ... }
+     *
+     * @returns {Promise<Object>}
+     */
+    async getChatRooms() {
+        const res = await this.request('GET', '/messaging/chats', { timeout: 15000 });
+        if (res.status !== 200) {
+            throw new Error(`getChatRooms failed: status=${res.status}`);
+        }
+        return this._parseJson(res) || { chats: [] };
+    }
+    /**
+     * Disconnect everything.
+     */
+    disconnect() {
+        this.stopPing();
+        this.stopListen();
+        if (this._session) {
+            this._session.close();
+            this._session = null;
+        }
+        this._connected = false;
+    }
+}
+exports.BreweryClient = BreweryClient;

package/dist/net/bubble-client.d.ts

@@ -0,0 +1,45 @@
+export declare const BUBBLE_HOST = "talk-pilsner.kakao.com";
+export type BubbleClientOptions = {
+    oauthToken: string;
+    deviceUuid: string;
+    deviceId?: string;
+    appVer?: string;
+    lang?: string;
+    os?: string;
+    timeZone?: string;
+    hasAccount?: string | boolean;
+    adid?: string;
+    dtype?: string | number;
+};
+export type ReactionPayload = {
+    logId: number | string;
+    type: number;
+    linkId?: number | string;
+    reqId?: number | string;
+};
+export declare class BubbleClient {
+    oauthToken: string;
+    deviceUuid: string;
+    deviceId: string;
+    appVer: string;
+    lang: string;
+    os: string;
+    timeZone: string;
+    hasAccount: string;
+    adid: string;
+    dtype: string;
+    constructor(opts: BubbleClientOptions);
+    _headers(extra?: Record<string, string>): {
+        Authorization: string;
+        A: string;
+        'User-Agent': string;
+        'talk-agent': string;
+        'talk-language': string;
+        TZ: string;
+        hasAccount: string;
+        ADID: string;
+        dtype: string;
+    };
+    _captureHeaders(res: any): void;
+    sendReaction(chatId: number | string, reaction: ReactionPayload): Promise<any>;
+}

package/dist/net/bubble-client.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BubbleClient = exports.BUBBLE_HOST = void 0;
+const login_1 = require("../auth/login");
+exports.BUBBLE_HOST = 'talk-pilsner.kakao.com';
+const BUBBLE_BASE = '/messaging/chats';
+class BubbleClient {
+    constructor(opts) {
+        this.oauthToken = opts.oauthToken;
+        this.deviceUuid = opts.deviceUuid;
+        this.deviceId = opts.deviceId || (0, login_1.buildDeviceId)(opts.deviceUuid);
+        this.appVer = opts.appVer || '26.1.2';
+        this.lang = opts.lang || 'ko';
+        this.os = opts.os || 'android';
+        this.timeZone = opts.timeZone || 'Asia/Seoul';
+        if (typeof opts.hasAccount === 'boolean') {
+            this.hasAccount = opts.hasAccount ? 'true' : 'false';
+        }
+        else if (typeof opts.hasAccount === 'string') {
+            this.hasAccount = opts.hasAccount;
+        }
+        else {
+            this.hasAccount = '';
+        }
+        this.adid = opts.adid || opts.deviceUuid || '';
+        this.dtype = opts.dtype !== undefined && opts.dtype !== null ? String(opts.dtype) : '2';
+    }
+    _headers(extra = {}) {
+        return {
+            'Authorization': (0, login_1.buildAuthorizationHeader)(this.oauthToken, this.deviceId || this.deviceUuid),
+            'A': (0, login_1.buildAHeader)(this.appVer, this.lang),
+            'User-Agent': (0, login_1.buildUserAgent)(this.appVer),
+            'talk-agent': `${this.os}/${this.appVer}`,
+            'talk-language': this.lang,
+            'TZ': this.timeZone,
+            'hasAccount': this.hasAccount,
+            'ADID': this.adid,
+            'dtype': this.dtype,
+            ...extra,
+        };
+    }
+    _captureHeaders(res) {
+        const headers = res?.headers || {};
+        const hasAccount = headers['hasaccount'] ?? headers['hasAccount'];
+        if (hasAccount !== undefined && hasAccount !== null) {
+            this.hasAccount = Array.isArray(hasAccount) ? String(hasAccount[0] ?? '') : String(hasAccount);
+        }
+    }
+    async sendReaction(chatId, reaction) {
+        const payload = {
+            logId: reaction.logId,
+            type: reaction.type,
+            reqId: reaction.reqId ?? Date.now(),
+        };
+        if (reaction.linkId !== undefined && reaction.linkId !== null && reaction.linkId !== '') {
+            payload.linkId = reaction.linkId;
+        }
+        const path = `${BUBBLE_BASE}/${encodeURIComponent(String(chatId))}/bubble/reactions`;
+        const res = await (0, login_1.httpsPostJson)(exports.BUBBLE_HOST, path, payload, this._headers());
+        this._captureHeaders(res);
+        return res;
+    }
+}
+exports.BubbleClient = BubbleClient;

package/dist/net/calendar-client.d.ts

@@ -0,0 +1,41 @@
+export declare const CALENDAR_HOST = "talk-pilsner.kakao.com";
+export type CalendarClientOptions = {
+    oauthToken: string;
+    deviceUuid: string;
+    deviceId?: string;
+    appVer?: string;
+    lang?: string;
+    os?: string;
+    timeZone?: string;
+    hasAccount?: string | boolean;
+    adid?: string;
+    dtype?: string | number;
+};
+export declare class CalendarClient {
+    oauthToken: string;
+    deviceUuid: string;
+    deviceId: string;
+    appVer: string;
+    lang: string;
+    os: string;
+    timeZone: string;
+    hasAccount: string;
+    adid: string;
+    dtype: string;
+    constructor(opts: CalendarClientOptions);
+    _headers(extra?: Record<string, string>): {
+        Authorization: string;
+        A: string;
+        'User-Agent': string;
+        'talk-agent': string;
+        'talk-language': string;
+        TZ: string;
+        hasAccount: string;
+        ADID: string;
+        dtype: string;
+    };
+    _captureHeaders(res: any): void;
+    createEvent(event: any, { referer, templateId, originalEId }?: any): Promise<any>;
+    connectEvent(eId: string, chatId: number | string, referer?: string): Promise<any>;
+    shareMessage(eId: string, referer?: string): Promise<any>;
+}

package/dist/net/calendar-client.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarClient = exports.CALENDAR_HOST = void 0;
+const login_1 = require("../auth/login");
+exports.CALENDAR_HOST = 'talk-pilsner.kakao.com';
+const CALENDAR_BASE = '/calendar/talk';
+function buildQuery(params) {
+    const parts = [];
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === null || value === '')
+            continue;
+        parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+    }
+    return parts.length > 0 ? `?${parts.join('&')}` : '';
+}
+class CalendarClient {
+    constructor(opts) {
+        this.oauthToken = opts.oauthToken;
+        this.deviceUuid = opts.deviceUuid;
+        this.deviceId = opts.deviceId || (0, login_1.buildDeviceId)(opts.deviceUuid);
+        this.appVer = opts.appVer || '26.1.2';
+        this.lang = opts.lang || 'ko';
+        this.os = opts.os || 'android';
+        this.timeZone = opts.timeZone || 'Asia/Seoul';
+        if (typeof opts.hasAccount === 'boolean') {
+            this.hasAccount = opts.hasAccount ? 'true' : 'false';
+        }
+        else if (typeof opts.hasAccount === 'string') {
+            this.hasAccount = opts.hasAccount;
+        }
+        else {
+            this.hasAccount = '';
+        }
+        this.adid = opts.adid || opts.deviceUuid || '';
+        this.dtype = opts.dtype !== undefined && opts.dtype !== null ? String(opts.dtype) : '2';
+    }
+    _headers(extra = {}) {
+        return {
+            'Authorization': (0, login_1.buildAuthorizationHeader)(this.oauthToken, this.deviceId || this.deviceUuid),
+            'A': (0, login_1.buildAHeader)(this.appVer, this.lang),
+            'User-Agent': (0, login_1.buildUserAgent)(this.appVer),
+            'talk-agent': `${this.os}/${this.appVer}`,
+            'talk-language': this.lang,
+            'TZ': this.timeZone,
+            'hasAccount': this.hasAccount,
+            'ADID': this.adid,
+            'dtype': this.dtype,
+            ...extra,
+        };
+    }
+    _captureHeaders(res) {
+        const headers = res?.headers || {};
+        const hasAccount = headers['hasaccount'] ?? headers['hasAccount'];
+        if (hasAccount !== undefined && hasAccount !== null) {
+            this.hasAccount = Array.isArray(hasAccount) ? String(hasAccount[0] ?? '') : String(hasAccount);
+        }
+    }
+    async createEvent(event, { referer, templateId, originalEId } = {}) {
+        const query = buildQuery({ referer, templateId, originalEId });
+        const path = `${CALENDAR_BASE}/events${query}`;
+        const res = await (0, login_1.httpsPostJson)(exports.CALENDAR_HOST, path, event, this._headers());
+        this._captureHeaders(res);
+        return res;
+    }
+    async connectEvent(eId, chatId, referer) {
+        const query = buildQuery({ eId, chatId, referer });
+        const path = `${CALENDAR_BASE}/chat/connectEvent${query}`;
+        const res = await (0, login_1.httpsPostJson)(exports.CALENDAR_HOST, path, {}, this._headers());
+        this._captureHeaders(res);
+        return res;
+    }
+    async shareMessage(eId, referer) {
+        const query = buildQuery({ eId, referer });
+        const path = `${CALENDAR_BASE}/chat/shareMessage${query}`;
+        const res = await (0, login_1.httpsGet)(exports.CALENDAR_HOST, path, this._headers());
+        this._captureHeaders(res);
+        return res;
+    }
+}
+exports.CalendarClient = CalendarClient;