pinglet-cli 0.5.4 → 0.6.1

package/dist/lock.js

@@ -0,0 +1,168 @@
+"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.withPingletLock = withPingletLock;
+exports.withCommandLock = withCommandLock;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+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");
+function owner(lockPath) {
+    try {
+        return fs.readFileSync(lockPath, "utf8");
+    }
+    catch (error) {
+        if ((0, storage_1.isMissing)(error))
+            return null;
+        throw error;
+    }
+}
+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(lockPath).mtimeMs > 30_000;
+    }
+    try {
+        process.kill(pid, 0);
+        return false;
+    }
+    catch (error) {
+        return error.code === "ESRCH";
+    }
+}
+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(recoveryPath, { mode: 0o700 });
+    }
+    catch (error) {
+        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 {
+        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 {
+        try {
+            fs.unlinkSync(ownerPath);
+            fs.rmdirSync(recoveryPath);
+        }
+        catch (error) {
+            if (!(0, storage_1.isMissing)(error))
+                throw error;
+        }
+    }
+}
+/** 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(lockPath, "wx", 0o600);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            recover(lockPath);
+            if (owner(lockPath) === null)
+                continue;
+            if (options.skipIfBusy)
+                return undefined;
+            if (Date.now() >= deadline)
+                throw new Error("Pinglet is busy. Retry after the other command finishes.");
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            continue;
+        }
+        try {
+            fs.writeFileSync(fd, identity);
+        }
+        catch (error) {
+            fs.unlinkSync(lockPath);
+            throw error;
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        break;
+    }
+    try {
+        return await action();
+    }
+    finally {
+        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

@@ -0,0 +1,73 @@
+"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.pendingPostId = pendingPostId;
+exports.completePost = completePost;
+const crypto_1 = require("crypto");
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const PENDING_PATH = path.join(config_1.PINGLET_DIR, "pending-posts.json");
+/** Persist before sending so retrying an ambiguous network failure uses the same ID.
+ * Only hashes are stored: no message text or bearer token in the retry journal.
+ */
+function pendingPostId(config, text, category) {
+    // 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 || 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;
+}
+function completePost(requestId) {
+    const pending = (0, config_1.readJsonFile)(PENDING_PATH) ?? [];
+    (0, config_1.writeJsonFile)(PENDING_PATH, pending.filter((p) => p.requestId !== requestId));
+}

package/dist/postinstall.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const install_1 = require("./commands/install");
 const i18n_1 = require("./i18n");
+const lock_1 = require("./lock");
 /**
  * npm install -g pinglet-cli 직후 자동으로 `pinglet install`을 수행한다.
  * - 글로벌 설치(npm_config_global=true)일 때만 동작 — 개발용 npm install,
@@ -14,7 +15,7 @@ async function main() {
     if (process.env.npm_config_global !== "true")
         return;
     console.log((0, i18n_1.t)("postinstall.start"));
-    await (0, install_1.runInstall)([]);
+    await (0, lock_1.withCommandLock)(() => (0, install_1.runInstall)([]));
 }
 main()
     .catch(() => {

package/dist/queue.js

@@ -37,18 +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 (append-only JSONL).
+ * 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 }),
@@ -70,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;
@@ -87,5 +98,43 @@ function countEvents() {
 function removeEvents(sentEventIds) {
     const remaining = readEvents().filter((e) => !sentEventIds.has(e.eventId));
     const body = remaining.map((e) => JSON.stringify(e)).join("\n");
-    fs.writeFileSync(config_1.EVENTS_PATH, body ? body + "\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/dist/storage.js

@@ -0,0 +1,61 @@
+"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.isMissing = isMissing;
+exports.atomicWrite = atomicWrite;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+function isMissing(error) {
+    return error.code === "ENOENT";
+}
+/** A unique, private temporary file prevents partial reads and writer collisions. */
+function atomicWrite(filePath, body) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    const tmp = `${filePath}.${process.pid}.${(0, crypto_1.randomUUID)()}.tmp`;
+    try {
+        fs.writeFileSync(tmp, body, { flag: "wx", mode: 0o600 });
+        fs.renameSync(tmp, filePath);
+    }
+    finally {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch (error) {
+            if (!isMissing(error))
+                throw error;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinglet-cli",
-  "version": "0.5.4",
+  "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": {
@@ -27,6 +27,7 @@
   ],
   "scripts": {
     "build": "tsc",
+    "test": "npm run build && node --test test/*.test.cjs",
     "dev": "tsc --watch",
     "prepare": "npm run build",
     "postinstall": "node dist/postinstall.js || exit 0"