editmamei 1.4.0 → 1.5.1

package/dist/telemetry/activity.js

@@ -0,0 +1,149 @@
+export const READ_ONLY_TOOLS = new Set([
+    'ps_sequence',
+    'ps_batch',
+    'ps_ping',
+    'ps_overview',
+    'ps_list_capabilities',
+    'ps_get_preview',
+    'ps_get_selection_preview',
+    'ps_get_histogram',
+    'ps_inspect',
+    'ps_read_scene',
+    'ps_compare_regions',
+    'ps_get_layer_bounds_diff',
+    'ps_template_list',
+    'ps_template_recall',
+    'ps_list_actions',
+    'ps_report_problem',
+    'ps_detect',
+    'ps_detect_landmarks',
+    'ps_document',
+    'ps_template_verify',
+    'ps_resolve_placement',
+    'ps_template_save',
+    'ps_template_delete',
+    'ps_template_create_evidence',
+]);
+export const KEPT_WORK_TOOLS = new Set(['ps_export', 'ps_save_psd']);
+export const MUTATING_TOOLS = new Set([
+    'ps_play_action',
+    'ps_execute_script',
+    'ps_add_adjustment_layer',
+    'ps_apply_adjustment',
+    'ps_create_document',
+    'ps_close_document',
+    'ps_open_document',
+    'ps_develop_raw',
+    'ps_filter',
+    'ps_group',
+    'ps_clipping_mask',
+    'ps_undo',
+    'ps_redo',
+    'ps_place_image',
+    'ps_resize_image',
+    'ps_crop_document',
+    'ps_convert_image_mode',
+    'ps_move_layer_to_position',
+    'ps_convert_to_smart_object',
+    'ps_rasterize_layer',
+    'ps_set_layer',
+    'ps_duplicate_layer',
+    'ps_copy_to_new_layer',
+    'ps_merge',
+    'ps_bake_layer',
+    'ps_add_layer_style',
+    'ps_create_layer',
+    'ps_delete_layer',
+    'ps_fill_layer',
+    'ps_add_fill_layer',
+    'ps_select_layer',
+    'ps_transform_layer',
+    'ps_warp_layer',
+    'ps_warp_layer_mesh',
+    'ps_warp_layer_along',
+    'ps_warp_layer_region',
+    'ps_warp_layer_to',
+    'ps_apply_camera_raw',
+    'ps_transform_canvas',
+    'ps_guides',
+    'ps_retouch',
+    'ps_apply_brush_stroke',
+    'ps_edit_object',
+    'ps_portrait_touchup',
+    'ps_add_text_to_object',
+    'ps_select_face_feature',
+    'ps_stroke_face_contour',
+    'ps_select_by_reference',
+    'ps_select',
+    'ps_select_subject',
+    'ps_select_sky',
+    'ps_select_subject_instance',
+    'ps_select_object',
+    'ps_replace_sky',
+    'ps_modify_selection',
+    'ps_selection_channel',
+    'ps_layer_mask',
+    'ps_path',
+    'ps_vector_mask',
+    'ps_apply_image',
+    'ps_calculations',
+    'ps_shape',
+    'ps_template_apply',
+    'ps_text',
+]);
+export function mapClientName(name) {
+    if (name === undefined)
+        return 'other';
+    const n = name.toLowerCase();
+    if (n.includes('claude-code') || n.includes('claude_code') || n.includes('claudecode')) {
+        return 'claude_code';
+    }
+    if (n.includes('claude'))
+        return 'claude_desktop';
+    if (n.includes('cursor'))
+        return 'cursor';
+    if (n.includes('windsurf'))
+        return 'windsurf';
+    if (n.includes('vscode') || n.includes('visual studio') || n.includes('code-oss')) {
+        return 'vscode';
+    }
+    return 'other';
+}
+export function parseMajor(version) {
+    if (version === undefined)
+        return null;
+    const m = /^(\d+)/.exec(version.trim());
+    return m ? Number(m[1]) : null;
+}
+export function boundMajor(n, max) {
+    return n !== null && Number.isFinite(n) && n >= 0 && n <= max ? n : null;
+}
+export function nodeMajor() {
+    return parseMajor(process.versions.node);
+}
+export function archToken() {
+    if (process.arch === 'x64')
+        return 'x64';
+    if (process.arch === 'arm64')
+        return 'arm64';
+    return 'other';
+}
+export function osMajor(platform, release) {
+    if (platform === 'win32') {
+        const parts = release.split('.');
+        const major = Number(parts[0]);
+        if (!Number.isFinite(major))
+            return null;
+        const build = Number(parts[2]);
+        return Number.isFinite(build) && build >= 22000 ? 11 : major;
+    }
+    if (platform === 'darwin') {
+        const m = /^(\d+)/.exec(release);
+        if (!m)
+            return null;
+        const darwinMajor = Number(m[1]);
+        return darwinMajor <= 24 ? darwinMajor - 9 : darwinMajor + 1;
+    }
+    const m = /^(\d+)/.exec(release);
+    return m ? Number(m[1]) : null;
+}

package/dist/telemetry/client.js

@@ -1,15 +1,19 @@
+import { release } from 'node:os';
 import { Logger } from '../utils/logger.js';
 import { EDITION } from '../edition.js';
 import { VERSION } from '../version.js';
 import { resolveInstallChannel } from '../install-channel.js';
-import { buildDiagnosticEvent, buildModuleStatus, buildSessionStart, buildSessionSummary, buildUsageEvent, dayBucket, normalizeDayBucket, isContentSafe, PS_VERSION_UNKNOWN, } from './events.js';
+import { READ_ONLY_TOOLS, KEPT_WORK_TOOLS, nodeMajor, archToken, osMajor, boundMajor, } from './activity.js';
+import { buildClientConnected, buildDiagnosticEvent, buildModuleStatus, buildSessionStart, buildSessionSummary, buildUsageEvent, dayBucket, normalizeDayBucket, isContentSafe, PS_VERSION_UNKNOWN, } from './events.js';
 import { sanitizeMessage, sanitizeSnippet, sanitizeStderrTail } from './sanitize.js';
 import { httpTransport, resolveEndpoint } from './transport.js';
-import { appendOutboxSync, clearOutbox, clearSessionState, readOutbox, readSessionState, writeSessionStateSync, } from './outbox.js';
+import { appendOutboxSync, clearOutbox, clearSessionState, readOutboxWithDiscards, readSessionState, rewriteOutbox, writeSessionStateSync, } from './outbox.js';
 const MAX_BATCH_SIZE = 100;
 const MAX_QUEUE_SIZE = 500;
 const DEFAULT_FLUSH_INTERVAL_MS = 5 * 60_000;
 const SESSION_PERSIST_THROTTLE_MS = 10_000;
+const MAX_SESSION_DURATION_S = 604_800;
+const MAX_INSTALL_ASSET_COUNT = 100_000;
 function isTestEnv() {
     return process.env.VITEST !== undefined || process.env.NODE_ENV === 'test';
 }
@@ -25,12 +29,26 @@ export class TelemetryClient {
     active;
     outboxOpts;
     getModuleStatus;
+    resolvedModuleStatus = null;
     queue = [];
     timer = null;
     shutdownPromise = null;
     toolCallCount = 0;
     distinctTools = new Set();
     anyFailures = false;
+    firstCallAtMs = null;
+    lastCallAtMs = null;
+    retryCount = 0;
+    lastCallSuccess = null;
+    editsOk = 0;
+    keptWork = 0;
+    droppedEvents = 0;
+    droppedOutbox = 0;
+    droppedUnsafe = 0;
+    usageCallsSent = 0;
+    behindLatest = null;
+    moduleUpdate = 'none';
+    installAssets = {};
     lastSessionPersistMs = 0;
     startDayBucket = null;
     constructor(opts) {
@@ -61,24 +79,98 @@ export class TelemetryClient {
         this.timer = setInterval(() => void this.flush(), this.flushIntervalMs);
         this.timer.unref?.();
         if (this.settings.telemetry.usage) {
-            this.enqueue(buildSessionStart(this.dims, this.now()));
-            const moduleStatus = this.getModuleStatus();
+            const hostNodeMajor = boundMajor(nodeMajor(), 999);
+            const hostOsMajor = boundMajor(osMajor(process.platform, release()), 999);
+            this.enqueue(buildSessionStart(this.dims, this.now(), {
+                ...(hostNodeMajor !== null ? { node_major: hostNodeMajor } : {}),
+                arch: archToken(),
+                ...(hostOsMajor !== null ? { os_major: hostOsMajor } : {}),
+            }));
+            const moduleStatus = this.moduleStatus();
             if (moduleStatus)
                 this.enqueue(buildModuleStatus(this.dims, moduleStatus, this.now()));
             void this.flush();
         }
     }
+    recordClientConnected(info) {
+        if (!this.active || !this.settings.telemetry.usage)
+            return;
+        this.enqueue(buildClientConnected(this.dims, info, this.now()));
+    }
     recordCall(call) {
         if (!this.active || !this.settings.telemetry.usage)
             return;
         this.ensureStartDayBucket();
+        const nowDate = this.now();
+        const nowMs = nowDate.getTime();
         this.toolCallCount += 1;
         this.distinctTools.add(call.tool);
         if (!call.success)
             this.anyFailures = true;
-        this.enqueue(buildUsageEvent(this.dims, call, this.now()));
+        this.lastCallSuccess = call.success;
+        if (call.retry)
+            this.retryCount += 1;
+        if (call.success) {
+            if (!READ_ONLY_TOOLS.has(call.tool))
+                this.editsOk += 1;
+            if (KEPT_WORK_TOOLS.has(call.tool))
+                this.keptWork += 1;
+        }
+        if (this.firstCallAtMs === null)
+            this.firstCallAtMs = nowMs;
+        this.lastCallAtMs = nowMs;
+        this.enqueue(buildUsageEvent(this.dims, call, nowDate));
         this.persistSessionStateThrottled();
     }
+    setBehindLatest(value) {
+        this.behindLatest = value;
+    }
+    setModuleUpdate(outcome) {
+        this.moduleUpdate = outcome;
+    }
+    setInstallAssets(assets) {
+        const templatesSaved = assets.templates_saved !== undefined ? clampCount(assets.templates_saved) : null;
+        const actionSets = assets.action_sets !== undefined ? clampCount(assets.action_sets) : null;
+        this.installAssets = {
+            ...this.installAssets,
+            ...(templatesSaved !== null ? { templates_saved: templatesSaved } : {}),
+            ...(actionSets !== null ? { action_sets: actionSets } : {}),
+        };
+    }
+    moduleStatus() {
+        if (this.resolvedModuleStatus === null) {
+            this.resolvedModuleStatus = { value: this.getModuleStatus() };
+        }
+        return this.resolvedModuleStatus.value;
+    }
+    durationS() {
+        if (this.firstCallAtMs === null || this.lastCallAtMs === null)
+            return undefined;
+        return Math.min(Math.max(0, Math.floor((this.lastCallAtMs - this.firstCallAtMs) / 1000)), MAX_SESSION_DURATION_S);
+    }
+    summaryFields() {
+        const duration = this.durationS();
+        const moduleStatus = this.moduleStatus();
+        return {
+            ...(duration !== undefined ? { duration_s: duration } : {}),
+            retry_count: this.retryCount,
+            ...(this.lastCallSuccess !== null ? { ended_after_failure: !this.lastCallSuccess } : {}),
+            edits_ok: this.editsOk,
+            kept_work: this.keptWork,
+            ...(this.behindLatest !== null ? { behind_latest: this.behindLatest } : {}),
+            dropped_events: this.droppedEvents,
+            dropped_outbox: this.droppedOutbox,
+            dropped_unsafe: this.droppedUnsafe,
+            usage_calls_sent: this.usageCallsSent,
+            ...(moduleStatus !== null ? { module_update: this.moduleUpdate } : {}),
+            ...(this.installAssets.templates_saved !== undefined
+                ? { templates_saved: this.installAssets.templates_saved }
+                : {}),
+            ...(this.installAssets.action_sets !== undefined
+                ? { action_sets: this.installAssets.action_sets }
+                : {}),
+        };
+    }
     psVersion() {
         const v = this.dims.getPsVersion();
         return v && v.length > 0 ? v : PS_VERSION_UNKNOWN;
@@ -105,6 +197,7 @@ export class TelemetryClient {
             tool_call_count: this.toolCallCount,
             distinct_tools: this.distinctTools.size,
             any_failures: this.anyFailures,
+            ...this.summaryFields(),
         };
         writeSessionStateSync(state, this.outboxOpts);
     }
@@ -123,6 +216,9 @@ export class TelemetryClient {
             error_message: sanitizeMessage(diag.error_message),
             ...(diag.snippet ? { snippet: sanitizeSnippet(diag.snippet) } : {}),
             ...(diag.stderr_tail ? { stderr_tail: sanitizeStderrTail(diag.stderr_tail) } : {}),
+            ...(diag.doc_depth !== undefined ? { doc_depth: diag.doc_depth } : {}),
+            ...(diag.doc_mode !== undefined ? { doc_mode: diag.doc_mode } : {}),
+            ...(diag.ps_locale !== undefined ? { ps_locale: diag.ps_locale } : {}),
         }, this.now()));
     }
     restampPsVersion(events) {
@@ -141,7 +237,9 @@ export class TelemetryClient {
     enqueue(event) {
         this.queue.push(event);
         if (this.queue.length > MAX_QUEUE_SIZE) {
-            this.queue.splice(0, this.queue.length - MAX_QUEUE_SIZE);
+            const excess = this.queue.length - MAX_QUEUE_SIZE;
+            this.queue.splice(0, excess);
+            this.droppedEvents += excess;
         }
         if (this.queue.length >= this.maxBatchSize)
             void this.flush();
@@ -149,15 +247,18 @@ export class TelemetryClient {
     async flush() {
         if (!this.active || this.queue.length === 0)
             return;
-        const batch = this.restampPsVersion(this.queue.splice(0, this.maxBatchSize)).filter(isContentSafe);
+        const picked = this.restampPsVersion(this.queue.splice(0, this.maxBatchSize));
+        const batch = picked.filter(isContentSafe);
+        this.droppedUnsafe += picked.length - batch.length;
         if (batch.length === 0)
             return;
         try {
             await this.transport(this.endpoint, JSON.stringify({ events: batch }));
+            this.usageCallsSent += countUsageCalls(batch);
         }
         catch (err) {
             this.logger.debug(`telemetry flush failed, persisting ${batch.length} event(s) to outbox: ${errMsg(err)}`);
-            appendOutboxSync(batch, this.outboxOpts);
+            this.droppedOutbox += appendOutboxSync(batch, this.outboxOpts);
         }
     }
     shutdown() {
@@ -172,15 +273,26 @@ export class TelemetryClient {
         }
         if (!this.active)
             return;
-        if (this.settings.telemetry.usage && this.toolCallCount > 0) {
-            this.enqueue(buildSessionSummary(this.dims, {
+        if (this.queue.length > 0) {
+            const picked = this.restampPsVersion(this.queue.splice(0));
+            const batch = picked.filter(isContentSafe);
+            this.droppedUnsafe += picked.length - batch.length;
+            this.droppedOutbox += appendOutboxSync(batch, this.outboxOpts);
+        }
+        const hasLossToReport = this.droppedEvents > 0 || this.droppedOutbox > 0 || this.droppedUnsafe > 0;
+        if (this.settings.telemetry.usage && (this.toolCallCount > 0 || hasLossToReport)) {
+            const summary = buildSessionSummary(this.dims, {
                 tool_call_count: this.toolCallCount,
                 distinct_tools: this.distinctTools.size,
                 any_failures: this.anyFailures,
-            }, this.ensureStartDayBucket(), this.now()));
-        }
-        if (this.queue.length > 0) {
-            appendOutboxSync(this.restampPsVersion(this.queue.splice(0)).filter(isContentSafe), this.outboxOpts);
+                ...this.summaryFields(),
+            }, this.ensureStartDayBucket(), this.now());
+            if (isContentSafe(summary)) {
+                const lost = appendOutboxSync([summary], this.outboxOpts);
+                if (lost > 0) {
+                    this.logger.debug(`outbox discarded ${lost} event(s) while writing the session summary`);
+                }
+            }
         }
         clearSessionState(this.outboxOpts);
     }
@@ -193,7 +305,8 @@ export class TelemetryClient {
                 appendOutboxSync([summaryFromState(stale)], this.outboxOpts);
             }
             clearSessionState(this.outboxOpts);
-            const pending = readOutbox(this.outboxOpts);
+            const { events: pending, discarded } = readOutboxWithDiscards(this.outboxOpts);
+            this.droppedOutbox += discarded;
             if (pending.length === 0) {
                 clearOutbox(this.outboxOpts);
                 return;
@@ -202,22 +315,27 @@ export class TelemetryClient {
                 clearOutbox(this.outboxOpts);
                 return;
             }
-            let allAccepted = true;
-            for (let i = 0; i < pending.length; i += this.maxBatchSize) {
-                const batch = pending.slice(i, i + this.maxBatchSize).filter(isContentSafe);
-                if (batch.length === 0)
-                    continue;
+            const sendable = pending.filter(isContentSafe);
+            this.droppedUnsafe += pending.length - sendable.length;
+            let settled = 0;
+            for (let i = 0; i < sendable.length; i += this.maxBatchSize) {
+                const batch = sendable.slice(i, i + this.maxBatchSize);
                 try {
                     await this.transport(this.endpoint, JSON.stringify({ events: batch }));
+                    this.usageCallsSent += countUsageCalls(batch);
                 }
                 catch (err) {
                     this.logger.debug(`startup outbox flush failed: ${errMsg(err)}`);
-                    allAccepted = false;
                     break;
                 }
+                settled = i + batch.length;
             }
-            if (allAccepted)
+            if (settled >= sendable.length) {
                 clearOutbox(this.outboxOpts);
+            }
+            else {
+                rewriteOutbox(sendable.slice(settled), this.outboxOpts);
+            }
         }
         catch (err) {
             this.logger.debug(`startup outbox flush error: ${errMsg(err)}`);
@@ -228,6 +346,8 @@ export class TelemetryClient {
     }
 }
 function summaryFromState(s) {
+    const templatesSaved = s.templates_saved !== undefined ? clampCount(s.templates_saved) : null;
+    const actionSets = s.action_sets !== undefined ? clampCount(s.action_sets) : null;
     return {
         v: 2,
         type: 'session_summary',
@@ -240,8 +360,36 @@ function summaryFromState(s) {
         tool_call_count: s.tool_call_count,
         distinct_tools: s.distinct_tools,
         any_failures: s.any_failures,
+        ...(s.duration_s !== undefined ? { duration_s: s.duration_s } : {}),
+        ...(s.retry_count !== undefined ? { retry_count: s.retry_count } : {}),
+        ...(s.ended_after_failure !== undefined ? { ended_after_failure: s.ended_after_failure } : {}),
+        ...(s.edits_ok !== undefined ? { edits_ok: s.edits_ok } : {}),
+        ...(s.kept_work !== undefined ? { kept_work: s.kept_work } : {}),
+        ...(s.behind_latest !== undefined ? { behind_latest: s.behind_latest } : {}),
+        ...(s.dropped_events !== undefined ? { dropped_events: s.dropped_events } : {}),
+        ...(s.dropped_outbox !== undefined ? { dropped_outbox: s.dropped_outbox } : {}),
+        ...(s.dropped_unsafe !== undefined ? { dropped_unsafe: s.dropped_unsafe } : {}),
+        ...(s.usage_calls_sent !== undefined ? { usage_calls_sent: s.usage_calls_sent } : {}),
+        ...(s.module_update !== undefined ? { module_update: s.module_update } : {}),
+        ...(templatesSaved !== null ? { templates_saved: templatesSaved } : {}),
+        ...(actionSets !== null ? { action_sets: actionSets } : {}),
     };
 }
 function errMsg(err) {
     return err instanceof Error ? err.message : String(err);
 }
+function countUsageCalls(events) {
+    let n = 0;
+    for (const event of events) {
+        if (event.type !== 'usage')
+            continue;
+        const count = event.count;
+        n += typeof count === 'number' && Number.isInteger(count) && count > 0 ? count : 1;
+    }
+    return n;
+}
+function clampCount(n) {
+    if (!Number.isFinite(n))
+        return null;
+    return Math.min(Math.max(0, Math.trunc(n)), MAX_INSTALL_ASSET_COUNT);
+}

package/dist/telemetry/events.js

@@ -1,5 +1,8 @@
+import { mapClientName, parseMajor, boundMajor } from './activity.js';
 export const TELEMETRY_SCHEMA_VERSION = 2;
 export const PS_VERSION_UNKNOWN = 'unknown';
+export const MAX_RESULT_BYTES = 16_777_216;
+const PS_LOCALE_RE = /^[a-z]{2,3}_[A-Z]{2}$/;
 export function dayBucket(now) {
     return now.toISOString().slice(0, 10);
 }
@@ -31,6 +34,9 @@ export function buildUsageEvent(dims, call, now) {
         success: call.success,
         error_class: call.error_class === null ? null : normalizeErrorClass(call.error_class),
         duration_ms: call.duration_ms,
+        ...(call.result_bytes !== undefined
+            ? { result_bytes: Math.min(call.result_bytes, MAX_RESULT_BYTES) }
+            : {}),
     };
 }
 export function buildSessionSummary(dims, summary, tsBucket, now) {
@@ -46,9 +52,26 @@ export function buildSessionSummary(dims, summary, tsBucket, now) {
         tool_call_count: summary.tool_call_count,
         distinct_tools: summary.distinct_tools,
         any_failures: summary.any_failures,
+        ...(summary.duration_s !== undefined ? { duration_s: summary.duration_s } : {}),
+        ...(summary.retry_count !== undefined ? { retry_count: summary.retry_count } : {}),
+        ...(summary.ended_after_failure !== undefined
+            ? { ended_after_failure: summary.ended_after_failure }
+            : {}),
+        ...(summary.edits_ok !== undefined ? { edits_ok: summary.edits_ok } : {}),
+        ...(summary.kept_work !== undefined ? { kept_work: summary.kept_work } : {}),
+        ...(summary.behind_latest !== undefined ? { behind_latest: summary.behind_latest } : {}),
+        ...(summary.dropped_events !== undefined ? { dropped_events: summary.dropped_events } : {}),
+        ...(summary.dropped_outbox !== undefined ? { dropped_outbox: summary.dropped_outbox } : {}),
+        ...(summary.dropped_unsafe !== undefined ? { dropped_unsafe: summary.dropped_unsafe } : {}),
+        ...(summary.usage_calls_sent !== undefined
+            ? { usage_calls_sent: summary.usage_calls_sent }
+            : {}),
+        ...(summary.module_update !== undefined ? { module_update: summary.module_update } : {}),
+        ...(summary.templates_saved !== undefined ? { templates_saved: summary.templates_saved } : {}),
+        ...(summary.action_sets !== undefined ? { action_sets: summary.action_sets } : {}),
     };
 }
-export function buildSessionStart(dims, now) {
+export function buildSessionStart(dims, now, facts = {}) {
     return {
         v: TELEMETRY_SCHEMA_VERSION,
         type: 'session_start',
@@ -59,6 +82,25 @@ export function buildSessionStart(dims, now) {
         platform: dims.platform,
         ps_version: psVersionOf(dims),
         channel: dims.channel,
+        ...(facts.node_major !== undefined ? { node_major: facts.node_major } : {}),
+        ...(facts.arch !== undefined ? { arch: facts.arch } : {}),
+        ...(facts.os_major !== undefined ? { os_major: facts.os_major } : {}),
+    };
+}
+export function buildClientConnected(dims, info, now) {
+    return {
+        v: TELEMETRY_SCHEMA_VERSION,
+        type: 'client_connected',
+        install_id: dims.install_id,
+        ts_bucket: dayBucket(now),
+        editmamei_version: dims.editmamei_version,
+        edition: dims.edition,
+        platform: dims.platform,
+        client: mapClientName(info.clientName),
+        client_major: boundMajor(parseMajor(info.clientVersion), 9999),
+        cap_sampling: info.capSampling,
+        cap_elicitation: info.capElicitation,
+        cap_roots: info.capRoots,
     };
 }
 export function buildModuleStatus(dims, status, now) {
@@ -90,6 +132,11 @@ export function buildDiagnosticEvent(dims, diag, now) {
         error_message: diag.error_message,
         ...(diag.snippet ? { snippet: diag.snippet } : {}),
         ...(diag.stderr_tail ? { stderr_tail: diag.stderr_tail } : {}),
+        ...(diag.doc_depth !== undefined ? { doc_depth: diag.doc_depth } : {}),
+        ...(diag.doc_mode !== undefined ? { doc_mode: diag.doc_mode } : {}),
+        ...(diag.ps_locale !== undefined && PS_LOCALE_RE.test(diag.ps_locale)
+            ? { ps_locale: diag.ps_locale }
+            : {}),
     };
 }
 export function looksLikeAbsolutePath(value) {

package/dist/telemetry/outbox.js

@@ -6,8 +6,8 @@ const logger = new Logger('TelemetryOutbox');
 const DIRNAME = '.editmamei';
 const OUTBOX_FILENAME = 'telemetry-outbox.ndjson';
 const SESSION_STATE_FILENAME = 'telemetry-session.json';
-export const MAX_OUTBOX_EVENTS = 1000;
-const MAX_OUTBOX_BYTES = 2_000_000;
+export const MAX_OUTBOX_EVENTS = 5_000;
+export const MAX_OUTBOX_BYTES = 2_000_000;
 function baseDir(opts) {
     return opts.dir ?? join(homedir(), DIRNAME);
 }
@@ -22,27 +22,31 @@ function ensureDir(path) {
 }
 export function appendOutboxSync(events, opts = {}) {
     if (events.length === 0)
-        return;
+        return 0;
     const path = outboxPath(opts);
+    let discarded = 0;
     try {
         ensureDir(path);
         if (existsSync(path) && statSync(path).size > MAX_OUTBOX_BYTES) {
-            compactOutbox(opts);
+            discarded += compactOutbox(opts);
         }
         const lines = events.map((e) => JSON.stringify(e)).join('\n') + '\n';
         appendFileSync(path, lines, { encoding: 'utf8', mode: 0o600 });
     }
     catch (err) {
         logger.debug(`outbox append dropped ${events.length} event(s): ${errMsg(err)}`);
+        discarded += events.length;
     }
+    return discarded;
 }
-export function readOutbox(opts = {}) {
+export function readOutboxWithDiscards(opts = {}) {
     const path = outboxPath(opts);
     if (!existsSync(path))
-        return [];
+        return { events: [], discarded: 0 };
     try {
         const raw = readFileSync(path, 'utf8');
         const events = [];
+        let discarded = 0;
         for (const line of raw.split('\n')) {
             const trimmed = line.trim();
             if (trimmed.length === 0)
@@ -51,17 +55,23 @@ export function readOutbox(opts = {}) {
                 events.push(JSON.parse(trimmed));
             }
             catch {
+                discarded += 1;
             }
         }
-        return events.length > MAX_OUTBOX_EVENTS
-            ? events.slice(events.length - MAX_OUTBOX_EVENTS)
-            : events;
+        if (events.length > MAX_OUTBOX_EVENTS) {
+            const over = events.length - MAX_OUTBOX_EVENTS;
+            return { events: events.slice(over), discarded: discarded + over };
+        }
+        return { events, discarded };
     }
     catch (err) {
         logger.debug(`outbox read failed: ${errMsg(err)}`);
-        return [];
+        return { events: [], discarded: 0 };
     }
 }
+export function readOutbox(opts = {}) {
+    return readOutboxWithDiscards(opts).events;
+}
 export function clearOutbox(opts = {}) {
     try {
         rmSync(outboxPath(opts), { force: true });
@@ -70,24 +80,39 @@ export function clearOutbox(opts = {}) {
         logger.debug(`outbox clear failed: ${errMsg(err)}`);
     }
 }
-function compactOutbox(opts = {}) {
-    const kept = readOutbox(opts);
+export function rewriteOutbox(events, opts = {}) {
+    if (events.length === 0) {
+        clearOutbox(opts);
+        return;
+    }
     const path = outboxPath(opts);
     try {
-        if (kept.length === 0) {
-            clearOutbox(opts);
-            return;
-        }
+        ensureDir(path);
         const tmp = join(dirname(path), `.outbox.${process.pid}.tmp`);
-        writeFileSync(tmp, kept.map((e) => JSON.stringify(e)).join('\n') + '\n', {
+        writeFileSync(tmp, events.map((e) => JSON.stringify(e)).join('\n') + '\n', {
             encoding: 'utf8',
             mode: 0o600,
         });
         renameSync(tmp, path);
     }
     catch (err) {
-        logger.debug(`outbox compaction failed: ${errMsg(err)}`);
+        logger.debug(`outbox rewrite failed: ${errMsg(err)}`);
+    }
+}
+function compactOutbox(opts = {}) {
+    const { events, discarded } = readOutboxWithDiscards(opts);
+    const target = MAX_OUTBOX_BYTES / 2;
+    let bytes = 0;
+    let firstKept = Math.max(events.length - 1, 0);
+    for (let i = events.length - 1; i >= 0; i--) {
+        bytes += Buffer.byteLength(JSON.stringify(events[i]), 'utf8') + 1;
+        if (bytes > target)
+            break;
+        firstKept = i;
     }
+    const kept = events.slice(firstKept);
+    rewriteOutbox(kept, opts);
+    return discarded + (events.length - kept.length);
 }
 export function writeSessionStateSync(state, opts = {}) {
     const path = sessionStatePath(opts);