pinglet-cli 0.6.0 → 0.6.1

package/dist/api.js

@@ -38,6 +38,7 @@ exports.checkHealth = checkHealth;
 exports.registerInstallation = registerInstallation;
 exports.fetchFeed = fetchFeed;
 exports.uploadEventBatch = uploadEventBatch;
+exports.uploadEventBatchResult = uploadEventBatchResult;
 exports.sendHeartbeat = sendHeartbeat;
 exports.createMessage = createMessage;
 exports.validateUserToken = validateUserToken;
@@ -110,20 +111,30 @@ async function fetchFeed(config, record, limit = 50) {
 }
 /** POST /events/batch — eventId 기반으로 서버가 dedupe하므로 재전송에 안전하다. */
 async function uploadEventBatch(config, record, events) {
-    const res = await request(config, "POST", "/events/batch", {
-        token: record.token,
-        body: {
-            batchId: "batch_" + (0, crypto_1.randomUUID)(),
-            events: events.map(({ eventId, type, messageId, visibleMs, occurredAt }) => ({
-                eventId,
-                type,
-                messageId,
-                ...(visibleMs !== undefined && { visibleMs }),
-                occurredAt,
-            })),
-        },
-    });
-    return res !== null;
+    return (await uploadEventBatchResult(config, record, events)).ok;
+}
+async function uploadEventBatchResult(config, record, events) {
+    try {
+        const res = await fetch(config.apiBaseUrl + "/events/batch", {
+            method: "POST",
+            headers: { "content-type": "application/json", authorization: `Bearer ${record.token}` },
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+            body: JSON.stringify({
+                batchId: "batch_" + (0, crypto_1.randomUUID)(),
+                events: events.map(({ eventId, type, messageId, visibleMs, occurredAt }) => ({
+                    eventId,
+                    type,
+                    messageId,
+                    ...(visibleMs !== undefined && { visibleMs }),
+                    occurredAt,
+                })),
+            }),
+        });
+        return { ok: res.ok, permanent: [400, 413, 422].includes(res.status), status: res.status };
+    }
+    catch {
+        return { ok: false, permanent: false };
+    }
 }
 /** POST /installations/heartbeat — lastSeenAt 갱신. 응답의 온라인 설치 수를 돌려준다(구서버는 null). */
 async function sendHeartbeat(config, record) {

package/dist/cache.js

@@ -43,12 +43,17 @@ function feedAgeMs() {
     return Number.isNaN(t) ? null : Date.now() - t;
 }
 function loadState() {
-    const state = (0, config_1.readJsonFile)(config_1.STATE_PATH);
-    if (state) {
-        state.seen ??= {};
-        return state;
+    const state = (0, config_1.readJsonFile)(config_1.STATE_PATH) ?? { seen: {} };
+    const installationId = (0, config_1.readJsonFile)(config_1.CONFIG_PATH)?.installations?.CLAUDE?.installationId;
+    if (state.claudeInstallationId && state.claudeInstallationId !== installationId) {
+        state.seen = {};
+        state.delivered = {};
+        state.current = undefined;
+        state.sessions = undefined;
     }
-    return { seen: {} };
+    state.claudeInstallationId = installationId;
+    state.seen ??= {};
+    return state;
 }
 function loadMyPosts() {
     return (0, config_1.readJsonFile)(config_1.POSTS_PATH) ?? [];

package/dist/cli.js

@@ -8,13 +8,14 @@ const doctor_1 = require("./commands/doctor");
 const login_1 = require("./commands/login");
 const logout_1 = require("./commands/logout");
 const statusline_1 = require("./commands/statusline");
-const notify_1 = require("./commands/notify");
 const flush_1 = require("./commands/flush");
 const refresh_1 = require("./commands/refresh");
 const ping_1 = require("./commands/ping");
 const post_1 = require("./commands/post");
 const i18n_1 = require("./i18n");
 const lock_1 = require("./lock");
+const notifications_1 = require("./notifications");
+const runtime_1 = require("./runtime");
 const HELP = (0, i18n_1.t)("cli.help", { version: config_1.VERSION });
 async function main() {
     const [command, ...rest] = process.argv.slice(2);
@@ -43,9 +44,6 @@ async function main() {
         case "statusline":
             (0, statusline_1.runStatusline)();
             break;
-        case "notify":
-            (0, notify_1.runNotify)(rest);
-            break;
         case "flush":
             await (0, flush_1.runFlush)();
             break;
@@ -73,12 +71,32 @@ async function main() {
             }
     }
 }
-(0, lock_1.withPingletLock)(main, {
-    skipIfBusy: ["statusline", "notify", "refresh", "flush"].includes(process.argv[2]),
-}).catch((error) => {
+async function dispatch() {
+    const command = process.argv[2];
+    if (command === "notify") {
+        if ((0, notifications_1.enqueueNotification)(process.argv.slice(3)))
+            (0, runtime_1.spawnDetachedCommand)(["notify-drain"]);
+        return;
+    }
+    if (command === "notify-drain" || command === "statusline") {
+        await (0, lock_1.withPingletLock)(() => {
+            (0, notifications_1.drainNotifications)();
+            if (command === "statusline")
+                (0, statusline_1.runStatusline)();
+        }, { skipIfBusy: command === "statusline" });
+        return;
+    }
+    if (["--version", "-v", "help", "--help"].includes(command)) {
+        await main();
+        return;
+    }
+    await (0, lock_1.withCommandLock)(main);
+    await (0, lock_1.withPingletLock)(notifications_1.drainNotifications);
+}
+dispatch().catch((error) => {
     // statusline/notify는 조용히 실패해야 Claude/Codex 경험을 해치지 않는다.
     const command = process.argv[2];
-    if (command === "statusline" || command === "notify") {
+    if (command === "statusline" || command === "notify" || command === "notify-drain") {
         process.exit(0);
     }
     console.error("pinglet:", error instanceof Error ? error.message : error);

package/dist/commands/flush.js

@@ -38,18 +38,49 @@ const config_1 = require("../config");
 const fs = __importStar(require("fs"));
 const api_1 = require("../api");
 const queue_1 = require("../queue");
+const lock_1 = require("../lock");
 /**
  * Local Event Queue를 batch로 서버에 전송한다 (아키텍처 §8).
  * 전송 성공한 이벤트만 큐에서 제거하므로 실패분은 다음 주기에 재시도되고,
  * 재전송 중복은 서버가 eventId로 dedupe한다.
  */
 async function runFlush() {
-    if (!fs.existsSync(config_1.CONFIG_PATH))
-        return;
-    const config = (0, config_1.loadConfig)();
-    const events = (0, queue_1.readEvents)();
-    if (events.length === 0)
+    const snapshot = await (0, lock_1.withPingletLock)(() => {
+        if (!fs.existsSync(config_1.CONFIG_PATH))
+            return;
+        const config = (0, config_1.loadConfig)();
+        const events = (0, queue_1.bindEvents)();
+        const valid = [];
+        for (const event of events) {
+            const reason = (0, queue_1.invalidEventReason)(event);
+            const record = config.installations[event.agentType];
+            if (reason)
+                (0, queue_1.quarantineEvents)([event], reason);
+            else if (event.installationId && event.installationId !== record?.installationId)
+                (0, queue_1.quarantineEvents)([event], "retired-installation");
+            else
+                valid.push(event);
+        }
+        return { config, events: valid };
+    });
+    if (!snapshot)
         return;
+    const { config, events } = snapshot;
+    const send = async (record, chunk) => {
+        const result = await (0, api_1.uploadEventBatchResult)(config, record, chunk);
+        if (result.ok) {
+            await (0, lock_1.withPingletLock)(() => (0, queue_1.removeEvents)(new Set(chunk.map(event => event.eventId))));
+            return true;
+        }
+        if (!result.permanent)
+            return false;
+        if (chunk.length === 1) {
+            await (0, lock_1.withPingletLock)(() => (0, queue_1.quarantineEvents)(chunk, `http-${result.status}`));
+            return true;
+        }
+        const middle = Math.floor(chunk.length / 2);
+        return await send(record, chunk.slice(0, middle)) && await send(record, chunk.slice(middle));
+    };
     for (const agentType of ["CLAUDE", "CODEX"]) {
         const record = config.installations[agentType];
         const group = events.filter((e) => e.agentType === agentType);
@@ -59,10 +90,8 @@ async function runFlush() {
             continue; // 미등록 상태 — refresh가 등록을 재시도한다.
         for (let i = 0; i < group.length; i += api_1.MAX_BATCH_SIZE) {
             const chunk = group.slice(i, i + api_1.MAX_BATCH_SIZE);
-            const ok = await (0, api_1.uploadEventBatch)(config, record, chunk);
-            if (!ok)
+            if (!await send(record, chunk))
                 break;
-            (0, queue_1.removeEvents)(new Set(chunk.map((e) => e.eventId)));
         }
     }
 }

package/dist/commands/install.js

@@ -41,6 +41,7 @@ const cache_1 = require("../cache");
 const claude_1 = require("../adapters/claude");
 const codex_1 = require("../adapters/codex");
 const i18n_1 = require("../i18n");
+const lock_1 = require("../lock");
 /**
  * 기존 설정 교체 확인. Enter 또는 y면 진행(기본 Yes — 설치 의도가 명확하므로).
  * non-TTY(postinstall, CI)에서는 묻지 않고 false — 사용자 설정을 말없이
@@ -72,7 +73,11 @@ async function runInstall(args) {
     const apiIndex = args.indexOf("--api");
     if (apiIndex !== -1 && args[apiIndex + 1]) {
         config.apiBaseUrl = args[apiIndex + 1].replace(/\/$/, "");
-        (0, config_1.saveConfig)(config);
+        await (0, lock_1.withPingletLock)(() => {
+            const current = (0, config_1.loadConfig)();
+            current.apiBaseUrl = config.apiBaseUrl;
+            (0, config_1.saveConfig)(current);
+        });
     }
     console.log("");
     const hasClaude = wantClaude && (0, claude_1.detectClaude)();
@@ -99,17 +104,21 @@ async function runInstall(args) {
             return;
         const record = await (0, api_1.registerInstallation)(config, agentType);
         if (record) {
+            await (0, lock_1.withPingletLock)(() => {
+                const current = (0, config_1.loadConfig)();
+                current.installations[agentType] = record;
+                (0, config_1.saveConfig)(current);
+            });
             config.installations[agentType] = record;
-            (0, config_1.saveConfig)(config);
         }
     };
     if (hasClaude) {
         await register("CLAUDE");
-        let result = (0, claude_1.installClaudeIntegration)(config, { force });
+        let result = (await (0, lock_1.withPingletLock)(() => (0, claude_1.installClaudeIntegration)((0, config_1.loadConfig)(), { force })));
         if (!result.ok && result.needsForce) {
             const yes = await confirmReplace((0, i18n_1.t)("install.askReplaceStatusLine"));
             if (yes)
-                result = (0, claude_1.installClaudeIntegration)(config, { force: true });
+                result = (await (0, lock_1.withPingletLock)(() => (0, claude_1.installClaudeIntegration)((0, config_1.loadConfig)(), { force: true })));
         }
         console.log(result.ok
             ? "✓ Claude integration installed"
@@ -117,11 +126,11 @@ async function runInstall(args) {
     }
     if (hasCodex) {
         await register("CODEX");
-        let result = (0, codex_1.installCodexIntegration)(config, { force });
+        let result = (await (0, lock_1.withPingletLock)(() => (0, codex_1.installCodexIntegration)((0, config_1.loadConfig)(), { force })));
         if (!result.ok && result.needsForce) {
             const yes = await confirmReplace((0, i18n_1.t)("install.askReplaceNotify"));
             if (yes)
-                result = (0, codex_1.installCodexIntegration)(config, { force: true });
+                result = (await (0, lock_1.withPingletLock)(() => (0, codex_1.installCodexIntegration)((0, config_1.loadConfig)(), { force: true })));
         }
         console.log(result.ok
             ? "✓ Codex integration installed (experimental)"
@@ -132,10 +141,10 @@ async function runInstall(args) {
     if (online && record) {
         const messages = await (0, api_1.fetchFeed)(config, record);
         if (messages) {
-            (0, cache_1.saveFeedMessages)(messages);
+            await (0, lock_1.withPingletLock)(() => (0, cache_1.saveFeedMessages)(messages));
             if (messages.length > 0) {
                 console.log(`✓ Feed cached (${messages.length} messages)`);
-                if ((0, claude_1.armSpinnerMessage)(config, messages[0] ?? null)) {
+                if (await (0, lock_1.withPingletLock)(() => (0, claude_1.armSpinnerMessage)((0, config_1.loadConfig)(), messages[0] ?? null))) {
                     console.log("✓ Claude spinner synced");
                 }
             }

package/dist/commands/login.js

@@ -40,6 +40,7 @@ const readline = __importStar(require("readline"));
 const config_1 = require("../config");
 const api_1 = require("../api");
 const i18n_1 = require("../i18n");
+const lock_1 = require("../lock");
 const LOGIN_TIMEOUT_MS = 180_000;
 function prompt(question) {
     const rl = readline.createInterface({
@@ -188,8 +189,13 @@ async function runLogin(args) {
             throw new Error((0, i18n_1.t)("logout.failed"));
         }
     }
+    await (0, lock_1.withPingletLock)(() => {
+        // Hooks may have added adapter restoration metadata while OAuth was open.
+        const current = (0, config_1.loadConfig)();
+        current.userToken = token;
+        (0, config_1.saveConfig)(current);
+    });
     config.userToken = token;
-    (0, config_1.saveConfig)(config);
     console.log((0, i18n_1.t)("login.saved"));
     for (const [agentType, record] of Object.entries(config.installations)) {
         const linked = await (0, api_1.linkInstallation)(config, record.token);

package/dist/commands/logout.js

@@ -4,6 +4,7 @@ exports.runLogout = runLogout;
 const config_1 = require("../config");
 const i18n_1 = require("../i18n");
 const api_1 = require("../api");
+const lock_1 = require("../lock");
 /**
  * Revoke the user session and unlink this device's installations before
  * removing local credentials. On failure preserve credentials for retry.
@@ -22,7 +23,10 @@ async function runLogout() {
     if (!await (0, api_1.releaseCredential)(config, "user", config.userToken)) {
         throw new Error((0, i18n_1.t)("logout.failed"));
     }
-    delete config.userToken;
-    (0, config_1.saveConfig)(config);
+    await (0, lock_1.withPingletLock)(() => {
+        const current = (0, config_1.loadConfig)();
+        delete current.userToken;
+        (0, config_1.saveConfig)(current);
+    });
     console.log((0, i18n_1.t)("logout.done"));
 }

package/dist/commands/notify.js

@@ -46,7 +46,7 @@ const config_1 = require("../config");
  * Codex는 turn 완료 시 마지막 인자로 notification JSON을 넘긴다.
  * notify 프로세스는 TUI 밖에서 돌기 때문에 MVP에서는 macOS 알림으로 Ping을 전달한다.
  */
-function runNotify(args) {
+function runNotify(args, eventId) {
     if (!fs.existsSync(config_1.CONFIG_PATH) || !(0, config_1.loadConfig)().adapters.codex)
         return;
     let notificationType;
@@ -68,7 +68,7 @@ function runNotify(args) {
         (0, cache_1.saveState)(state);
         return;
     }
-    (0, queue_1.appendEvent)({ agentType: "CODEX", type: "DELIVERED", messageId: message.id });
+    (0, queue_1.appendEvent)({ eventId, agentType: "CODEX", type: "DELIVERED", messageId: message.id });
     state.seen[message.id] = (state.seen[message.id] ?? 0) + 1;
     (0, runtime_1.runMaintenance)(state, now);
     (0, cache_1.saveState)(state);

package/dist/commands/post.js

@@ -43,7 +43,9 @@ async function runPost(args) {
     const config = (0, config_1.loadConfig)();
     const requestId = (0, pending_post_1.pendingPostId)(config, text, category);
     const result = await (0, api_1.createMessage)(config, text, category, requestId);
-    if (result.ok || (result.error !== "NETWORK" && result.error !== "SERVER"))
+    // Only a definitive response resolves an earlier ambiguous commit. In
+    // particular 401/429 say nothing about whether the previous request committed.
+    if (result.ok)
         (0, pending_post_1.completePost)(requestId);
     // 슬래시 명령 안에서는 같은 방식의 슬래시 명령을 안내한다.
     const loginCmd = quiet ? "/pinglet-login" : "pinglet login";

package/dist/commands/refresh.js

@@ -40,6 +40,7 @@ const api_1 = require("../api");
 const update_1 = require("../update");
 const cache_1 = require("../cache");
 const claude_1 = require("../adapters/claude");
+const lock_1 = require("../lock");
 /**
  * 서버 feed를 미리 받아 Local Feed Cache를 갱신한다 (아키텍처 §6).
  * 설치 당시 오프라인이었다면 installation 등록도 여기서 재시도한다.
@@ -57,8 +58,12 @@ async function runRefresh() {
         if (!config.installations[agentType]) {
             const record = await (0, api_1.registerInstallation)(config, agentType);
             if (record) {
+                await (0, lock_1.withPingletLock)(() => {
+                    const current = (0, config_1.loadConfig)();
+                    current.installations[agentType] = record;
+                    (0, config_1.saveConfig)(current);
+                });
                 config.installations[agentType] = record;
-                (0, config_1.saveConfig)(config);
             }
         }
     }
@@ -68,20 +73,22 @@ async function runRefresh() {
     const onlineCounts = await Promise.all(records.map((r) => (0, api_1.sendHeartbeat)(config, r)));
     const online = onlineCounts.find((n) => n !== null);
     if (online !== undefined) {
-        (0, cache_1.saveOnline)(online);
+        await (0, lock_1.withPingletLock)(() => (0, cache_1.saveOnline)(online));
     }
     const messages = await (0, api_1.fetchFeed)(config, records[0]);
     if (messages) {
-        (0, cache_1.saveFeedMessages)(messages);
-        // spinner 회전과 DELIVERED/QUALIFIED 기록은 statusline이 담당한다 (pool=1).
-        // 여기서는 armed된 메시지가 서버에서 사라진 경우만 즉시 정리한다.
-        const state = (0, cache_1.loadState)();
-        const current = state.current;
-        if (current && !messages.some((m) => m.id === current.messageId)) {
-            (0, claude_1.armSpinnerMessage)(config, messages[0] ?? null);
-            state.current = undefined; // 다음 statusline tick이 정식으로 다음 메시지를 armed한다
-            (0, cache_1.saveState)(state);
-        }
+        await (0, lock_1.withPingletLock)(() => {
+            (0, cache_1.saveFeedMessages)(messages);
+            // spinner 회전과 DELIVERED/QUALIFIED 기록은 statusline이 담당한다 (pool=1).
+            // 여기서는 armed된 메시지가 서버에서 사라진 경우만 즉시 정리한다.
+            const state = (0, cache_1.loadState)();
+            const current = state.current;
+            if (current && !messages.some((m) => m.id === current.messageId)) {
+                (0, claude_1.armSpinnerMessage)((0, config_1.loadConfig)(), messages[0] ?? null);
+                state.current = undefined; // 다음 statusline tick이 정식으로 다음 메시지를 armed한다
+                (0, cache_1.saveState)(state);
+            }
+        });
     }
     // 하루 1회 새 버전 확인 후 npm 전역 설치면 백그라운드 자동 업데이트.
     await (0, update_1.maybeSelfUpdate)(config);

package/dist/commands/statusline.js

@@ -101,6 +101,7 @@ function rotateSpinner(state, now) {
             messageId: prev.messageId,
             visibleMs: prev.visibleMs,
         });
+        prev.visibleMs = 0; // A failed replacement must not account this interval twice.
     }
     const message = (0, picker_1.pickMessage)((0, cache_1.loadFeedMessages)(), state);
     if (!message) {
@@ -108,7 +109,12 @@ function rotateSpinner(state, now) {
         state.current = undefined;
         return;
     }
-    (0, claude_1.armSpinnerMessage)(config, message);
+    if (!(0, claude_1.armSpinnerMessage)(config, message)) {
+        // No delivery/current transition until the settings write actually commits.
+        // Clear attribution of subsequent API time and retry on the next tick.
+        state.current = undefined;
+        return;
+    }
     state.seen[message.id] = (state.seen[message.id] ?? 0) + 1;
     state.delivered ??= {};
     if (!state.delivered[message.id]) {

package/dist/commands/uninstall.js

@@ -40,32 +40,58 @@ const claude_1 = require("../adapters/claude");
 const codex_1 = require("../adapters/codex");
 const i18n_1 = require("../i18n");
 const api_1 = require("../api");
+const lock_1 = require("../lock");
+const queue_1 = require("../queue");
+const cache_1 = require("../cache");
+const flush_1 = require("./flush");
 async function runUninstall(args) {
-    const config = (0, config_1.loadConfig)();
-    const claudeRemoved = (0, claude_1.uninstallClaudeIntegration)(config);
-    const codexRemoved = (0, codex_1.uninstallCodexIntegration)(config);
+    const restored = await (0, lock_1.withPingletLock)(() => {
+        const config = (0, config_1.loadConfig)();
+        (0, queue_1.bindEvents)();
+        const claudeRemoved = (0, claude_1.uninstallClaudeIntegration)(config);
+        const codexRemoved = (0, codex_1.uninstallCodexIntegration)(config);
+        (0, cache_1.saveState)({ seen: {} });
+        return { config, claudeRemoved, codexRemoved };
+    });
+    if (!restored)
+        return;
+    const { config, claudeRemoved, codexRemoved } = restored;
     console.log(claudeRemoved
         ? "✓ Claude integration removed"
         : "○ Claude integration not installed");
     console.log(codexRemoved
         ? "✓ Codex integration removed"
         : "○ Codex integration not installed");
+    await (0, flush_1.runFlush)();
     for (const [agent, record] of Object.entries(config.installations)) {
         if (!await (0, api_1.releaseCredential)(config, "installation", record.token)) {
             throw new Error((0, i18n_1.t)("uninstall.failed"));
         }
-        delete config.installations[agent];
-        (0, config_1.saveConfig)(config);
+        await (0, lock_1.withPingletLock)(() => {
+            const pending = (0, queue_1.readEvents)().filter(event => event.agentType === agent);
+            (0, queue_1.quarantineEvents)(pending, "uninstalled-before-upload");
+            if (pending.length && !args.includes("--purge"))
+                console.log(`○ ${pending.length} unsent events archived in events-quarantine.jsonl (not reassigned on reinstall)`);
+            delete config.installations[agent];
+            (0, config_1.saveConfig)(config);
+        });
     }
+    // Also retire offline events produced before registration ever succeeded.
+    await (0, lock_1.withPingletLock)(() => {
+        const pending = (0, queue_1.readEvents)();
+        (0, queue_1.quarantineEvents)(pending, "uninstalled-without-registration");
+        if (pending.length && !args.includes("--purge"))
+            console.log(`○ ${pending.length} unregistered events archived in events-quarantine.jsonl`);
+    });
     if (config.userToken) {
         if (!await (0, api_1.releaseCredential)(config, "user", config.userToken)) {
             throw new Error((0, i18n_1.t)("uninstall.failed"));
         }
         delete config.userToken;
-        (0, config_1.saveConfig)(config);
+        await (0, lock_1.withPingletLock)(() => (0, config_1.saveConfig)(config));
     }
     if (args.includes("--purge")) {
-        fs.rmSync(config_1.PINGLET_DIR, { recursive: true, force: true });
+        await (0, lock_1.withPingletLock)(() => fs.rmSync(config_1.PINGLET_DIR, { recursive: true, force: true }));
         console.log("✓ ~/.pinglet removed (config / cache / event queue)");
     }
     else {

package/dist/lock.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withPingletLock = withPingletLock;
+exports.withCommandLock = withCommandLock;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
@@ -41,10 +42,9 @@ const crypto_1 = require("crypto");
 const storage_1 = require("./storage");
 // Outside ~/.pinglet so purge cannot remove a lock held by another command.
 const LOCK_PATH = path.join(os.homedir(), ".pinglet.lock");
-const RECOVERY_PATH = LOCK_PATH + ".recovery";
-function owner() {
+function owner(lockPath) {
     try {
-        return fs.readFileSync(LOCK_PATH, "utf8");
+        return fs.readFileSync(lockPath, "utf8");
     }
     catch (error) {
         if ((0, storage_1.isMissing)(error))
@@ -52,11 +52,11 @@ function owner() {
         throw error;
     }
 }
-function abandoned(value) {
-    const pid = Number(value.split(":")[0]);
+function abandoned(value, lockPath) {
+    const pid = Number(value.split(/[:-]/)[0]);
     if (!Number.isInteger(pid) || pid <= 0) {
         // The creating process may not have written its PID yet.
-        return Date.now() - fs.statSync(LOCK_PATH).mtimeMs > 30_000;
+        return Date.now() - fs.statSync(lockPath).mtimeMs > 30_000;
     }
     try {
         process.kill(pid, 0);
@@ -66,46 +66,74 @@ function abandoned(value) {
         return error.code === "ESRCH";
     }
 }
-function recover() {
+function recover(lockPath) {
+    const recoveryPath = lockPath + ".recovery";
+    const identity = `${process.pid}-${(0, crypto_1.randomUUID)()}`;
     // Serialize reapers and re-read ownership: a second reaper must never unlink
     // a fresh lock acquired after the first reaper removed the abandoned one.
     try {
-        fs.mkdirSync(RECOVERY_PATH, { mode: 0o700 });
+        fs.mkdirSync(recoveryPath, { mode: 0o700 });
     }
     catch (error) {
-        if (error.code === "EEXIST")
+        if (error.code === "EEXIST") {
+            // A killed reaper must not block recovery forever. Unique owner filenames
+            // ensure only the process that removed the old owner may remove its dir.
+            try {
+                const entries = fs.readdirSync(recoveryPath);
+                if (entries.length === 1 && abandoned(entries[0], recoveryPath)) {
+                    fs.unlinkSync(path.join(recoveryPath, entries[0]));
+                    fs.rmdirSync(recoveryPath);
+                }
+                else if (entries.length === 0 && Date.now() - fs.statSync(recoveryPath).mtimeMs > 30_000) {
+                    // Legacy/partially-created recovery directory; allow initialization grace.
+                    fs.rmdirSync(recoveryPath);
+                }
+            }
+            catch (cleanupError) {
+                if (!(0, storage_1.isMissing)(cleanupError) && !["ENOTEMPTY", "EEXIST"].includes(cleanupError.code ?? ""))
+                    throw cleanupError;
+            }
             return;
+        }
         throw error;
     }
+    const ownerPath = path.join(recoveryPath, identity);
     try {
-        const value = owner();
-        if (value !== null && abandoned(value))
-            fs.unlinkSync(LOCK_PATH);
+        fs.writeFileSync(ownerPath, "", { flag: "wx", mode: 0o600 });
+        const value = owner(lockPath);
+        if (value !== null && abandoned(value, lockPath))
+            fs.unlinkSync(lockPath);
     }
     catch (error) {
         if (!(0, storage_1.isMissing)(error))
             throw error;
     }
     finally {
-        fs.rmdirSync(RECOVERY_PATH);
+        try {
+            fs.unlinkSync(ownerPath);
+            fs.rmdirSync(recoveryPath);
+        }
+        catch (error) {
+            if (!(0, storage_1.isMissing)(error))
+                throw error;
+        }
     }
 }
-/** Serialize the entire read/modify/write command, including asynchronous work.
- * Hooks skip a busy tick instead of blocking Claude/Codex rendering.
- */
+/** Short local read/modify/write transactions. Never hold this across network I/O. */
 async function withPingletLock(action, options = {}) {
+    const lockPath = options.command ? LOCK_PATH + ".command" : LOCK_PATH;
     const identity = `${process.pid}:${(0, crypto_1.randomUUID)()}`;
     const deadline = Date.now() + (options.timeoutMs ?? 15_000);
     for (;;) {
         let fd;
         try {
-            fd = fs.openSync(LOCK_PATH, "wx", 0o600);
+            fd = fs.openSync(lockPath, "wx", 0o600);
         }
         catch (error) {
             if (error.code !== "EEXIST")
                 throw error;
-            recover();
-            if (owner() === null)
+            recover(lockPath);
+            if (owner(lockPath) === null)
                 continue;
             if (options.skipIfBusy)
                 return undefined;
@@ -118,7 +146,7 @@ async function withPingletLock(action, options = {}) {
             fs.writeFileSync(fd, identity);
         }
         catch (error) {
-            fs.unlinkSync(LOCK_PATH);
+            fs.unlinkSync(lockPath);
             throw error;
         }
         finally {
@@ -130,7 +158,11 @@ async function withPingletLock(action, options = {}) {
         return await action();
     }
     finally {
-        if (owner() === identity)
-            fs.unlinkSync(LOCK_PATH);
+        if (owner(lockPath) === identity)
+            fs.unlinkSync(lockPath);
     }
 }
+/** Serializes administrative/network commands without excluding local hooks. */
+function withCommandLock(action) {
+    return withPingletLock(action, { command: true });
+}

package/dist/notifications.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enqueueNotification = enqueueNotification;
+exports.drainNotifications = drainNotifications;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const config_1 = require("./config");
+const notify_1 = require("./commands/notify");
+const storage_1 = require("./storage");
+const PREFIX = "notify-";
+/** Unique files allow enqueueing without waiting for the state lock. Store only
+ * the event type, never the Codex payload (which can contain user/code content).
+ * Do not mkdir: a concurrent purge must not be undone by a stale hook.
+ */
+function enqueueNotification(args) {
+    if (!fs.existsSync(config_1.CONFIG_PATH))
+        return false;
+    const config = (0, config_1.loadConfig)();
+    const adapter = config.adapters.codex;
+    if (!adapter)
+        return false;
+    let type = "agent-turn-complete";
+    try {
+        type = JSON.parse(args[args.length - 1] ?? "")?.type ?? type;
+    }
+    catch { /* manual invocation */ }
+    if (type !== "agent-turn-complete")
+        return false;
+    const file = path.join(config_1.PINGLET_DIR, `${PREFIX}${(0, crypto_1.randomUUID)()}.json`);
+    const temp = file + ".tmp";
+    try {
+        fs.writeFileSync(temp, JSON.stringify({ type, installedAt: adapter.installedAt, apiBaseUrl: config.apiBaseUrl }), { flag: "wx", mode: 0o600 });
+        fs.renameSync(temp, file);
+        return true;
+    }
+    catch (error) {
+        if (!(0, storage_1.isMissing)(error))
+            throw error;
+        return false;
+    }
+    finally {
+        try {
+            fs.unlinkSync(temp);
+        }
+        catch (error) {
+            if (!(0, storage_1.isMissing)(error))
+                throw error;
+        }
+    }
+}
+/** Caller holds the short state lock. Failed work stays on disk for retry. */
+function drainNotifications() {
+    if (!fs.existsSync(config_1.CONFIG_PATH))
+        return;
+    const config = (0, config_1.loadConfig)();
+    for (const name of fs.readdirSync(config_1.PINGLET_DIR).filter(name => name.startsWith(PREFIX) && name.endsWith(".json"))) {
+        const file = path.join(config_1.PINGLET_DIR, name);
+        const event = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (config.adapters.codex?.installedAt === event.installedAt && config.apiBaseUrl === event.apiBaseUrl) {
+            (0, notify_1.runNotify)([JSON.stringify({ type: event.type })], "evt_" + name.slice(PREFIX.length, -5));
+        }
+        fs.unlinkSync(file); // Stale installation notifications must not survive reinstall.
+    }
+}

package/dist/pending-post.js

@@ -43,11 +43,26 @@ const PENDING_PATH = path.join(config_1.PINGLET_DIR, "pending-posts.json");
  * Only hashes are stored: no message text or bearer token in the retry journal.
  */
 function pendingPostId(config, text, category) {
-    const key = (0, crypto_1.createHash)("sha256").update(JSON.stringify([config.apiBaseUrl, config.userToken, text, category ?? null])).digest("hex");
+    // The JWT subject is used only as a local journal namespace, never for auth.
+    // Refreshing/replacing a token for the same user must retain pending requests.
+    let account = config.userToken;
+    try {
+        const payload = JSON.parse(Buffer.from(config.userToken?.split(".")[1] ?? "", "base64url").toString());
+        if (payload.kind === "user" && typeof payload.sub === "string")
+            account = payload.sub;
+    }
+    catch { /* Legacy/non-JWT fixture tokens retain their previous namespace. */ }
+    const digest = (identity) => (0, crypto_1.createHash)("sha256").update(JSON.stringify([config.apiBaseUrl, identity, text, category || null])).digest("hex");
+    const key = digest(account);
     const pending = (0, config_1.readJsonFile)(PENDING_PATH) ?? [];
-    const existing = pending.find((p) => p.key === key);
-    if (existing)
+    const existing = pending.find((p) => p.key === key || p.key === digest(config.userToken));
+    if (existing) {
+        if (existing.key !== key) {
+            existing.key = key;
+            (0, config_1.writeJsonFile)(PENDING_PATH, pending);
+        }
         return existing.requestId;
+    }
     const requestId = (0, crypto_1.randomUUID)();
     (0, config_1.writeJsonFile)(PENDING_PATH, [...pending, { key, requestId }]);
     return requestId;

package/dist/postinstall.js

@@ -15,7 +15,7 @@ async function main() {
     if (process.env.npm_config_global !== "true")
         return;
     console.log((0, i18n_1.t)("postinstall.start"));
-    await (0, lock_1.withPingletLock)(() => (0, install_1.runInstall)([]));
+    await (0, lock_1.withCommandLock)(() => (0, install_1.runInstall)([]));
 }
 main()
     .catch(() => {

package/dist/queue.js

@@ -37,20 +37,25 @@ exports.appendEvent = appendEvent;
 exports.readEvents = readEvents;
 exports.countEvents = countEvents;
 exports.removeEvents = removeEvents;
+exports.quarantineEvents = quarantineEvents;
+exports.bindEvents = bindEvents;
+exports.invalidEventReason = invalidEventReason;
 const fs = __importStar(require("fs"));
 const crypto_1 = require("crypto");
 const config_1 = require("./config");
+const path = __importStar(require("path"));
 const storage_1 = require("./storage");
 /**
- * Local Event Queue (JSONL). All CLI writers hold withPingletLock for the
- * complete command, so append and removal cannot interleave across processes.
+ * Local Event Queue (JSONL). Writers hold the short local transaction lock;
+ * uploads use a snapshot and acknowledge only its event IDs afterwards.
  * 노출 즉시 서버를 호출하지 않고 여기 기록했다가 batch 전송한다 (아키텍처 §8).
  */
 function appendEvent(input) {
     (0, config_1.ensurePingletDir)();
     const event = {
-        eventId: "evt_" + (0, crypto_1.randomUUID)(),
+        eventId: input.eventId ?? "evt_" + (0, crypto_1.randomUUID)(),
         agentType: input.agentType,
+        installationId: (0, config_1.loadConfig)().installations[input.agentType]?.installationId,
         type: input.type,
         messageId: input.messageId,
         ...(input.visibleMs !== undefined && { visibleMs: input.visibleMs }),
@@ -72,12 +77,16 @@ function readEvents() {
             continue;
         try {
             const parsed = JSON.parse(line);
-            if (parsed.eventId && parsed.messageId && parsed.type) {
-                events.push(parsed);
-            }
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || typeof parsed.eventId !== "string" || !parsed.eventId)
+                throw new Error("invalid queue record");
+            events.push(parsed);
         }
         catch {
-            // 손상된 라인은 버린다.
+            // Preserve damaged input for quarantine rather than silently deleting it
+            // when the next successful upload rewrites the queue.
+            events.push({ eventId: "invalid_" + (0, crypto_1.createHash)("sha256").update(line).digest("hex").slice(0, 48),
+                agentType: "CLAUDE", type: "DELIVERED", messageId: "", occurredAt: "",
+                queueError: "malformed-queue-line", rawLine: line });
         }
     }
     return events;
@@ -91,3 +100,41 @@ function removeEvents(sentEventIds) {
     const body = remaining.map((e) => JSON.stringify(e)).join("\n");
     (0, storage_1.atomicWrite)(config_1.EVENTS_PATH, body ? body + "\n" : "");
 }
+/** Persist before removing from the retry queue. No tokens or server writes. */
+function quarantineEvents(events, reason) {
+    if (!events.length)
+        return;
+    (0, config_1.ensurePingletDir)();
+    fs.appendFileSync(path.join(config_1.PINGLET_DIR, "events-quarantine.jsonl"), events.map(event => JSON.stringify({ reason, quarantinedAt: new Date().toISOString(), event })).join("\n") + "\n", { mode: 0o600 });
+    removeEvents(new Set(events.map(event => event.eventId)));
+}
+/** Legacy/offline events bind once, before any installation can be revoked. */
+function bindEvents() {
+    const config = (0, config_1.loadConfig)();
+    const events = readEvents();
+    let changed = false;
+    for (const event of events) {
+        if (!event.installationId && config.installations[event.agentType]) {
+            event.installationId = config.installations[event.agentType].installationId;
+            changed = true;
+        }
+    }
+    if (changed)
+        (0, storage_1.atomicWrite)(config_1.EVENTS_PATH, events.map(event => JSON.stringify(event)).join("\n") + "\n");
+    return events;
+}
+function invalidEventReason(event) {
+    if (event.queueError)
+        return event.queueError;
+    if (!["CLAUDE", "CODEX"].includes(event.agentType) ||
+        !["DELIVERED", "QUALIFIED_IMPRESSION"].includes(event.type))
+        return "invalid-type";
+    if ([event.eventId, event.messageId].some(value => typeof value !== "string" || !value.length || value.length > 64))
+        return "invalid-id";
+    if (event.visibleMs != null && (!Number.isInteger(event.visibleMs) || event.visibleMs < 0 || event.visibleMs > 60_000))
+        return "invalid-visible-ms";
+    const time = typeof event.occurredAt === "string" ? Date.parse(event.occurredAt) : NaN;
+    if (!Number.isFinite(time) || time < Date.UTC(2000, 0, 1) || time > Date.now() + 5 * 60_000)
+        return "invalid-timestamp";
+    return null;
+}

package/dist/runtime.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FEED_TTL_MS = exports.FLUSH_COUNT = exports.FLUSH_INTERVAL_MS = exports.QUALIFIED_MS = exports.ROTATE_MS = void 0;
+exports.spawnDetachedCommand = spawnDetachedCommand;
 exports.runMaintenance = runMaintenance;
 const child_process_1 = require("child_process");
 const config_1 = require("./config");
@@ -17,6 +18,7 @@ function spawnDetachedCommand(args) {
             detached: true,
             stdio: "ignore",
         });
+        child.on("error", () => { });
         child.unref();
     }
     catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinglet-cli",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Short messages from other developers shown in your Claude Code spinner while the AI thinks — zero tokens, never reads your code. Claude Code / Codex integration",
   "license": "MIT",
   "repository": {