editmamei 1.5.0 → 1.6.0

package/dist/telemetry/client.js

@@ -7,7 +7,7 @@ import { READ_ONLY_TOOLS, KEPT_WORK_TOOLS, nodeMajor, archToken, osMajor, boundM
 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;
@@ -43,6 +43,9 @@ export class TelemetryClient {
     editsOk = 0;
     keptWork = 0;
     droppedEvents = 0;
+    droppedOutbox = 0;
+    droppedUnsafe = 0;
+    usageCallsSent = 0;
     behindLatest = null;
     moduleUpdate = 'none';
     installAssets = {};
@@ -156,6 +159,9 @@ export class TelemetryClient {
             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 }
@@ -241,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() {
@@ -264,16 +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.summaryFields(),
-            }, this.ensureStartDayBucket(), this.now()));
-        }
-        if (this.queue.length > 0) {
-            appendOutboxSync(this.restampPsVersion(this.queue.splice(0)).filter(isContentSafe), this.outboxOpts);
+            }, 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);
     }
@@ -286,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;
@@ -295,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)}`);
@@ -342,6 +367,9 @@ function summaryFromState(s) {
         ...(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 } : {}),
@@ -350,6 +378,16 @@ function summaryFromState(s) {
 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;

package/dist/telemetry/events.js

@@ -61,6 +61,11 @@ export function buildSessionSummary(dims, summary, tsBucket, now) {
         ...(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 } : {}),

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);

package/dist/tools/adjustment-tools.js

@@ -2,6 +2,7 @@ import { runScript } from '../utils/run-script.js';
 import { validateArgs } from '../utils/validate.js';
 import { toolErrorResult, runSnippetTool, applyToActiveLayerProp } from '../utils/tool-helpers.js';
 import { getPendingRawDevelop } from '../core/raw-develop-state.js';
+import { CAMERA_RAW_TOOL } from '../core/tool-activity.js';
 const addAdjustmentLayerSchema = {
     type: 'object',
     properties: {
@@ -844,7 +845,7 @@ async function addAdjustmentLayer(connection, snippetClient, rawArgs) {
         if (pendingRaw) {
             const source = pendingRaw.documentName || pendingRaw.filePath || 'a raw source';
             const note = `This document was opened from raw source ${source} with no Camera Raw develop pass yet — ` +
-                'consider ps_apply_camera_raw first for global tone/color. Nothing failed; ignore if the ' +
+                `consider ${CAMERA_RAW_TOOL} first for global tone/color. Nothing failed; ignore if the ` +
                 'user prescribed this exact layer or the file was already developed elsewhere.';
             if (typeof result === 'object' && result !== null) {
                 structured.raw_develop_pending = note;