@mu-cabin/muc-cli 0.5.0 → 0.5.2

package/dist/muc.mjs

@@ -22241,10 +22241,9 @@ async function request(opts) {
           recovered = true;
         } catch (refreshErr) {
           if (!(refreshErr instanceof CliError) || cred.rememberedPwd == null) throw refreshErr;
-          if (isAssistantProfile()) throw refreshErr;
         }
       }
-      if (!recovered && cred.rememberedPwd && !isAssistantProfile()) {
+      if (!recovered && cred.rememberedPwd) {
         try {
           await refreshViaRememberedPwd();
           recovered = true;
@@ -22343,9 +22342,6 @@ async function doRefreshViaRememberedPwd() {
     throw new CliError(
       "AUTH_EXPIRED",
       `rememberedPwd refresh rejected: code=${res.code} msg=${res.msg ?? ""}`.trim(),
-      // This arm is gated off on the assistant profile (see request()'s
-      // cascade), so in practice loginCmd() always returns `muc login`
-      // here. Templated anyway for consistency + future-proofing.
       `rerun \`${loginCmd()} --account <UID>\` interactively to mint fresh credentials`
     );
   }
@@ -22522,13 +22518,6 @@ function register(program3, variant) {
           "rerun without --token-pwd, or pass --account + (--password-stdin or interactive prompt)"
         );
       }
-      if (isAssistant && opts.remember === true) {
-        throw new CliError(
-          "USAGE",
-          "--remember is not supported on the assistant profile",
-          "the assistant daemon's refresh cascade stops at Step 2 by design (see http.ts); drop --remember (and run with --no-remember to wipe any pre-existing blob)"
-        );
-      }
       const existing = loadCredentials();
       const accountRaw = opts.account ?? process.env.MUC_ACCOUNT ?? existing?.uid;
       if (!accountRaw) {
@@ -23163,6 +23152,7 @@ var Output3 = external_exports.object({
   tokenPwdSet: external_exports.boolean(),
   tokenPwdExpireAt: external_exports.number().optional(),
   tokenPwdExpiresIn: external_exports.string().optional(),
+  remembered: external_exports.boolean(),
   savedAt: external_exports.number(),
   credentialsPath: external_exports.string()
 });
@@ -23216,6 +23206,7 @@ function register3(program3) {
         tokenPwdSet: Boolean(c.tokenPwd),
         tokenPwdExpireAt: c.tokenPwdExpireAt,
         tokenPwdExpiresIn: relativeFromNow(c.tokenPwdExpireAt),
+        remembered: Boolean(c.rememberedPwd),
         savedAt: c.savedAt,
         credentialsPath: credentialsPath()
       };
@@ -24016,9 +24007,13 @@ async function openChatSession(cred, opts = {}) {
     } catch (refreshErr) {
       const msg = String(refreshErr?.message ?? refreshErr);
       if (msg.includes("61018") || /tokenPwd|自动登陆/.test(msg)) {
+        if (cred.rememberedPwd) {
+          const rememberedFresh = await refreshViaRememberedPwd();
+          return await tryChatLogin(rememberedFresh, opts, cfg);
+        }
         const lc = isAssistantProfile() ? "muc assistant-login" : "muc login";
         throw new Error(
-          `chat login failed: access token expired AND saved tokenPwd is no longer valid (server returned 61018). Run \`${lc}\` with your password to mint fresh credentials, then retry.`
+          `chat login failed: access token expired AND saved tokenPwd is no longer valid (server returned 61018). Run \`${lc}\` with your password (add --remember to allow unattended daemon recovery) to mint fresh credentials, then retry.`
         );
       }
       throw refreshErr;
@@ -24128,6 +24123,7 @@ function daemonPaths(kind, opts = {}) {
       sock: join7(runtimeDir2, "daemon.sock"),
       pid: join7(runtimeDir2, "daemon.pid"),
       state: join7(runtimeDir2, "daemon-state.json"),
+      lifecycle: join7(runtimeDir2, "daemon-lifecycle.ndjson"),
       eventsLegacy: join7(runtimeDir2, "daemon-events.ndjson"),
       eventsPrefix: prefix2,
       eventsFile: (date) => join7(runtimeDir2, `${prefix2}-${date}.ndjson`)
@@ -24144,6 +24140,7 @@ function daemonPaths(kind, opts = {}) {
       sock: join7(runtimeDir2, "assistant.sock"),
       pid: join7(runtimeDir2, "assistant.pid"),
       state: join7(runtimeDir2, "assistant-state.json"),
+      lifecycle: join7(runtimeDir2, "assistant-lifecycle.ndjson"),
       eventsLegacy: join7(runtimeDir2, "assistant-events.ndjson"),
       eventsPrefix: prefix2,
       eventsFile: (date) => join7(runtimeDir2, `${prefix2}-${date}.ndjson`),
@@ -24163,6 +24160,7 @@ function daemonPaths(kind, opts = {}) {
     sock: join7(runtimeDir, "assistant.sock"),
     pid: join7(runtimeDir, "daemon.pid"),
     state: join7(runtimeDir, "state.json"),
+    lifecycle: join7(runtimeDir, "lifecycle.ndjson"),
     eventsLegacy: join7(runtimeDir, "events.ndjson"),
     eventsPrefix: prefix,
     eventsFile: (date) => join7(runtimeDir, `${prefix}-${date}.ndjson`),
@@ -28279,7 +28277,7 @@ function formatHuman(m) {
 import { existsSync as existsSync11, unlinkSync as unlinkSync4 } from "node:fs";
 
 // src/daemon/broker.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync7, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync7, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "node:fs";
 import { setTimeout as delay } from "node:timers/promises";
 
 // src/daemon/kicked-policy.ts
@@ -28336,6 +28334,10 @@ function formatDuration(ms) {
 }
 
 // src/daemon/broker.ts
+function credentialsForReconnect(current, onDisk) {
+  if (!onDisk || onDisk.uid !== current.uid) return current;
+  return onDisk.savedAt >= current.savedAt ? onDisk : current;
+}
 var ChatBroker = class {
   kind;
   paths;
@@ -28353,6 +28355,8 @@ var ChatBroker = class {
   status = "starting";
   lastMessage;
   startedAt = Date.now();
+  lifecycleDetails = {};
+  exitRecorded = false;
   socketEndDeferred = null;
   constructor(opts) {
     this.kind = opts.kind;
@@ -28402,11 +28406,10 @@ var ChatBroker = class {
     });
     this.eventLog.migrateLegacy();
     this.eventLog.prune();
+    this.installProcessHandlers();
     this.ipc = new IpcServer(this.paths, (cmd) => this.handleIpc(cmd), { eventLog: this.eventLog });
     await this.ipc.start();
     this.publishState("starting", `${this.kind} daemon initializing (os=${this.os}, uid=${this.cred.uid})`);
-    process.on("SIGINT", () => void this.shutdown("SIGINT"));
-    process.on("SIGTERM", () => void this.shutdown("SIGTERM"));
     await this.connectChatLoop();
   }
   broadcast(event) {
@@ -28425,7 +28428,8 @@ var ChatBroker = class {
         uid: this.cred?.uid,
         os: this.os,
         kind: this.kind,
-        on_kicked: formatKickedRecoveryPolicy(this.kickedPolicy)
+        on_kicked: formatKickedRecoveryPolicy(this.kickedPolicy),
+        ...this.lifecycleDetails
       }, null, 2), { mode: 384 });
     } catch {
     }
@@ -28434,6 +28438,7 @@ var ChatBroker = class {
   async shutdown(reason) {
     if (this.shuttingDown) return;
     this.shuttingDown = true;
+    this.recordLifecycle("shutdown_requested", { last_exit_reason: reason, last_signal: isSignal(reason) ? reason : void 0 });
     process.stderr.write(`[${this.kind}-daemon] shutting down (${reason})
 `);
     if (this.session) {
@@ -28451,11 +28456,24 @@ var ChatBroker = class {
       unlinkSync3(this.paths.pid);
     } catch {
     }
+    this.lifecycleDetails = {
+      ...this.lifecycleDetails,
+      last_exit_reason: reason,
+      last_exit_at: Date.now(),
+      ...isSignal(reason) ? { last_signal: reason } : {}
+    };
     this.publishState("stopped", `${this.kind} daemon stopped (${reason})`);
+    this.recordLifecycle("process_exit", { last_exit_reason: reason, last_exit_at: Date.now() });
+    this.exitRecorded = true;
     process.exit(0);
   }
   async connectChatLoop() {
+    let connectionAttempt = 0;
     while (!this.shuttingDown) {
+      connectionAttempt++;
+      this.recordLifecycle(connectionAttempt === 1 ? "connection_attempt" : "reconnect_attempt", {
+        reconnect_attempt: Math.max(0, connectionAttempt - 1)
+      });
       let endReason;
       try {
         await this.openSocket();
@@ -28470,6 +28488,9 @@ var ChatBroker = class {
     }
   }
   async handleSocketEnd(reason) {
+    this.recordLifecycle("socket_end", {
+      last_error: socketEndDetail(reason)
+    });
     if (reason.kind === "kicked") {
       const prefix = `chat slot taken by another device: ${reason.detail}`;
       if (this.kickedPolicy.mode === "pause") {
@@ -28486,6 +28507,10 @@ var ChatBroker = class {
         policy: waitMs === 0 ? "immediate" : "delayed",
         retry_in_ms: waitMs
       });
+      this.recordLifecycle("reconnect_scheduled", {
+        retry_in_ms: waitMs,
+        retry_at: Date.now() + waitMs
+      });
       if (waitMs > 0) await this.sleep(waitMs);
       return true;
     }
@@ -28505,15 +28530,23 @@ var ChatBroker = class {
     const backoff = expBackoffMs(this.reconnectAttempts);
     this.publishState("paused_network", `reconnect attempt ${this.reconnectAttempts} in ${Math.round(backoff / 1e3)}s: ${msg}`);
     this.broadcast({ event: "paused", reason: "network", detail: msg });
+    this.recordLifecycle("reconnect_scheduled", {
+      reconnect_attempt: this.reconnectAttempts,
+      retry_in_ms: backoff,
+      retry_at: Date.now() + backoff,
+      last_error: msg
+    });
     await this.sleep(backoff);
     return true;
   }
   async openSocket() {
+    this.cred = credentialsForReconnect(this.cred, loadCredentials());
     const session = await openChatSession(this.cred, { os: this.os, debug: this.opts.debug });
     const reloaded = loadCredentials();
     if (reloaded) this.cred = reloaded;
     this.session = session;
     this.publishState("connected", `chat socket open (os=${this.os}, uid=${this.cred.uid})`);
+    this.recordLifecycle("connected", { reconnect_attempt: this.reconnectAttempts });
     this.broadcast({ event: "hello", os: this.os });
     const sock = session.socket;
     sock.on("kicked", (payload) => {
@@ -28564,6 +28597,78 @@ var ChatBroker = class {
       this.socketEndDeferred = null;
     }
   }
+  installProcessHandlers() {
+    for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+      process.on(signal, () => void this.shutdown(signal));
+    }
+    process.on("uncaughtException", (error) => this.crash("uncaught_exception", error));
+    process.on("unhandledRejection", (reason) => this.crash("unhandled_rejection", reason));
+    process.on("exit", (code) => {
+      if (this.exitRecorded) return;
+      this.recordLifecycle("process_exit", {
+        last_exit_reason: `process_exit_${code}`,
+        last_exit_at: Date.now()
+      });
+    });
+  }
+  crash(reason, error) {
+    if (this.shuttingDown) process.exit(1);
+    this.shuttingDown = true;
+    const detail = errorDetail(error);
+    this.lifecycleDetails = {
+      ...this.lifecycleDetails,
+      last_exit_reason: reason,
+      last_exit_at: Date.now(),
+      last_error: detail
+    };
+    this.publishState("stopped", `${this.kind} daemon crashed (${reason}): ${detail}`);
+    this.recordLifecycle("process_crash", this.lifecycleDetails);
+    this.exitRecorded = true;
+    process.stderr.write(`[${this.kind}-daemon] ${reason}: ${detail}
+`);
+    process.exit(1);
+  }
+  recordLifecycle(event, details = {}) {
+    const now = Date.now();
+    if (event === "connected" || event === "connection_attempt" || event === "reconnect_attempt" || event === "shutdown_requested" || event === "process_exit" || event === "process_crash") {
+      delete this.lifecycleDetails.retry_in_ms;
+      delete this.lifecycleDetails.retry_at;
+    }
+    this.lifecycleDetails = {
+      ...this.lifecycleDetails,
+      lifecycle_event: event,
+      lifecycle_at: now,
+      ...withoutUndefined(details)
+    };
+    ensureRuntimeDir(this.paths);
+    try {
+      appendFileSync2(this.paths.lifecycle, JSON.stringify({
+        ts: now,
+        event,
+        pid: process.pid,
+        kind: this.kind,
+        status: this.status,
+        uid: this.cred?.uid,
+        os: this.os,
+        ...withoutUndefined(details)
+      }) + "\n", { mode: 384 });
+    } catch {
+    }
+    try {
+      const previous = readState(this.paths) ?? {};
+      writeFileSync5(this.paths.state, JSON.stringify({
+        ...previous,
+        status: this.status,
+        pid: process.pid,
+        uid: this.cred?.uid,
+        os: this.os,
+        kind: this.kind,
+        on_kicked: formatKickedRecoveryPolicy(this.kickedPolicy),
+        ...this.lifecycleDetails
+      }, null, 2), { mode: 384 });
+    } catch {
+    }
+  }
   async handleIpc(cmd) {
     const extra = await this.opts.extraIpc?.(cmd, this);
     if (extra) return extra;
@@ -28684,6 +28789,22 @@ function readState(paths2) {
     return null;
   }
 }
+function inferredExitState(state, pid) {
+  if (!pid || state?.status === "stopped") return {};
+  try {
+    process.kill(pid, 0);
+    return {};
+  } catch (e) {
+    if (e?.code !== "ESRCH") return {};
+  }
+  if (state?.last_exit_reason) return {};
+  const lastStateAt = state?.lifecycle_at ?? state?.ts;
+  return {
+    last_exit_reason: "process_disappeared",
+    exit_inferred: true,
+    ...lastStateAt ? { last_state_at: lastStateAt } : {}
+  };
+}
 function readPid(paths2) {
   if (!existsSync10(paths2.pid)) return void 0;
   try {
@@ -28729,6 +28850,25 @@ function expBackoffMs(attempt) {
   const base = [5e3, 15e3, 6e4, 3e5, 3e5, 3e5, 3e5];
   return base[Math.min(attempt - 1, base.length - 1)];
 }
+function socketEndDetail(reason) {
+  if (reason.kind === "kicked") return reason.detail;
+  if (reason.kind === "error" || reason.kind === "open_failed") return reason.message;
+  return "socket closed";
+}
+function errorDetail(error) {
+  if (error instanceof Error) return (error.stack ?? error.message).slice(0, 4e3);
+  try {
+    return JSON.stringify(error).slice(0, 4e3);
+  } catch {
+    return String(error).slice(0, 4e3);
+  }
+}
+function isSignal(reason) {
+  return reason === "SIGINT" || reason === "SIGTERM" || reason === "SIGHUP";
+}
+function withoutUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0));
+}
 function ok(id, data) {
   return { id, ok: true, data };
 }
@@ -28773,7 +28913,18 @@ var StatusOutput = external_exports.object({
   pid: external_exports.number().optional(),
   socket: external_exports.string(),
   history_days: external_exports.number().optional(),
-  on_kicked: external_exports.string().optional()
+  on_kicked: external_exports.string().optional(),
+  lifecycle_event: external_exports.string().optional(),
+  lifecycle_at: external_exports.number().optional(),
+  reconnect_attempt: external_exports.number().optional(),
+  retry_in_ms: external_exports.number().optional(),
+  retry_at: external_exports.number().optional(),
+  last_exit_reason: external_exports.string().optional(),
+  last_exit_at: external_exports.number().optional(),
+  exit_inferred: external_exports.boolean().optional(),
+  last_state_at: external_exports.number().optional(),
+  last_signal: external_exports.string().optional(),
+  last_error: external_exports.string().optional()
 });
 var StopOutput = external_exports.object({
   stopped: external_exports.boolean(),
@@ -28851,6 +29002,7 @@ function register29(program3) {
       const probe = await probeDaemon(paths);
       const state = readState(paths);
       const pid = readPid(paths);
+      const diagnostics = { ...stateDiagnostics(state), ...inferredExitState(state, pid) };
       if (probe === "absent" || probe === "stale") {
         return {
           running: false,
@@ -28861,7 +29013,8 @@ function register29(program3) {
           os: state?.os,
           ...pid ? { pid } : {},
           socket: paths.sock,
-          on_kicked: state?.on_kicked
+          on_kicked: state?.on_kicked,
+          ...diagnostics
         };
       }
       if (probe === "indeterminate") {
@@ -28872,7 +29025,8 @@ function register29(program3) {
           message: "socket present but unresponsive within probe budget",
           ...pid ? { pid } : {},
           socket: paths.sock,
-          on_kicked: state?.on_kicked
+          on_kicked: state?.on_kicked,
+          ...diagnostics
         };
       }
       const res = await callIpc(paths, { cmd: "status" }, 5e3).catch(() => null);
@@ -28888,7 +29042,8 @@ function register29(program3) {
           pid: typeof data.pid === "number" ? data.pid : pid,
           socket: typeof data.socket === "string" ? data.socket : paths.sock,
           history_days: typeof data.history_days === "number" ? data.history_days : void 0,
-          on_kicked: typeof data.on_kicked === "string" ? data.on_kicked : state?.on_kicked
+          on_kicked: typeof data.on_kicked === "string" ? data.on_kicked : state?.on_kicked,
+          ...diagnostics
         };
       }
       return {
@@ -28900,7 +29055,8 @@ function register29(program3) {
         os: state?.os,
         ...pid ? { pid } : {},
         socket: paths.sock,
-        on_kicked: state?.on_kicked
+        on_kicked: state?.on_kicked,
+        ...diagnostics
       };
     }
   });
@@ -28995,6 +29151,21 @@ function register29(program3) {
     }
   });
 }
+function stateDiagnostics(state) {
+  if (!state) return {};
+  const keys = [
+    "lifecycle_event",
+    "lifecycle_at",
+    "reconnect_attempt",
+    "retry_in_ms",
+    "retry_at",
+    "last_exit_reason",
+    "last_exit_at",
+    "last_signal",
+    "last_error"
+  ];
+  return Object.fromEntries(keys.flatMap((key) => state[key] === void 0 ? [] : [[key, state[key]]]));
+}
 function parseIfMissing2(raw) {
   if (raw === "error" || raw === "earliest" || raw === "latest") return raw;
   throw new CliError("USAGE", `invalid --if-missing: ${raw}`, "expected error|earliest|latest");
@@ -30377,7 +30548,7 @@ function formatBytes(n) {
 }
 
 // src/assistant/memory.ts
-import { appendFileSync as appendFileSync2, readFileSync as readFileSync10, readdirSync as readdirSync5, existsSync as existsSync15, writeFileSync as writeFileSync7, mkdirSync as mkdirSync11, renameSync as renameSync5, unlinkSync as unlinkSync7, rmSync as rmSync4 } from "node:fs";
+import { appendFileSync as appendFileSync3, readFileSync as readFileSync10, readdirSync as readdirSync5, existsSync as existsSync15, writeFileSync as writeFileSync7, mkdirSync as mkdirSync11, renameSync as renameSync5, unlinkSync as unlinkSync7, rmSync as rmSync4 } from "node:fs";
 import { dirname as dirname6, join as join12 } from "node:path";
 function scopeKey(scene, toId, fromUid, selfUid) {
   if (scene === "team_g") return `team_g:${toId}`;
@@ -30388,7 +30559,7 @@ function appendMemory(name, entry) {
   migrateLegacyMemoryFile(name);
   const file4 = assistantThreadFile(name, entry.tid);
   mkdirSync11(dirname6(file4), { recursive: true, mode: 448 });
-  appendFileSync2(file4, JSON.stringify(entry) + "\n", { mode: 384 });
+  appendFileSync3(file4, JSON.stringify(entry) + "\n", { mode: 384 });
 }
 function readWindow(name, tid, limit, excludeMid) {
   migrateLegacyMemoryFile(name);
@@ -30504,7 +30675,7 @@ function migrateLegacyMemoryFile(name) {
     if (!obj || typeof obj !== "object") continue;
     if (typeof obj.tid !== "string" || !obj.tid) continue;
     const dest = assistantThreadFile(name, obj.tid);
-    appendFileSync2(dest, JSON.stringify(obj) + "\n", { mode: 384 });
+    appendFileSync3(dest, JSON.stringify(obj) + "\n", { mode: 384 });
   }
   try {
     renameSync5(legacy, legacy + ".legacy");
@@ -30518,7 +30689,7 @@ function migrateLegacyMemoryFile(name) {
 
 // src/assistant/ipc.ts
 import { createServer as createServer2, connect as netConnect2 } from "node:net";
-import { existsSync as existsSync16, mkdirSync as mkdirSync12, unlinkSync as unlinkSync8, chmodSync as chmodSync7, appendFileSync as appendFileSync3 } from "node:fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync12, unlinkSync as unlinkSync8, chmodSync as chmodSync7, appendFileSync as appendFileSync4 } from "node:fs";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { dirname as dirname7 } from "node:path";
 var IpcServer2 = class {
@@ -30623,7 +30794,7 @@ var IpcServer2 = class {
       }
       const date = historyDateString2(ts);
       if (this.currentDate !== date) this.currentDate = date;
-      appendFileSync3(historyFile(date), line, { mode: 384 });
+      appendFileSync4(historyFile(date), line, { mode: 384 });
     } catch {
     }
   }
@@ -31659,7 +31830,7 @@ function parseConflictLine(line) {
 import { existsSync as existsSync23, readFileSync as readFileSync16, unlinkSync as unlinkSync11 } from "node:fs";
 
 // src/assistant/daemon.ts
-import { existsSync as existsSync22, writeFileSync as writeFileSync12, readFileSync as readFileSync15, unlinkSync as unlinkSync10, appendFileSync as appendFileSync4, mkdirSync as mkdirSync17 } from "node:fs";
+import { existsSync as existsSync22, writeFileSync as writeFileSync12, readFileSync as readFileSync15, unlinkSync as unlinkSync10, appendFileSync as appendFileSync5, mkdirSync as mkdirSync17 } from "node:fs";
 import { promises as fsp4 } from "node:fs";
 import path7 from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
@@ -33607,10 +33778,10 @@ var AssistantDaemon = class {
       const loginCmd2 = isAssistantProfile() ? "muc assistant-login" : "muc login";
       this.publishState(
         "paused_auth",
-        `access token expired and saved tokenPwd is invalid. Run \`${loginCmd2}\` to mint fresh credentials, then restart the daemon.`
+        `access token expired and saved tokenPwd is invalid. Run \`${loginCmd2} --remember\` to mint fresh credentials and enable unattended recovery, then restart the daemon.`
       );
       this.statusBoard?.onPause("auth", msg);
-      notifyMac("MUC Assistant paused", `auth expired \u2014 run \`${loginCmd2}\`, then restart the daemon`);
+      notifyMac("MUC Assistant paused", `auth expired \u2014 run \`${loginCmd2} --remember\`, then restart the daemon`);
       return false;
     }
     this.reconnectAttempts++;
@@ -33651,6 +33822,10 @@ var AssistantDaemon = class {
     }
   }
   async openSocket() {
+    const onDisk = loadCredentials();
+    if (onDisk?.uid === this.cred.uid && onDisk.savedAt >= this.cred.savedAt) {
+      this.cred = onDisk;
+    }
     const session = await openChatSession(this.cred, { os: this.os, debug: this.opts.debug });
     const reloaded = loadCredentials();
     if (reloaded) this.cred = reloaded;
@@ -35164,14 +35339,14 @@ function writePid2(pid) {
 function appendInboxLog(line) {
   ensureRuntimeDir2();
   try {
-    appendFileSync4(INBOX_LOG, JSON.stringify({ ts: Date.now(), ...line }) + "\n", { mode: 384 });
+    appendFileSync5(INBOX_LOG, JSON.stringify({ ts: Date.now(), ...line }) + "\n", { mode: 384 });
   } catch {
   }
 }
 function appendConflictsLog(msg) {
   ensureRuntimeDir2();
   try {
-    appendFileSync4(CONFLICTS_LOG, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
+    appendFileSync5(CONFLICTS_LOG, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `, { mode: 384 });
   } catch {
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mu-cabin/muc-cli",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Terminal client for MUC IM (com.meicloud.im.dh).",
   "license": "MIT",
   "type": "module",
@@ -22,6 +22,16 @@
     "im",
     "cli"
   ],
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "test": "tsx --test \"src/**/*.test.ts\"",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "build": "node scripts/build.mjs",
+    "prepack": "npm run typecheck && npm run build",
+    "verify": "npm pack --dry-run",
+    "pack:offline": "bash ../../scripts/pack-offline.sh"
+  },
   "dependencies": {
     "commander": "^12.1.0",
     "crypto-js": "^4.2.0",
@@ -39,14 +49,5 @@
   },
   "publishConfig": {
     "access": "public"
-  },
-  "scripts": {
-    "dev": "tsx src/index.ts",
-    "test": "tsx --test \"src/**/*.test.ts\"",
-    "typecheck": "tsc --noEmit",
-    "clean": "rm -rf dist",
-    "build": "node scripts/build.mjs",
-    "verify": "npm pack --dry-run",
-    "pack:offline": "bash ../../scripts/pack-offline.sh"
   }
-}
+}