@makefinks/daemon 0.7.2 → 0.9.0

package/src/utils/config.ts

@@ -4,8 +4,20 @@ import { getAppConfigDir } from "./preferences";
 
 const CONFIG_FILE = "config.json";
 
+export type McpTransportType = "http" | "sse";
+
+export interface McpServerConfig {
+	/** Optional stable id. If omitted, derived from URL. */
+	id?: string;
+	/** Transport type for the MCP server. */
+	type: McpTransportType;
+	/** MCP endpoint URL. */
+	url: string;
+}
+
 export interface ManualConfig {
 	memoryModel?: string;
+	mcpServers?: McpServerConfig[];
 }
 
 let cachedConfig: ManualConfig | null = null;
@@ -17,6 +29,10 @@ function getConfigPath(): string {
 	return path.join(getAppConfigDir(), CONFIG_FILE);
 }
 
+export function getManualConfigPath(): string {
+	return getConfigPath();
+}
+
 export function loadManualConfig(): ManualConfig {
 	const now = Date.now();
 
@@ -56,6 +72,23 @@ function parseManualConfig(raw: Record<string, unknown>): ManualConfig {
 		config.memoryModel = raw.memoryModel.trim();
 	}
 
+	if (Array.isArray(raw.mcpServers)) {
+		const servers: McpServerConfig[] = [];
+		for (const entry of raw.mcpServers) {
+			if (typeof entry !== "object" || entry === null) continue;
+			const obj = entry as Record<string, unknown>;
+			const type = obj.type;
+			const url = obj.url;
+			if (type !== "http" && type !== "sse") continue;
+			if (typeof url !== "string" || url.trim().length === 0) continue;
+			const id = typeof obj.id === "string" && obj.id.trim().length > 0 ? obj.id.trim() : undefined;
+			servers.push({ id, type, url: url.trim() });
+		}
+		if (servers.length > 0) {
+			config.mcpServers = servers;
+		}
+	}
+
 	return config;
 }
 

package/src/utils/derive-url-menu-items.ts

@@ -10,6 +10,80 @@ function normalizeUrlKey(rawUrl: string): string {
 	}
 }
 
+function unescapeXmlAttribute(value: string): string {
+	return value
+		.replace(/"/g, '"')
+		.replace(/&lt;/g, "<")
+		.replace(/&gt;/g, ">")
+		.replace(/&amp;/g, "&");
+}
+
+function parseFetchUrlsXml(result: string): {
+	items: Array<{
+		url: string;
+		lineOffset?: number;
+		lineLimit?: number;
+		totalLines?: number;
+		remainingLines?: number | null;
+		error?: string;
+		success: boolean;
+	}>;
+	error?: string;
+} {
+	const items: Array<{
+		url: string;
+		lineOffset?: number;
+		lineLimit?: number;
+		totalLines?: number;
+		remainingLines?: number | null;
+		error?: string;
+		success: boolean;
+	}> = [];
+
+	let error: string | undefined;
+	const errorMatch = result.match(/<fetchUrls[^>]*\serror="([^"]+)"[^>]*\/?>/);
+	if (errorMatch?.[1]) {
+		error = unescapeXmlAttribute(errorMatch[1]);
+	}
+
+	const regex = /<url\s+([^>]*?)(\/?)>/g;
+	let match = regex.exec(result);
+	while (match) {
+		const attrText = match[1] ?? "";
+		const attrs: Record<string, string> = {};
+		for (const attr of attrText.matchAll(/(\w+)="([^"]*)"/g)) {
+			const key = attr[1];
+			const value = attr[2] ?? "";
+			attrs[key] = unescapeXmlAttribute(value);
+		}
+		const url = attrs.href;
+		if (!url) continue;
+		const lineOffset = attrs.lineOffset !== undefined ? Number(attrs.lineOffset) : undefined;
+		const lineLimit = attrs.lineLimit !== undefined ? Number(attrs.lineLimit) : undefined;
+		const totalLines = attrs.totalLines !== undefined ? Number(attrs.totalLines) : undefined;
+		let remainingLines: number | null | undefined = undefined;
+		if (attrs.remainingLines === "unknown") remainingLines = null;
+		else if (attrs.remainingLines !== undefined) remainingLines = Number(attrs.remainingLines);
+		const error = attrs.error;
+		const success = !error;
+		items.push({
+			url,
+			lineOffset: Number.isFinite(lineOffset) ? lineOffset : undefined,
+			lineLimit: Number.isFinite(lineLimit) ? lineLimit : undefined,
+			totalLines: Number.isFinite(totalLines) ? totalLines : undefined,
+			remainingLines:
+				remainingLines === null || (typeof remainingLines === "number" && Number.isFinite(remainingLines))
+					? remainingLines
+					: undefined,
+			error,
+			success,
+		});
+		match = regex.exec(result);
+	}
+
+	return { items, error };
+}
+
 function computeCoveragePercent(intervals: Array<[number, number]>, totalLines: number): number | undefined {
 	if (!Number.isFinite(totalLines) || totalLines <= 0) return undefined;
 	if (intervals.length === 0) return undefined;
@@ -43,7 +117,6 @@ export function deriveUrlMenuItems(params: {
 
 	const intervalsByUrl = new Map<string, Array<[number, number]>>();
 	const totalLinesByUrl = new Map<string, number>();
-	const highlightsCountByUrl = new Map<string, number>();
 	const lastSeenIndexByUrl = new Map<string, number>();
 	const statusByUrl = new Map<string, "ok" | "error">();
 	const errorByUrl = new Map<string, string>();
@@ -57,58 +130,147 @@ export function deriveUrlMenuItems(params: {
 		if (block.type !== "tool") continue;
 		if (block.call.name !== "fetchUrls" && block.call.name !== "renderUrl") continue;
 
-		const input = block.call.input as { url?: string } | undefined;
-		const url = input?.url;
-		if (!url) continue;
+		const input = block.call.input as { url?: string; requests?: Array<{ url?: string }> } | undefined;
+		const urls: string[] = [];
+		if (input?.url && typeof input.url === "string") {
+			urls.push(input.url);
+		}
+		if (Array.isArray(input?.requests)) {
+			for (const request of input.requests) {
+				if (request?.url && typeof request.url === "string") {
+					urls.push(request.url);
+				}
+			}
+		}
+		if (urls.length === 0) continue;
 
-		lastSeenIndexByUrl.set(url, blockIndex);
+		for (const url of urls) {
+			lastSeenIndexByUrl.set(url, blockIndex);
+		}
 
 		const result = block.result as
 			| {
+					success?: boolean;
+					error?: string;
+					results?: Array<{
+						success?: boolean;
+						url?: string;
+						lineOffset?: number;
+						lineLimit?: number;
+						totalLines?: number;
+						error?: string;
+					}>;
 					lineOffset?: number;
 					lineLimit?: number;
 					totalLines?: number;
-					highlights?: unknown[];
-					success?: boolean;
-					error?: string;
 			  }
 			| undefined;
 
-		if (!result || typeof result !== "object") continue;
+		if (!result) continue;
 
-		if (result.success === false && typeof result.error === "string" && result.error.trim().length > 0) {
-			statusByUrl.set(url, "error");
-			errorByUrl.set(url, result.error.trim());
-		} else if (result.success === true) {
-			statusByUrl.set(url, "ok");
-		}
+		if (typeof result === "string") {
+			const parsed = parseFetchUrlsXml(result);
+			for (const item of parsed.items) {
+				const itemUrl = item.url;
 
-		if (Array.isArray(result.highlights)) {
-			highlightsCountByUrl.set(url, result.highlights.length);
+				if (!item.success && item.error && item.error.trim().length > 0) {
+					statusByUrl.set(itemUrl, "error");
+					errorByUrl.set(itemUrl, item.error.trim());
+				} else if (item.success) {
+					statusByUrl.set(itemUrl, "ok");
+				}
+
+				if (typeof item.totalLines === "number" && item.totalLines > 0) {
+					const prev = totalLinesByUrl.get(itemUrl) ?? 0;
+					totalLinesByUrl.set(itemUrl, Math.max(prev, item.totalLines));
+				}
+
+				if (
+					typeof item.lineOffset === "number" &&
+					typeof item.lineLimit === "number" &&
+					item.lineLimit > 0 &&
+					item.lineOffset >= 0
+				) {
+					const start = item.lineOffset;
+					const end = item.lineOffset + item.lineLimit;
+					const list = intervalsByUrl.get(itemUrl) ?? [];
+					list.push([start, end]);
+					intervalsByUrl.set(itemUrl, list);
+				}
+			}
+			if (parsed.items.length === 0 && parsed.error) {
+				for (const url of urls) {
+					statusByUrl.set(url, "error");
+					errorByUrl.set(url, parsed.error);
+				}
+			}
+			continue;
 		}
 
-		if (
+		if (typeof result !== "object") continue;
+
+		if (Array.isArray(result.results)) {
+			for (const item of result.results) {
+				if (!item || typeof item !== "object") continue;
+				const itemUrl = typeof item.url === "string" ? item.url : null;
+				if (!itemUrl) continue;
+
+				if (item.success === false && typeof item.error === "string" && item.error.trim().length > 0) {
+					statusByUrl.set(itemUrl, "error");
+					errorByUrl.set(itemUrl, item.error.trim());
+				} else if (item.success === true) {
+					statusByUrl.set(itemUrl, "ok");
+				}
+
+				if (typeof item.totalLines === "number" && Number.isFinite(item.totalLines) && item.totalLines > 0) {
+					const prev = totalLinesByUrl.get(itemUrl) ?? 0;
+					totalLinesByUrl.set(itemUrl, Math.max(prev, item.totalLines));
+				}
+
+				if (
+					typeof item.lineOffset === "number" &&
+					typeof item.lineLimit === "number" &&
+					Number.isFinite(item.lineOffset) &&
+					Number.isFinite(item.lineLimit) &&
+					item.lineLimit > 0 &&
+					item.lineOffset >= 0
+				) {
+					const start = item.lineOffset;
+					const end = item.lineOffset + item.lineLimit;
+					const list = intervalsByUrl.get(itemUrl) ?? [];
+					list.push([start, end]);
+					intervalsByUrl.set(itemUrl, list);
+				}
+			}
+		} else if (
+			result.success === false &&
+			typeof result.error === "string" &&
+			result.error.trim().length > 0
+		) {
+			for (const url of urls) {
+				statusByUrl.set(url, "error");
+				errorByUrl.set(url, result.error.trim());
+			}
+		} else if (result.success === true) {
+			for (const url of urls) {
+				statusByUrl.set(url, "ok");
+			}
+		} else if (
 			typeof result.totalLines === "number" &&
 			Number.isFinite(result.totalLines) &&
-			result.totalLines > 0
-		) {
-			const prev = totalLinesByUrl.get(url) ?? 0;
-			totalLinesByUrl.set(url, Math.max(prev, result.totalLines));
-		}
-
-		if (
+			result.totalLines > 0 &&
 			typeof result.lineOffset === "number" &&
-			typeof result.lineLimit === "number" &&
-			Number.isFinite(result.lineOffset) &&
-			Number.isFinite(result.lineLimit) &&
-			result.lineLimit > 0 &&
-			result.lineOffset >= 0
+			typeof result.lineLimit === "number"
 		) {
-			const start = result.lineOffset;
-			const end = result.lineOffset + result.lineLimit;
-			const list = intervalsByUrl.get(url) ?? [];
-			list.push([start, end]);
-			intervalsByUrl.set(url, list);
+			for (const url of urls) {
+				const prev = totalLinesByUrl.get(url) ?? 0;
+				totalLinesByUrl.set(url, Math.max(prev, result.totalLines));
+				const start = result.lineOffset;
+				const end = result.lineOffset + result.lineLimit;
+				const list = intervalsByUrl.get(url) ?? [];
+				list.push([start, end]);
+				intervalsByUrl.set(url, list);
+			}
 		}
 	}
 
@@ -134,7 +296,6 @@ export function deriveUrlMenuItems(params: {
 	const urls = [...lastSeenIndexByUrl.keys()];
 	return urls.map((url) => {
 		const groundedCount = lookupGroundedCount(url);
-		const highlightsCount = highlightsCountByUrl.get(url);
 		const totalLines = totalLinesByUrl.get(url);
 		const intervals = intervalsByUrl.get(url) ?? [];
 		const readPercent = totalLines !== undefined ? computeCoveragePercent(intervals, totalLines) : undefined;
@@ -146,7 +307,6 @@ export function deriveUrlMenuItems(params: {
 			url,
 			groundedCount,
 			readPercent,
-			highlightsCount,
 			status,
 			error,
 			lastSeenIndex,

package/src/utils/preferences.ts

@@ -12,6 +12,7 @@ const PREFERENCES_VERSION = 1;
 const APP_DIR_NAME = "daemon";
 const PREFERENCES_FILE = "preferences.json";
 const CREDENTIALS_FILE = "credentials.json";
+const CONFIG_DIR_ENV = "DAEMON_CONFIG_DIR";
 
 /** Keys that belong in credentials.json (secrets) vs preferences.json (settings) */
 const CREDENTIAL_KEYS = ["openRouterApiKey", "openAiApiKey", "exaApiKey"] as const;
@@ -32,6 +33,8 @@ function getBaseConfigDir(): string {
 }
 
 export function getAppConfigDir(): string {
+	const override = process.env[CONFIG_DIR_ENV]?.trim();
+	if (override) return override;
 	return path.join(getBaseConfigDir(), APP_DIR_NAME);
 }
 
@@ -109,6 +112,9 @@ export function parsePreferences(raw: unknown): AppPreferences | null {
 	if (typeof raw.showToolOutput === "boolean") {
 		prefs.showToolOutput = raw.showToolOutput;
 	}
+	if (typeof raw.memoryEnabled === "boolean") {
+		prefs.memoryEnabled = raw.memoryEnabled;
+	}
 	if (isRecord(raw.toolToggles)) {
 		const record = raw.toolToggles;
 		const next: Record<string, boolean> = {};

package/src/utils/tool-output-preview.ts

@@ -8,6 +8,10 @@ function normalizeWhitespace(text: string): string {
 	return text.replace(/\r\n/g, "\n").replace(/\t/g, "  ");
 }
 
+function escapeXmlAttribute(value: string): string {
+	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
 function truncateText(text: string, maxChars: number): { text: string; truncated: boolean } {
 	if (text.length <= maxChars) return { text, truncated: false };
 	if (maxChars <= 1) return { text: "…", truncated: true };
@@ -105,43 +109,123 @@ function formatExaSearchResult(result: unknown): string | null {
 }
 
 function formatExaFetchResult(result: unknown): string | null {
+	if (typeof result === "string") {
+		const trimmed = result.trim();
+		if (!trimmed) return null;
+		if (trimmed.startsWith("<fetchUrls") && trimmed.includes("error=") && !trimmed.includes("</fetchUrls>")) {
+			return trimmed;
+		}
+
+		const rawLines = trimmed
+			.split("\n")
+			.map((line) => line.trimEnd())
+			.filter((line) => line.trim().length > 0);
+		const hasFetchHeader = rawLines.some((line) => line.includes("<fetchUrls"));
+		if (!hasFetchHeader) return trimmed;
+
+		const headerLine = rawLines.find((line) => line.includes("<fetchUrls"));
+		const closingLine = rawLines.find((line) => line.includes("</fetchUrls>"));
+		const urlLines = rawLines.filter((line) => line.includes("<url"));
+		const errorLines = urlLines.filter((line) => line.includes("error="));
+		const normalLines = urlLines.filter((line) => !line.includes("error="));
+
+		let contentLine: string | undefined;
+		if (normalLines.length === 1) {
+			const firstUrlIdx = rawLines.findIndex((line) => line.includes("<url") && line.includes("href="));
+			if (firstUrlIdx >= 0) {
+				contentLine = rawLines
+					.slice(firstUrlIdx + 1)
+					.find(
+						(line) => !line.includes("</url>") && !line.includes("<url") && !line.includes("</fetchUrls>")
+					)
+					?.trim();
+			}
+		}
+
+		const lines: string[] = [];
+		if (headerLine) lines.push(headerLine);
+		if (normalLines[0]) lines.push(normalLines[0]);
+
+		if (errorLines.length > 0) {
+			lines.push(errorLines[0]);
+		} else if (contentLine) {
+			lines.push(contentLine);
+		}
+
+		if (contentLine && errorLines.length > 0 && lines.length < 4) {
+			lines.push(contentLine);
+		}
+
+		if (closingLine && lines.length < 4) {
+			lines.push(closingLine);
+		}
+
+		return lines.length > 0 ? lines.join("\n") : trimmed;
+	}
 	if (!isRecord(result)) return null;
 	if (result.success === false && typeof result.error === "string") {
 		return `error: ${result.error}`;
 	}
 	if (result.success !== true) return null;
 	const data = extractToolDataContainer(result);
-	const candidate = isRecord(data) ? (data as ExaLikeItem & { remainingLines?: unknown }) : {};
-	const label = formatExaItemLabel(candidate);
-	const url = typeof candidate.url === "string" ? candidate.url : "";
-	const title = typeof candidate.title === "string" ? candidate.title : "";
-	const lineOffset = typeof candidate.lineOffset === "number" ? candidate.lineOffset : undefined;
-	const lineLimit = typeof candidate.lineLimit === "number" ? candidate.lineLimit : undefined;
-	const remainingLines =
-		typeof (candidate as { remainingLines?: unknown }).remainingLines === "number" ||
-		(candidate as { remainingLines?: unknown }).remainingLines === null
-			? (candidate as { remainingLines: number | null }).remainingLines
-			: undefined;
-	const rangeParts: string[] = [];
-	if (lineOffset !== undefined) rangeParts.push(`lineOffset=${lineOffset}`);
-	if (lineLimit !== undefined) rangeParts.push(`lineLimit=${lineLimit}`);
-	if (remainingLines !== undefined) {
-		rangeParts.push(remainingLines === null ? "remainingLines=unknown" : `remainingLines=${remainingLines}`);
-	}
-	const remainingSuffix = rangeParts.length > 0 ? ` (${rangeParts.join(", ")})` : "";
+	const container = isRecord(data) ? data : {};
+	const results = Array.isArray(container.results) ? container.results : null;
+	if (!results) return null;
+
+	const lines: string[] = ["<fetchUrls>"];
+	const maxItems = 3;
+	const MAX_LINES = 2;
+	const MAX_CHARS = 160;
+
+	for (const item of results.slice(0, maxItems)) {
+		if (!isRecord(item)) continue;
+
+		const candidate = item as ExaLikeItem & {
+			remainingLines?: unknown;
+			totalLines?: unknown;
+			error?: unknown;
+		};
+		const url = typeof candidate.url === "string" ? candidate.url : "";
+		if (!url) continue;
+
+		const attributes: string[] = [`href="${escapeXmlAttribute(url)}"`];
+		if (typeof candidate.lineOffset === "number") attributes.push(`lineOffset="${candidate.lineOffset}"`);
+		if (typeof candidate.lineLimit === "number") attributes.push(`lineLimit="${candidate.lineLimit}"`);
+		if (typeof candidate.totalLines === "number") attributes.push(`totalLines="${candidate.totalLines}"`);
+		if (typeof candidate.remainingLines === "number") {
+			attributes.push(`remainingLines="${candidate.remainingLines}"`);
+		} else if (candidate.remainingLines === null) {
+			attributes.push(`remainingLines="unknown"`);
+		}
 
-	const headerBase = url && title ? `${label} — ${url}` : label;
-	const header = `${headerBase}${remainingSuffix}`;
+		if (candidate.success === false && typeof candidate.error === "string") {
+			attributes.push(`error="${escapeXmlAttribute(candidate.error)}"`);
+			lines.push(`  <url ${attributes.join(" ")} />`);
+			continue;
+		}
 
-	const text = typeof candidate.text === "string" ? candidate.text : "";
-	if (!text.trim()) return header;
+		const text = typeof candidate.text === "string" ? candidate.text : "";
+		if (!text.trim()) {
+			lines.push(`  <url ${attributes.join(" ")} />`);
+			continue;
+		}
 
-	// Provide a small snippet; downstream truncation enforces the hard caps.
-	const snippet = normalizeWhitespace(text)
-		.replace(/\n{3,}/g, "\n\n")
-		.trim();
+		const snippetLines = normalizeWhitespace(text)
+			.replace(/\n{3,}/g, "\n\n")
+			.trim()
+			.split("\n")
+			.slice(0, MAX_LINES)
+			.map((l) => (l.length > MAX_CHARS ? `${l.slice(0, MAX_CHARS - 1)}…` : l));
 
-	return `${header}\n${snippet}`;
+		lines.push(`  <url ${attributes.join(" ")}>`);
+		for (const line of snippetLines) {
+			lines.push(`    ${escapeXmlAttribute(line)}`);
+		}
+		lines.push("  </url>");
+	}
+
+	lines.push("</fetchUrls>");
+	return lines.length > 2 ? lines.join("\n") : null;
 }
 
 function formatRenderUrlResult(result: unknown): string | null {
@@ -194,6 +278,66 @@ function formatReadFileResult(result: unknown): string | null {
 	return `${path}${range}:\n${content}`;
 }
 
+function tryStringify(value: unknown): string {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint")
+		return String(value);
+	if (value === null) return "null";
+	if (value === undefined) return "undefined";
+	try {
+		return JSON.stringify(value, null, 2);
+	} catch {
+		return String(value);
+	}
+}
+
+type McpContentLike = {
+	type?: unknown;
+	text?: unknown;
+	content?: unknown;
+	data?: unknown;
+};
+
+function extractMcpContentText(item: unknown): string {
+	if (!isRecord(item)) return "";
+	const it = item as McpContentLike;
+	if (typeof it.text === "string") return it.text;
+	if (typeof it.content === "string") return it.content;
+	if (typeof it.type === "string" && it.type === "text" && typeof it.data === "string") return it.data;
+	return "";
+}
+
+function formatMcpLikeResult(result: unknown): string | null {
+	if (!isRecord(result)) return null;
+
+	const structuredContent =
+		"structuredContent" in result ? (result as UnknownRecord).structuredContent : undefined;
+	if (structuredContent !== undefined) {
+		const raw = tryStringify(structuredContent);
+		return raw.trim().length > 0 ? raw : null;
+	}
+
+	const content = "content" in result ? (result as UnknownRecord).content : undefined;
+	if (Array.isArray(content)) {
+		const pieces = content
+			.map(extractMcpContentText)
+			.map((t) => t.trim())
+			.filter((t) => t.length > 0);
+		const joined = pieces.join("\n");
+		if (joined.trim().length > 0) {
+			const isError = (result as UnknownRecord).isError === true;
+			if (isError && !joined.toLowerCase().startsWith("error:")) {
+				return `error: ${joined}`;
+			}
+			return joined;
+		}
+	}
+
+	// Fallback: show the raw container (truncated downstream)
+	const fallback = tryStringify(result);
+	return fallback.trim().length > 0 ? fallback : null;
+}
+
 /**
  * Format a very small, terminal-safe preview of a tool result.
  * Intended for the tool call UI box (not full logs).
@@ -248,3 +392,47 @@ export function formatToolOutputPreview(toolName: string, result: unknown): stri
 
 	return outputLines.length > 0 ? outputLines : null;
 }
+
+/**
+ * Generic preview formatter for dynamic tools (e.g. MCP).
+ */
+export function formatGenericToolOutputPreview(result: unknown): string[] | null {
+	if (result === undefined) return null;
+
+	const raw = formatMcpLikeResult(result) ?? tryStringify(result);
+	if (!raw.trim()) return ["(no output)"];
+
+	const MAX_LINES = 4;
+	const MAX_CHARS_PER_LINE = 160;
+	const MAX_TOTAL_CHARS = 260;
+
+	const { lines, truncated: lineTruncated } = splitPreviewLines(raw, MAX_LINES);
+
+	let usedChars = 0;
+	const outputLines: string[] = [];
+	let anyTruncated = lineTruncated;
+
+	for (const line of lines) {
+		const remaining = Math.max(0, MAX_TOTAL_CHARS - usedChars);
+		if (remaining <= 0) {
+			anyTruncated = true;
+			break;
+		}
+		const { text: truncatedLine, truncated } = truncateText(line, Math.min(MAX_CHARS_PER_LINE, remaining));
+		anyTruncated = anyTruncated || truncated;
+		outputLines.push(truncatedLine);
+		usedChars += truncatedLine.length;
+	}
+
+	if (outputLines.length === 0) return ["(no output)"];
+
+	if (anyTruncated && outputLines.length > 0) {
+		const last = outputLines[outputLines.length - 1] ?? "";
+		if (!last.endsWith("…")) {
+			const { text } = truncateText(last, Math.max(1, last.length - 1));
+			outputLines[outputLines.length - 1] = `${text}…`.replace(/……$/, "…");
+		}
+	}
+
+	return outputLines;
+}