@qearlyao/familiar 0.2.1 → 0.2.3

package/README.md

@@ -85,6 +85,7 @@ node dist/cli.js init
 - `USER.md`
 - `MEMORY.md`
 - `HEARTBEAT.md`
+- `CONTACT.md`
 - `data/`
 - `memories/`
 - `skills/`
@@ -297,18 +298,6 @@ For OpenAI Responses models, Familiar strips replayed reasoning items from
 outgoing payloads while pi-ai sends `store: false`; otherwise OpenAI can reject
 later turns with missing `rs_...` item references.
 
-## Release Checks
-
-Before publishing:
-
-```sh
-npm run build
-npm pack --dry-run
-```
-
-The npm package is intentionally published from built output plus workspace
-templates, not the full source tree.
-
 ## License
 
 MIT

package/dist/browser-tools.js

@@ -120,7 +120,12 @@ function buildSpawnInvocation(spec, currentPlatform = platform(), comSpec = proc
     const commandLine = [spec.command, ...spec.args].map(quoteWindowsShellArg).join(" ");
     return {
         command: comSpec,
-        args: ["/d", "/s", "/c", commandLine],
+        // Windows npm shims are .cmd files, so we must cross cmd.exe here.
+        // The caller already validates browser.site/browser.command and individual
+        // args before they reach this shell boundary.
+        // cmd.exe strips one outer quote pair from the /c string. Wrap the whole
+        // already-quoted command so .cmd shims with spaced paths still receive argv.
+        args: ["/d", "/s", "/c", `"${commandLine}"`],
         options: {
             ...options,
             windowsVerbatimArguments: true,

package/dist/discord.js

@@ -1,18 +1,21 @@
 import { randomUUID } from "node:crypto";
 import { once } from "node:events";
+import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
 import { ApplicationCommandOptionType, ApplicationCommandType, ApplicationIntegrationType, ChannelType, Client, Events, GatewayIntentBits, InteractionContextType, MessageFlags, Partials, } from "discord.js";
 import { createAgentEventRecorder, storedAgentEventFromAgentEvent, thinkingDurationMs, updateAgentEventSummary, } from "./agent-events.js";
 import { chatChannelKey, createChatLog } from "./chat-log.js";
 import { materializeInboundAttachments, promptImagesFromAttachments } from "./inbound-attachments.js";
 import { ConversationRuntime } from "./runtime.js";
 import { appendSchedulerLog, buildCronInjectionText, buildHeartbeatInjectionText, dueCronSlot, isHeartbeatDue, loadSchedulerState, saveSchedulerState, } from "./scheduler.js";
+import { parseAgentReply as parseSilentMarker } from "./silent-marker.js";
 const FAMILIAR_COMMAND_NAME = "familiar";
 const THINKING_CHOICES = ["off", "minimal", "low", "medium", "high", "xhigh"];
 const CHANNEL_TRIGGER_CHOICES = ["mention", "always"];
 const EPHEMERAL_REPLY = MessageFlags.Ephemeral;
-const SILENT_RESPONSE_MARKER = "[[FAMILIAR_SILENT]]";
 const HEARTBEAT_SKIPPED = Symbol("heartbeat-skipped");
 const CRON_SKIPPED = Symbol("cron-skipped");
+const DISCORD_ATTACHMENT_SEND_TIMEOUT_MS = 20_000;
 async function withReadyClient(token) {
     const client = new Client({
         intents: [
@@ -326,16 +329,72 @@ async function delayBetweenBurstChunks(config, channel) {
 function normalizeOutboundText(text) {
     return text.trim() || "(empty response)";
 }
-function parseAgentReply(text) {
-    const normalized = text.replace(/\r\n/g, "\n").trim();
-    if (normalized === SILENT_RESPONSE_MARKER) {
-        return { text: "", silent: true };
+function fallbackMimeType(name) {
+    return extname(name).toLowerCase() === ".mp3" ? "audio/mpeg" : "application/octet-stream";
+}
+async function discordAttachmentPayload(attachment) {
+    if (!attachment.localPath)
+        return undefined;
+    const data = await readFile(attachment.localPath);
+    const bytes = new Uint8Array(data.byteLength);
+    bytes.set(data);
+    return {
+        bytes,
+        name: attachment.name,
+        mimeType: attachment.mimeType || fallbackMimeType(attachment.name),
+    };
+}
+async function discordAttachmentPayloads(attachments) {
+    const payloads = [];
+    for (const attachment of attachments) {
+        const payload = await discordAttachmentPayload(attachment);
+        if (payload)
+            payloads.push(payload);
     }
-    if (normalized.startsWith(`${SILENT_RESPONSE_MARKER}\n`)) {
-        const reason = normalized.slice(SILENT_RESPONSE_MARKER.length).trim();
-        return { text: reason, silent: true };
+    return payloads;
+}
+async function postDiscordAttachments(config, channelId, attachments) {
+    const files = await discordAttachmentPayloads(attachments);
+    if (files.length === 0)
+        return [];
+    const form = new FormData();
+    form.set("payload_json", JSON.stringify({}));
+    for (const [index, file] of files.entries()) {
+        form.set(`files[${index}]`, new Blob([file.bytes], { type: file.mimeType }), file.name);
     }
-    return { text: normalizeOutboundText(text), silent: false };
+    const response = await fetch(`https://discord.com/api/v10/channels/${channelId}/messages`, {
+        method: "POST",
+        headers: { Authorization: `Bot ${config.discord.token}` },
+        body: form,
+    });
+    const data = (await response.json().catch(() => ({})));
+    if (!response.ok || !data.id)
+        throw new Error(data.message || `Discord attachment send failed (${response.status})`);
+    return [data.id];
+}
+async function withDiscordSendTimeout(operation, label, timeoutMs = DISCORD_ATTACHMENT_SEND_TIMEOUT_MS) {
+    let timeout;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeout = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+    });
+    try {
+        return await Promise.race([operation, timeoutPromise]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+export const __test = {
+    discordAttachmentPayloads,
+    postDiscordAttachments,
+    withDiscordSendTimeout,
+};
+function parseAgentReply(text) {
+    const parsed = parseSilentMarker(text);
+    if (parsed.silent)
+        return parsed;
+    return { text: normalizeOutboundText(parsed.text), silent: false };
 }
 async function sendReply(config, message, text, replyToMessageId, attachments = []) {
     const normalizedText = normalizeOutboundText(text);
@@ -344,7 +403,6 @@ async function sendReply(config, message, text, replyToMessageId, attachments =
     for (const [index, chunk] of chunks.entries()) {
         if (index > 0)
             await delayBetweenBurstChunks(config, message.channel);
-        const files = index === 0 ? attachments.flatMap((attachment) => (attachment.localPath ? [attachment.localPath] : [])) : [];
         let sent;
         if (index === 0 && config.discord.replyMode === "reply") {
             try {
@@ -352,7 +410,7 @@ async function sendReply(config, message, text, replyToMessageId, attachments =
                 if (!message.channel.isSendable()) {
                     throw new Error(`Discord channel is not sendable: ${message.channelId}`);
                 }
-                const options = { content: chunk, reply: { messageReference: replyTarget }, files };
+                const options = { content: chunk, reply: { messageReference: replyTarget } };
                 sent = await message.channel.send(options);
                 sentIds.push(sent.id);
                 continue;
@@ -364,9 +422,10 @@ async function sendReply(config, message, text, replyToMessageId, attachments =
         if (!message.channel.isSendable()) {
             throw new Error(`Discord channel is not sendable: ${message.channelId}`);
         }
-        sent = await message.channel.send(files.length > 0 ? { content: chunk, files } : chunk);
+        sent = await message.channel.send(chunk);
         sentIds.push(sent.id);
     }
+    sendDiscordAttachmentsInBackground(config, message.channelId, attachments);
     return sentIds;
 }
 async function sendChannelMessage(config, channel, text, attachments = []) {
@@ -379,12 +438,19 @@ async function sendChannelMessage(config, channel, text, attachments = []) {
     for (const [index, chunk] of chunks.entries()) {
         if (index > 0)
             await delayBetweenBurstChunks(config, channel);
-        const files = index === 0 ? attachments.flatMap((attachment) => (attachment.localPath ? [attachment.localPath] : [])) : [];
-        const sent = await channel.send(files.length > 0 ? { content: chunk, files } : chunk);
+        const sent = await channel.send(chunk);
         sentIds.push(sent.id);
     }
+    sendDiscordAttachmentsInBackground(config, channel.id, attachments);
     return sentIds;
 }
+function sendDiscordAttachmentsInBackground(config, channelId, attachments) {
+    if (attachments.length === 0)
+        return;
+    void withDiscordSendTimeout(postDiscordAttachments(config, channelId, attachments), "Discord attachment send").catch((error) => {
+        console.error("Discord attachment send failed", error);
+    });
+}
 function buildChannelRef(channel, channelId) {
     const scope = channel.type === ChannelType.DM ? "dm" : channel.isThread() ? "thread" : "channel";
     const channelName = "name" in channel ? channel.name : undefined;
@@ -775,9 +841,13 @@ export async function startDiscordDaemon(config, familiarAgent, settings, memory
                     await recorder.flush();
                 }
                 const parsedReply = parseAgentReply(reply.text);
+                const replyAnchor = await fetchMessageAnchor(message, dispatch.triggerMessageId);
                 const messageIds = parsedReply.silent
                     ? []
-                    : await sendReply(config, await fetchMessageAnchor(message, dispatch.triggerMessageId), parsedReply.text, dispatch.triggerMessageId, reply.attachments);
+                    : await sendReply(config, replyAnchor, parsedReply.text, dispatch.triggerMessageId, reply.attachments);
+                if (parsedReply.silent) {
+                    sendDiscordAttachmentsInBackground(config, replyAnchor.channelId, reply.attachments);
+                }
                 await runtime.completeActiveJob({
                     text: parsedReply.text,
                     messageIds,
@@ -867,6 +937,8 @@ export async function startDiscordDaemon(config, familiarAgent, settings, memory
             const messageIds = parsedReply.silent
                 ? []
                 : await sendChannelMessage(config, channel, parsedReply.text, reply.attachments);
+            if (parsedReply.silent)
+                sendDiscordAttachmentsInBackground(config, channel.id, reply.attachments);
             await heartbeatRuntime.noteOutbound({
                 text: parsedReply.text,
                 messageIds,
@@ -979,6 +1051,8 @@ export async function startDiscordDaemon(config, familiarAgent, settings, memory
         const messageIds = parsedReply.silent
             ? []
             : await sendChannelMessage(config, channel, parsedReply.text, reply.attachments);
+        if (parsedReply.silent)
+            sendDiscordAttachmentsInBackground(config, channel.id, reply.attachments);
         await runtime.noteOutbound({
             text: parsedReply.text,
             messageIds,

package/dist/inbound-attachments.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
-import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { basename, extname, resolve } from "node:path";
 import { attachmentsDir, publicAttachmentPath } from "./generated-media.js";
 import { ensureInlineImageDerivative, MAX_INLINE_IMAGE_BASE64_BYTES } from "./image-derivatives.js";
@@ -184,6 +184,7 @@ export async function materializeInboundAttachments(config, inputs) {
     }
     const stored = [];
     const writtenPaths = [];
+    const existingDerivedPaths = await knownDerivedImagePaths(config);
     try {
         for (const attachment of prepared) {
             const dir = resolve(attachmentsDir(config), "inbound", attachment.source);
@@ -205,6 +206,10 @@ export async function materializeInboundAttachments(config, inputs) {
             };
             const derivedImage = await ensureInlineImageDerivative(config, finalAttachment);
             if (derivedImage) {
+                if (derivedImage.localPath && !existingDerivedPaths.has(derivedImage.localPath)) {
+                    writtenPaths.push(derivedImage.localPath);
+                    existingDerivedPaths.add(derivedImage.localPath);
+                }
                 finalAttachment.derived = {
                     ...finalAttachment.derived,
                     image: derivedImage,
@@ -219,6 +224,11 @@ export async function materializeInboundAttachments(config, inputs) {
         throw error;
     }
 }
+async function knownDerivedImagePaths(config) {
+    const dir = resolve(attachmentsDir(config), "derived", "image");
+    const entries = await readdir(dir).catch(() => []);
+    return new Set(entries.map((entry) => resolve(dir, entry)));
+}
 export async function promptImagesFromAttachments(attachments) {
     const images = [];
     const notes = [];

package/dist/memory/index/chunk-indexer.js

@@ -15,8 +15,11 @@ export class ChunkIndexer {
     async replaceSource(corpus, sourceId, inputs, signal) {
         const prepared = this.prepare(inputs.map((input) => ({ ...input, corpus, sourceId })));
         const keepMappings = prepared.map((item) => ({ contentHash: item.contentHash, chunkIndex: item.chunkIndex }));
-        this.store.deleteBySourceExceptMappings(corpus, sourceId, keepMappings);
-        const result = await this.insertPrepared(prepared, inputs.length - prepared.length, signal);
+        const result = await this.insertPrepared(prepared, inputs.length - prepared.length, signal, {
+            corpus,
+            sourceId,
+            keepMappings,
+        });
         return result;
     }
     prepare(inputs) {
@@ -46,10 +49,14 @@ export class ChunkIndexer {
         }
         return prepared;
     }
-    async insertPrepared(prepared, skipped, signal) {
+    async insertPrepared(prepared, skipped, signal, replaceSource) {
         const startedAt = Date.now();
-        if (prepared.length === 0)
+        if (prepared.length === 0) {
+            if (replaceSource) {
+                this.store.deleteBySourceExceptMappings(replaceSource.corpus, replaceSource.sourceId, []);
+            }
             return { ids: [], embedded: 0, reused: 0, skipped };
+        }
         const present = this.store.whichHashesPresent(prepared.map((item) => item.contentHash));
         for (const item of prepared)
             item.existingId = present.get(item.contentHash) ?? null;
@@ -125,8 +132,18 @@ export class ChunkIndexer {
                 embedding,
             });
         }
-        this.store.recordSourceMappings(existingMappings);
-        const insertedIds = this.store.insertChunks(toInsert);
+        let insertedIds = [];
+        const writeChunks = () => {
+            if (replaceSource) {
+                this.store.deleteBySourceExceptMappings(replaceSource.corpus, replaceSource.sourceId, replaceSource.keepMappings);
+            }
+            this.store.recordSourceMappings(existingMappings);
+            insertedIds = this.store.insertChunks(toInsert);
+        };
+        if (replaceSource && !this.store.db.inTransaction)
+            this.store.db.transaction(writeChunks).immediate();
+        else
+            writeChunks();
         for (let index = 0; index < insertPositions.length; index++) {
             ids[insertPositions[index]] = insertedIds[index];
         }

package/dist/memory/lcm/context-transformer.js

@@ -149,19 +149,15 @@ export class LcmContextTransformer {
                 mode: candidate.reasons.includes("context_threshold") ? "aggressive" : "normal",
                 previousSummary,
             }, input.signal);
-            const summaryId = `${input.sessionKey}:summary-${++state.summaryCounter}`;
             const message = createSyntheticLcmSummaryMessage(renderLcmSummaryMessage(summaryText), this.now());
             const summaryItem = {
                 type: "summary",
-                id: summaryId,
+                id: "",
                 sourceIds: chunkItems.map((item) => item.id),
                 depth: 1,
                 message,
                 tokens: estimateAgentMessageTokens(message),
             };
-            state.items.splice(startIndex, removeCount, summaryItem);
-            compacted = true;
-            tokensSaved = Math.max(0, candidate.chunkTokens - summaryItem.tokens);
             const persisted = await this.persistRuntimeSummary({
                 text: summaryText,
                 sourceItems: chunkItems,
@@ -169,8 +165,12 @@ export class LcmContextTransformer {
                 sessionId: input.sessionId,
                 signal: input.signal,
             });
+            summaryItem.id = `${input.sessionKey}:summary-${++state.summaryCounter}`;
             if (persisted?.summaryId !== undefined)
                 summaryItem.persistedSummaryId = persisted.summaryId;
+            state.items.splice(startIndex, removeCount, summaryItem);
+            compacted = true;
+            tokensSaved = Math.max(0, candidate.chunkTokens - summaryItem.tokens);
             await this.condenseRuntimeSummaries({ state, sessionKey: input.sessionKey, signal: input.signal });
         };
         input.state.compactionQueue = input.state.compactionQueue.then(run, run);

package/dist/memory/operator.js

@@ -221,39 +221,13 @@ async function prune(service, options) {
         console.log("Prune cancelled");
         return;
     }
-    const activeSegments = service.lcmStore.listSegments().filter((segment) => segment.status === "active");
-    const activeSegmentId = activeSegments.at(-1)?.id ?? null;
-    const runClose = () => {
-        for (const segment of activeSegments) {
-            if (segment.id !== activeSegmentId)
-                service.lcmStore.closeSegment(segment.id);
-        }
-    };
-    if (service.lcmStore.db.inTransaction)
-        runClose();
-    else
-        service.lcmStore.db.transaction(runClose).immediate();
     const report = service.lcmStore.applyNewSessionRetention({
         newSessionRetainDepth: options.retainDepth,
-        activeSegmentId,
+        activeSegmentId: null,
         vacuum: options.vacuum,
     });
     for (const ref of report.indexDeletes)
         service.memoryStore.deleteBySource(ref.corpus, ref.sourceId);
-    const closedActive = activeSegments.filter((segment) => segment.id !== activeSegmentId);
-    if (closedActive.length > 0) {
-        const runReopen = () => {
-            for (const segment of closedActive) {
-                service.lcmStore.db
-                    .prepare("UPDATE lcm_segments SET status = 'active', closed_at = NULL, updated_at = unixepoch() WHERE id = ?")
-                    .run(segment.id);
-            }
-        };
-        if (service.lcmStore.db.inTransaction)
-            runReopen();
-        else
-            service.lcmStore.db.transaction(runReopen).immediate();
-    }
     console.log(`Pruned ${report.rawRecordsDeleted} raw record(s), ${report.summariesDeleted} summary row(s), ` +
         `${report.affectedSegments.length} closed segment(s) scanned`);
 }

package/dist/persona.js

@@ -41,7 +41,7 @@ ${renderedFiles}
 <note_to_self>
 you can edit MEMORY.md when something about her is worth keeping.
 CONTACT.md is what you call her in your contact book — like a nickname only you use. edit it whenever it feels right.
-output [[FAMILIAR_SILENT]] if there's nothing worth saying — quiet's a real choice.
+when there's nothing worth saying, reply with exactly the literal string [[FAMILIAR_SILENT]]. quiet's a real choice.
 </note_to_self>
 ${renderedSkillsBlock}
 </system-reminder>`;

package/dist/runtime.js

@@ -91,6 +91,8 @@ export class ConversationRuntime {
         for (const record of this.records) {
             if (record.type === "job_completed" || record.type === "job_failed")
                 terminalJobIds.add(record.jobId);
+            if (record.type === "outbound" && record.jobId)
+                terminalJobIds.add(record.jobId);
             if (record.type === "job_queued") {
                 queuedJobs.push({
                     jobId: record.jobId,
@@ -180,9 +182,17 @@ export class ConversationRuntime {
     }
     getLastCompletedTriggerRecordId() {
         let last = 0;
+        const queuedTriggerRecordIds = new Map();
         for (const record of this.records) {
+            if (record.type === "job_queued")
+                queuedTriggerRecordIds.set(record.jobId, record.triggerRecordId);
             if (record.type === "job_completed")
                 last = Math.max(last, record.triggerRecordId);
+            if (record.type === "outbound" && record.jobId) {
+                const triggerRecordId = queuedTriggerRecordIds.get(record.jobId);
+                if (triggerRecordId !== undefined)
+                    last = Math.max(last, triggerRecordId);
+            }
         }
         return last;
     }

package/dist/service.js

@@ -8,20 +8,21 @@ const execFileAsync = promisify(execFile);
 const SERVICE_LABEL = "com.qearlyao.familiar";
 const SYSTEMD_SERVICE = "familiar.service";
 function servicePaths(workspacePath, input) {
-    const logDir = resolve(workspacePath, "logs");
+    const logDir = input.resolvePath(workspacePath, "logs");
     return {
         servicePath: input.platform === "darwin"
-            ? resolve(input.homeDir, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`)
-            : resolve(input.homeDir, ".config", "systemd", "user", SYSTEMD_SERVICE),
+            ? input.resolvePath(input.homeDir, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`)
+            : input.resolvePath(input.homeDir, ".config", "systemd", "user", SYSTEMD_SERVICE),
         logDir,
-        stdoutPath: resolve(logDir, "familiar.out.log"),
-        stderrPath: resolve(logDir, "familiar.err.log"),
+        stdoutPath: input.resolvePath(logDir, "familiar.out.log"),
+        stderrPath: input.resolvePath(logDir, "familiar.err.log"),
     };
 }
 function buildSpec(workspacePath, options = {}) {
     const currentPlatform = options.platform ?? platform();
     const cliPath = options.cliPath ?? currentCliPath();
-    const resolvedWorkspacePath = resolve(workspacePath);
+    const resolvePath = options.resolvePath ?? resolve;
+    const resolvedWorkspacePath = resolvePath(workspacePath);
     return {
         platform: currentPlatform,
         workspacePath: resolvedWorkspacePath,
@@ -30,6 +31,7 @@ function buildSpec(workspacePath, options = {}) {
         paths: servicePaths(resolvedWorkspacePath, {
             platform: currentPlatform,
             homeDir: options.homeDir ?? homedir(),
+            resolvePath,
         }),
     };
 }
@@ -153,8 +155,8 @@ async function runOptional(command, args, options) {
         // Best-effort cleanup for stale service registrations.
     }
 }
-function guiDomain() {
-    return `gui/${userInfo().uid}`;
+function guiDomain(options = {}) {
+    return `gui/${options.userId ?? userInfo().uid}`;
 }
 function unsupported(platformName) {
     return {
@@ -174,9 +176,9 @@ export async function installService(workspacePath, options = {}) {
     const serviceText = spec.platform === "darwin" ? launchdPlist(spec) : systemdUnit(spec);
     await writeFile(spec.paths.servicePath, serviceText, "utf8");
     if (spec.platform === "darwin") {
-        await runOptional("launchctl", ["bootout", guiDomain(), spec.paths.servicePath], options);
-        await run("launchctl", ["bootstrap", guiDomain(), spec.paths.servicePath], options);
-        await run("launchctl", ["kickstart", "-k", `${guiDomain()}/${SERVICE_LABEL}`], options);
+        await runOptional("launchctl", ["bootout", guiDomain(options), spec.paths.servicePath], options);
+        await run("launchctl", ["bootstrap", guiDomain(options), spec.paths.servicePath], options);
+        await run("launchctl", ["kickstart", "-k", `${guiDomain(options)}/${SERVICE_LABEL}`], options);
     }
     else {
         if (!(await hasCommand("systemctl", options))) {
@@ -204,7 +206,7 @@ export async function uninstallService(workspacePath, options = {}) {
     if (spec.platform !== "darwin" && spec.platform !== "linux")
         return unsupported(spec.platform);
     if (spec.platform === "darwin") {
-        await runOptional("launchctl", ["bootout", guiDomain(), spec.paths.servicePath], options);
+        await runOptional("launchctl", ["bootout", guiDomain(options), spec.paths.servicePath], options);
     }
     else {
         if (await hasCommand("systemctl", options)) {
@@ -242,7 +244,7 @@ export async function serviceStatus(workspacePath, options = {}) {
 async function supervisorState(spec, options) {
     try {
         if (spec.platform === "darwin") {
-            await capture("launchctl", ["print", `${guiDomain()}/${SERVICE_LABEL}`], options);
+            await capture("launchctl", ["print", `${guiDomain(options)}/${SERVICE_LABEL}`], options);
             return "loaded";
         }
         const state = (await capture("systemctl", ["--user", "is-active", SYSTEMD_SERVICE], options)).trim();

package/dist/silent-marker.js

@@ -0,0 +1,64 @@
+export const SILENT_RESPONSE_MARKER = "[[FAMILIAR_SILENT]]";
+function normalizeNewlines(text) {
+    return text.replace(/\r\n/g, "\n");
+}
+export function parseAgentReply(text) {
+    const normalized = normalizeNewlines(text);
+    if (normalized === SILENT_RESPONSE_MARKER) {
+        return { text: "", silent: true };
+    }
+    if (normalized.startsWith(`${SILENT_RESPONSE_MARKER}\n`)) {
+        return { text: normalized.slice(SILENT_RESPONSE_MARKER.length + 1), silent: true };
+    }
+    return { text, silent: false };
+}
+export function createSilentFilterState() {
+    return { accumulated: "", buffered: "", silent: false, carryCR: false };
+}
+function normalizeStreamingChunk(state, chunk) {
+    let working = chunk;
+    if (state.carryCR) {
+        state.carryCR = false;
+        working = `\r${working}`;
+    }
+    if (working.endsWith("\r")) {
+        state.carryCR = true;
+        working = working.slice(0, -1);
+    }
+    return working.replace(/\r\n/g, "\n");
+}
+export function consumeSilentDelta(state, delta) {
+    if (state.silent)
+        return { kind: "silent" };
+    const normalized = normalizeStreamingChunk(state, delta);
+    state.accumulated += normalized;
+    state.buffered += normalized;
+    if (state.accumulated.startsWith(`${SILENT_RESPONSE_MARKER}\n`)) {
+        state.silent = true;
+        state.buffered = "";
+        return { kind: "silent" };
+    }
+    if (SILENT_RESPONSE_MARKER.startsWith(state.accumulated)) {
+        return { kind: "buffer" };
+    }
+    const emit = state.buffered;
+    state.buffered = "";
+    return emit ? { kind: "emit", text: emit } : { kind: "buffer" };
+}
+export function finalizeSilentFilter(state) {
+    if (state.carryCR) {
+        state.buffered += "\r";
+        state.accumulated += "\r";
+        state.carryCR = false;
+    }
+    if (state.silent)
+        return { silent: true, flush: "" };
+    if (state.accumulated === SILENT_RESPONSE_MARKER) {
+        state.silent = true;
+        state.buffered = "";
+        return { silent: true, flush: "" };
+    }
+    const flush = state.buffered;
+    state.buffered = "";
+    return { silent: false, flush };
+}

package/dist/web-static.js

@@ -54,7 +54,29 @@ export async function serveStatic(response, requestPath) {
     stream.pipe(response);
     return true;
 }
-export async function serveAttachment(config, response, requestPath) {
+function parseRangeHeader(rangeHeader, size) {
+    if (!rangeHeader)
+        return undefined;
+    const match = /^bytes=(\d*)-(\d*)$/.exec(rangeHeader.trim());
+    if (!match)
+        return undefined;
+    const [, rawStart, rawEnd] = match;
+    if (!rawStart && !rawEnd)
+        return undefined;
+    if (!rawStart) {
+        const suffixLength = Number(rawEnd);
+        if (!Number.isSafeInteger(suffixLength) || suffixLength <= 0)
+            return undefined;
+        return { start: Math.max(0, size - suffixLength), end: size - 1 };
+    }
+    const start = Number(rawStart);
+    const end = rawEnd ? Number(rawEnd) : size - 1;
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start || start >= size) {
+        return undefined;
+    }
+    return { start, end: Math.min(end, size - 1) };
+}
+export async function serveAttachment(config, response, requestPath, rangeHeader) {
     const relativePath = decodeURIComponent(requestPath.replace(/^\/api\/web\/attachments\/?/, ""));
     if (!relativePath) {
         sendText(response, 404, "Not found");
@@ -93,9 +115,22 @@ export async function serveAttachment(config, response, requestPath) {
         const fileStat = await stat(fileRealPath).catch(() => undefined);
         if (!fileStat?.isFile())
             continue;
+        const range = parseRangeHeader(rangeHeader, fileStat.size);
+        if (range) {
+            response.writeHead(206, {
+                "content-type": mimeType(filePath),
+                "content-length": String(range.end - range.start + 1),
+                "content-range": `bytes ${range.start}-${range.end}/${fileStat.size}`,
+                "accept-ranges": "bytes",
+                "cache-control": "private, max-age=31536000, immutable",
+            });
+            createReadStream(fileRealPath, { start: range.start, end: range.end }).pipe(response);
+            return true;
+        }
         response.writeHead(200, {
             "content-type": mimeType(filePath),
             "content-length": String(fileStat.size),
+            "accept-ranges": "bytes",
             "cache-control": "private, max-age=31536000, immutable",
         });
         createReadStream(fileRealPath).pipe(response);