sessioner 0.1.0

package/lib/actions/rename.js

@@ -0,0 +1,87 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { readCache, writeCache } from '../helpers/rename-cache.js';
+const updateIndex = async (session, title) => {
+    const path = join(dirname(session.file), 'sessions-index.json');
+    try {
+        const raw = await readFile(path, 'utf-8');
+        const index = JSON.parse(raw);
+        const entry = index.entries.find((item) => item.sessionId === session.id);
+        if (!entry)
+            return;
+        entry.firstPrompt = title;
+        await writeFile(path, JSON.stringify(index, null, 2));
+    }
+    catch { }
+};
+const stripExistingTitle = (content) => {
+    const newline = content.indexOf('\n');
+    if (newline === -1)
+        return content;
+    try {
+        const parsed = JSON.parse(content.slice(0, newline));
+        if (parsed.type === 'session_title')
+            return content.slice(newline + 1);
+    }
+    catch { }
+    return content;
+};
+const isUserLine = (value) => typeof value === 'object' &&
+    value !== null &&
+    value.type === 'user' &&
+    Array.isArray(value.message?.content);
+const isTextBlock = (block) => block.type === 'text' &&
+    typeof block.text === 'string' &&
+    !block.text.startsWith('<');
+const updateUserMessage = async (filePath, title) => {
+    const cache = await readCache();
+    const previous = cache[filePath];
+    const raw = await readFile(filePath, 'utf-8');
+    const lines = raw.split('\n');
+    for (let index = 0; index < lines.length; index++) {
+        const current = lines[index];
+        if (!current?.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(current);
+        }
+        catch {
+            continue;
+        }
+        if (!isUserLine(parsed))
+            continue;
+        const content = parsed.message.content;
+        for (const block of content) {
+            delete block._renamed;
+        }
+        let replaced = false;
+        if (previous) {
+            const existing = content.findIndex((block) => block.type === 'text' && block.text === previous);
+            const match = content[existing];
+            if (existing !== -1 && match) {
+                match.text = title;
+                replaced = true;
+            }
+        }
+        if (!replaced) {
+            const target = content.findIndex(isTextBlock);
+            if (target === -1)
+                break;
+            content.splice(target, 0, { type: 'text', text: title });
+        }
+        lines[index] = JSON.stringify(parsed);
+        await writeFile(filePath, lines.join('\n'));
+        cache[filePath] = title;
+        await writeCache(cache);
+        return;
+    }
+};
+export const rename = async (session, title) => {
+    const raw = await readFile(session.file, 'utf-8');
+    const content = stripExistingTitle(raw);
+    const line = JSON.stringify({ type: 'session_title', title });
+    await writeFile(session.file, `${line}\n${content}`);
+    await updateIndex(session, title);
+    await updateUserMessage(session.file, title);
+};

package/lib/actions/trim.d.ts

@@ -0,0 +1,2 @@
+import type { Session } from '../types.js';
+export declare const trim: (session: Session, keepCount: number) => Promise<void>;

package/lib/actions/trim.js

@@ -0,0 +1,26 @@
+import { readFile, writeFile } from 'node:fs/promises';
+export const trim = async (session, keepCount) => {
+    const raw = await readFile(session.file, 'utf-8');
+    const lines = raw.split('\n');
+    let seen = 0;
+    let cutIndex = lines.length;
+    for (let index = 0; index < lines.length; index++) {
+        const current = lines[index];
+        if (!current?.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(current);
+            const isMessage = parsed.type === 'user' || parsed.type === 'assistant';
+            if (!isMessage)
+                continue;
+            seen++;
+            if (seen > keepCount) {
+                cutIndex = index;
+                break;
+            }
+        }
+        catch { }
+    }
+    const kept = lines.slice(0, cutIndex).filter((line) => line.trim());
+    await writeFile(session.file, kept.join('\n') + '\n');
+};

package/lib/bin/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/bin/index.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { parseArgs } from 'node:util';
+import { cleanEmpty, remove, targets } from '../actions/delete.js';
+import { fork } from '../actions/fork.js';
+import { merge } from '../actions/merge.js';
+import { open } from '../actions/open.js';
+import { preview } from '../actions/preview.js';
+import { prune } from '../actions/prune.js';
+import { rename } from '../actions/rename.js';
+import { trim } from '../actions/trim.js';
+import { formatProjectStats, formatStats } from '../helpers/format-stats.js';
+import { analyze } from '../sessions/analyze-prune.js';
+import { countSubagents } from '../sessions/count-subagents.js';
+import { extractMessages } from '../sessions/extract-messages.js';
+import { listSessions } from '../sessions/list-sessions.js';
+import { projectStats, stats } from '../sessions/stats.js';
+import { promptConfirm, promptTitle, select, selectAction, selectMain, selectMultiple, selectPruneOptions, selectTrimLine, showProjectStats, } from '../ui/select.js';
+const usage = [
+    'Usage: sessioner [options]',
+    '',
+    'Options:',
+    '  -p, --project <path>  Project path (default: cwd)',
+    '  -b, --base <path>     Agent base directory (default: ~/.claude/projects)',
+].join('\n');
+let values;
+try {
+    ({ values } = parseArgs({
+        args: process.argv.slice(2),
+        options: {
+            base: { type: 'string', short: 'b' },
+            project: { type: 'string', short: 'p' },
+        },
+    }));
+}
+catch {
+    console.error(usage);
+    process.exit(1);
+}
+const CTRL_C = 0x03;
+if (process.stdin.isTTY) {
+    process.stdin.prependListener('data', (data) => {
+        if (data[0] === CTRL_C) {
+            process.stdin.setRawMode(false);
+            process.stdout.write('\x1b[?25h\n');
+            process.exit(0);
+        }
+    });
+}
+const project = values.project ?? process.cwd();
+const base = values.base ?? join(homedir(), '.claude', 'projects');
+menu: while (true) {
+    const { sessions, empty } = await listSessions(project, base);
+    const choice = await selectMain(project, base, empty.length);
+    if (!choice)
+        break;
+    if (choice === 'stats') {
+        const aggregated = await projectStats(sessions);
+        const lines = formatProjectStats(aggregated, sessions.length);
+        await showProjectStats(lines, { Project: project, Base: base });
+        continue menu;
+    }
+    if (choice === 'clean') {
+        const confirmed = await promptConfirm(`Delete ${empty.length} empty sessions?`);
+        if (!confirmed)
+            continue menu;
+        await cleanEmpty(empty);
+        continue menu;
+    }
+    list: while (true) {
+        const { sessions: fresh } = await listSessions(project, base);
+        const result = await select(fresh, project, base);
+        if (!result)
+            continue menu;
+        if (result === 'exit')
+            break menu;
+        let session = result;
+        let previewLines = await preview(session);
+        let subagentCount = await countSubagents(session);
+        action: while (true) {
+            const action = await selectAction(session, project, base, previewLines, subagentCount);
+            if (!action)
+                continue list;
+            switch (action) {
+                case 'back':
+                    continue list;
+                case 'rename': {
+                    const title = await promptTitle({
+                        Project: project,
+                        Base: base,
+                        ID: session.id,
+                        Date: session.date,
+                        Title: session.message,
+                    });
+                    if (!title)
+                        continue action;
+                    await rename(session, title);
+                    session.message = title;
+                    continue action;
+                }
+                case 'open':
+                    open(session);
+                    continue action;
+                case 'stats': {
+                    const sessionStats = await stats(session);
+                    previewLines = formatStats(sessionStats);
+                    continue action;
+                }
+                case 'fork': {
+                    const defaultTitle = `Fork: ${session.message}`;
+                    const forked = await fork(session, defaultTitle);
+                    await rename(forked, defaultTitle);
+                    const title = await promptTitle({
+                        Project: project,
+                        Base: base,
+                        ID: forked.id,
+                        Date: forked.date,
+                        Title: forked.message,
+                    });
+                    if (title) {
+                        await rename(forked, title);
+                        forked.message = title;
+                    }
+                    session = forked;
+                    previewLines = await preview(session);
+                    subagentCount = await countSubagents(session);
+                    continue action;
+                }
+                case 'merge': {
+                    const current = session;
+                    const others = await selectMultiple(fresh.filter((session) => session.id !== current.id), project, base);
+                    if (!others || others.length === 0)
+                        continue action;
+                    const all = [current, ...others];
+                    const titles = all.map((session) => session.message);
+                    const defaultTitle = `Merge: ${titles.join(', ')}`;
+                    const merged = await merge(all, defaultTitle);
+                    await rename(merged, defaultTitle);
+                    const title = await promptTitle({
+                        Project: project,
+                        Base: base,
+                        ID: merged.id,
+                        Date: merged.date,
+                        Title: merged.message,
+                    });
+                    if (title) {
+                        await rename(merged, title);
+                        merged.message = title;
+                    }
+                    session = merged;
+                    previewLines = await preview(session);
+                    subagentCount = await countSubagents(session);
+                    continue action;
+                }
+                case 'prune': {
+                    const stats = await analyze(session);
+                    const selected = await selectPruneOptions(stats, {
+                        Project: project,
+                        Base: base,
+                        ID: session.id,
+                        Date: session.date,
+                        Title: session.message,
+                    });
+                    if (selected === 'exit')
+                        break menu;
+                    if (!selected)
+                        continue action;
+                    await prune(session, {
+                        toolBlocks: selected.has('toolBlocks'),
+                        shortMessages: selected.has('shortMessages'),
+                        emptyMessages: selected.has('emptyMessages'),
+                        systemTags: selected.has('systemTags'),
+                    });
+                    previewLines = await preview(session);
+                    subagentCount = await countSubagents(session);
+                    continue action;
+                }
+                case 'trim': {
+                    const { total, lines } = await extractMessages(session);
+                    if (lines.length <= 1)
+                        continue action;
+                    const selected = await selectTrimLine(lines, {
+                        Project: project,
+                        Base: base,
+                        ID: session.id,
+                        Date: session.date,
+                        Title: session.message,
+                    });
+                    if (selected === null)
+                        continue action;
+                    const keepCount = selected + 1;
+                    const removeCount = total - keepCount;
+                    if (removeCount <= 0)
+                        continue action;
+                    const confirmed = await promptConfirm(`Remove last ${removeCount} of ${total} messages?`);
+                    if (!confirmed)
+                        continue action;
+                    await trim(session, keepCount);
+                    previewLines = await preview(session);
+                    subagentCount = await countSubagents(session);
+                    continue action;
+                }
+                case 'delete': {
+                    const items = await targets(session);
+                    const confirmed = await promptConfirm(`Delete ${items.join(' + ')}?`);
+                    if (!confirmed)
+                        continue action;
+                    await remove(session);
+                    continue list;
+                }
+                case 'exit':
+                    break menu;
+            }
+        }
+    }
+}

package/lib/helpers/ansi.d.ts

@@ -0,0 +1,9 @@
+export declare const dim: (text: string) => string;
+export declare const bold: (text: string) => string;
+export declare const strikethrough: (text: string) => string;
+export declare const gray: (text: string) => string;
+export declare const cyan: (text: string) => string;
+export declare const green: (text: string) => string;
+export declare const yellow: (text: string) => string;
+export declare const colorize: (text: string, ansiColor: string) => string;
+export declare const DEFAULT_ICON_COLOR = "38;5;214";

package/lib/helpers/ansi.js

@@ -0,0 +1,9 @@
+export const dim = (text) => `\x1b[2m${text}\x1b[22m`;
+export const bold = (text) => `\x1b[1m${text}\x1b[22m`;
+export const strikethrough = (text) => `\x1b[9m${text}\x1b[29m`;
+export const gray = (text) => `\x1b[90m${text}\x1b[39m`;
+export const cyan = (text) => `\x1b[36m${text}\x1b[39m`;
+export const green = (text) => `\x1b[32m${text}\x1b[39m`;
+export const yellow = (text) => `\x1b[33m${text}\x1b[39m`;
+export const colorize = (text, ansiColor) => `\x1b[${ansiColor}m${text}\x1b[39m`;
+export const DEFAULT_ICON_COLOR = '38;5;214';

package/lib/helpers/format-date.d.ts

@@ -0,0 +1 @@
+export declare const formatDate: (date: Date) => string;

package/lib/helpers/format-date.js

@@ -0,0 +1,8 @@
+export const formatDate = (date) => {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    return `${year}-${month}-${day} ${hours}:${minutes}`;
+};

package/lib/helpers/format-stats.d.ts

@@ -0,0 +1,3 @@
+import type { SessionStats } from '../types.js';
+export declare const formatStats: (result: SessionStats) => string[];
+export declare const formatProjectStats: (result: SessionStats, count: number) => string[];

package/lib/helpers/format-stats.js

@@ -0,0 +1,81 @@
+import { bold, dim, green, yellow } from './ansi.js';
+const COST_DECIMALS = 4;
+const NUMBER_DECIMALS = 1;
+const LABEL_COLUMN_WIDTH = 12;
+const COLUMN_GAP = 2;
+const MS_PER_HOUR = 3_600_000;
+const MS_PER_MINUTE = 60_000;
+const ONE_MILLION = 1_000_000;
+const ONE_THOUSAND = 1_000;
+const formatNumber = (value) => {
+    if (value >= ONE_MILLION)
+        return `${(value / ONE_MILLION).toFixed(NUMBER_DECIMALS)}M`;
+    if (value >= ONE_THOUSAND)
+        return `${(value / ONE_THOUSAND).toFixed(NUMBER_DECIMALS)}K`;
+    return String(value);
+};
+const formatCost = (value) => `$${value.toFixed(COST_DECIMALS)}`;
+const formatDuration = (duration) => {
+    if (!duration.first || !duration.last)
+        return [];
+    const start = new Date(duration.first);
+    const end = new Date(duration.last);
+    const elapsed = end.getTime() - start.getTime();
+    const hours = Math.floor(elapsed / MS_PER_HOUR);
+    const minutes = Math.floor((elapsed % MS_PER_HOUR) / MS_PER_MINUTE);
+    const label = hours > 0 ? `${hours}h ${minutes}m` : `${minutes}m`;
+    return [`  ${dim('Duration:')}    ${label}`];
+};
+const formatMessages = (messages, subagents) => {
+    const total = messages.user + messages.assistant;
+    const lines = [
+        `  ${dim('Messages:')}    ${total} ${dim(`(${messages.user} user, ${messages.assistant} assistant)`)}`,
+    ];
+    if (subagents > 0)
+        lines.push(`  ${dim('Subagents:')}   ${subagents}`);
+    return lines;
+};
+const formatTokens = (tokens) => [
+    '',
+    `  ${bold('Tokens')}`,
+    `  ${dim('Input:')}       ${formatNumber(tokens.input)}`,
+    `  ${dim('Output:')}      ${formatNumber(tokens.output)}`,
+    `  ${dim('Cache write:')} ${formatNumber(tokens.cacheCreation)}`,
+    `  ${dim('Cache read:')}  ${formatNumber(tokens.cacheRead)}`,
+];
+const formatCostSection = (cost, totalCost) => {
+    if (cost.size === 0)
+        return [];
+    const sorted = [...cost.entries()]
+        .filter(([, modelCost]) => modelCost > 0)
+        .sort(([, costA], [, costB]) => costB - costA);
+    const modelLines = sorted.map(([model, modelCost]) => {
+        const padding = ' '.repeat(LABEL_COLUMN_WIDTH - model.length);
+        return `  ${dim(`${model}:`)}${padding}${formatCost(modelCost)}`;
+    });
+    return [
+        '',
+        `  ${bold('Cost')}`,
+        ...modelLines,
+        `  ${dim('Total:')}       ${green(formatCost(totalCost))}`,
+    ];
+};
+const formatToolsSection = (tools) => {
+    if (tools.size === 0)
+        return [];
+    const sorted = [...tools.entries()].sort(([, countA], [, countB]) => countB - countA);
+    const longest = Math.max(...sorted.map(([name]) => name.length));
+    const toolLines = sorted.map(([name, count]) => {
+        const padding = ' '.repeat(longest - name.length + COLUMN_GAP);
+        return `  ${dim(name)}${padding}${yellow(String(count))}`;
+    });
+    return ['', `  ${bold('Tools')}`, ...toolLines];
+};
+export const formatStats = (result) => [
+    ...formatDuration(result.duration),
+    ...formatMessages(result.messages, result.subagents),
+    ...formatTokens(result.tokens),
+    ...formatCostSection(result.cost, result.totalCost),
+    ...formatToolsSection(result.tools),
+];
+export const formatProjectStats = (result, count) => [`  ${dim('Sessions:')}    ${count}`, ...formatStats(result)];

package/lib/helpers/get-columns.d.ts

@@ -0,0 +1 @@
+export declare const getColumns: () => number;

package/lib/helpers/get-columns.js

@@ -0,0 +1,8 @@
+const DEFAULT_COLUMNS = 80;
+export const getColumns = () => {
+    if (process.stdout.isTTY && process.stdout.columns)
+        return process.stdout.columns;
+    if (process.stderr.isTTY && process.stderr.columns)
+        return process.stderr.columns;
+    return DEFAULT_COLUMNS;
+};

package/lib/helpers/rename-cache.d.ts

@@ -0,0 +1,3 @@
+import type { RenameCache } from '../types.js';
+export declare const readCache: () => Promise<RenameCache>;
+export declare const writeCache: (cache: RenameCache) => Promise<void>;

package/lib/helpers/rename-cache.js

@@ -0,0 +1,18 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const cacheDir = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '.cache');
+const cacheFile = join(cacheDir, 'renames.json');
+export const readCache = async () => {
+    try {
+        const raw = await readFile(cacheFile, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+};
+export const writeCache = async (cache) => {
+    await mkdir(cacheDir, { recursive: true });
+    await writeFile(cacheFile, JSON.stringify(cache, null, 2));
+};

package/lib/helpers/styled-label.d.ts

@@ -0,0 +1,2 @@
+import type { StyledLabelOptions } from '../types.js';
+export declare const styledLabel: ({ label, icon, iconColor, }: StyledLabelOptions) => string;

package/lib/helpers/styled-label.js

@@ -0,0 +1,2 @@
+import { colorize, DEFAULT_ICON_COLOR } from './ansi.js';
+export const styledLabel = ({ label, icon, iconColor = DEFAULT_ICON_COLOR, }) => `${colorize(icon, iconColor)}\x1b[1m ${label}`;

package/lib/helpers/truncate.d.ts

@@ -0,0 +1 @@
+export declare const truncate: (text: string, maxLength: number) => string;

package/lib/helpers/truncate.js

@@ -0,0 +1 @@
+export const truncate = (text, maxLength) => text.length > maxLength ? text.slice(0, maxLength - 1) + '…' : text;

package/lib/sessions/analyze-prune.d.ts

@@ -0,0 +1,12 @@
+import type { ContentBlock, PruneStats, Session } from '../types.js';
+export declare const MIN_TEXT_LENGTH = 50;
+export declare const SYSTEM_TAGS: readonly ["ide_selection", "ide_opened_file", "system-reminder"];
+export declare const isToolBlock: (block: ContentBlock) => boolean;
+export declare const textLength: (blocks: ContentBlock[]) => number;
+export declare const hasContent: (parsed: {
+    type?: string;
+    message?: {
+        content?: unknown[];
+    };
+}) => boolean;
+export declare const analyze: (session: Session) => Promise<PruneStats>;

package/lib/sessions/analyze-prune.js

@@ -0,0 +1,77 @@
+import { readFile } from 'node:fs/promises';
+export const MIN_TEXT_LENGTH = 50;
+export const SYSTEM_TAGS = [
+    'ide_selection',
+    'ide_opened_file',
+    'system-reminder',
+];
+export const isToolBlock = (block) => block.type === 'tool_use' || block.type === 'tool_result';
+export const textLength = (blocks) => {
+    let length = 0;
+    for (const block of blocks) {
+        if (block.type !== 'text' || !block.text)
+            continue;
+        length += block.text.trim().length;
+    }
+    return length;
+};
+export const hasContent = (parsed) => (parsed.type === 'assistant' || parsed.type === 'user') &&
+    Array.isArray(parsed.message?.content);
+const countTagsInText = (text) => {
+    let count = 0;
+    for (const tag of SYSTEM_TAGS) {
+        const open = `<${tag}>`;
+        const close = `</${tag}>`;
+        let position = 0;
+        scan: while (true) {
+            const start = text.indexOf(open, position);
+            if (start === -1)
+                break scan;
+            const end = text.indexOf(close, start + open.length);
+            if (end === -1)
+                break scan;
+            count++;
+            position = end + close.length;
+        }
+    }
+    return count;
+};
+const countSystemTags = (blocks) => {
+    let count = 0;
+    for (const block of blocks) {
+        if (block.type !== 'text' || !block.text)
+            continue;
+        count += countTagsInText(block.text);
+    }
+    return count;
+};
+export const analyze = async (session) => {
+    const raw = await readFile(session.file, 'utf-8');
+    const lines = raw.split('\n');
+    let toolBlocks = 0;
+    let shortMessages = 0;
+    let emptyMessages = 0;
+    let systemTags = 0;
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (!hasContent(parsed))
+                continue;
+            const content = parsed.message.content;
+            const tools = content.filter((block) => isToolBlock(block));
+            toolBlocks += tools.length;
+            systemTags += countSystemTags(content);
+            const filtered = content.filter((block) => !isToolBlock(block));
+            if (filtered.length === 0) {
+                emptyMessages++;
+                continue;
+            }
+            if (parsed.type === 'assistant' && textLength(filtered) < MIN_TEXT_LENGTH)
+                shortMessages++;
+        }
+        catch { }
+    }
+    return { toolBlocks, shortMessages, emptyMessages, systemTags };
+};

package/lib/sessions/count-subagents.d.ts

@@ -0,0 +1,2 @@
+import type { Session } from '../types.js';
+export declare const countSubagents: (session: Session) => Promise<number>;

package/lib/sessions/count-subagents.js

@@ -0,0 +1,13 @@
+import { readdir } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+export const countSubagents = async (session) => {
+    const id = basename(session.file, '.jsonl');
+    const subagentsDir = join(dirname(session.file), id, 'subagents');
+    try {
+        const entries = await readdir(subagentsDir);
+        return entries.length;
+    }
+    catch {
+        return 0;
+    }
+};

package/lib/sessions/extract-first-user-message.d.ts

@@ -0,0 +1 @@
+export declare const extractFirstUserMessage: (filePath: string) => Promise<string>;

package/lib/sessions/extract-first-user-message.js

@@ -0,0 +1,42 @@
+import { createReadStream } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { parseLine } from './parse-line.js';
+const MIN_TEXT_LENGTH = 5;
+export const extractFirstUserMessage = (filePath) => new Promise((resolve) => {
+    const stream = createReadStream(filePath, 'utf-8');
+    const reader = createInterface({ input: stream, crlfDelay: Infinity });
+    const close = (value) => {
+        resolve(value);
+        reader.close();
+        stream.destroy();
+    };
+    reader.on('line', (line) => {
+        if (!line.trim())
+            return;
+        const entry = parseLine(line);
+        if (!entry)
+            return;
+        if (entry.type === 'session_title' && 'title' in entry) {
+            close(String(entry.title)
+                .replace(/\s+/g, ' ')
+                .trim());
+            return;
+        }
+        if (entry.type !== 'user')
+            return;
+        const texts = entry.message?.content ?? [];
+        for (const block of texts) {
+            if (block.type !== 'text' || !block.text)
+                continue;
+            const text = block.text.replace(/\s+/g, ' ').trim();
+            if (text.startsWith('<'))
+                continue;
+            if (text.length <= MIN_TEXT_LENGTH)
+                continue;
+            close(text);
+            return;
+        }
+    });
+    reader.on('close', () => resolve(''));
+    stream.on('error', () => close(''));
+});