slacklocalvibe 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slacklocalvibe",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "SlackLocalVibe: Codex/Claude Code turn notifications and reply→resume bridge for Slack DM (Socket Mode)",
   "bin": {
     "slacklocalvibe": "src/cli.js"

package/src/cli.js

@@ -4,13 +4,14 @@ const { runWizard } = require("./commands/wizard");
 const { runNotify } = require("./commands/notify");
 const { runDaemon } = require("./commands/daemon");
 const { runLaunchd } = require("./commands/launchd");
+const packageJson = require("../package.json");
 
 const program = new Command();
 
 program
   .name("slacklocalvibe")
   .description("SlackLocalVibe: Slack DM通知 + 返信resumeブリッジ")
-  .version("0.1.0");
+  .version(packageJson.version);
 
 program
   .command("notify")

package/src/commands/notify.js

@@ -75,6 +75,19 @@ async function runNotify({ tool }) {
     });
     return;
   }
+  if (input.tool === "codex") {
+    const meta = input.meta || {};
+    log(LEVELS.INFO, "notify.codex_prompt_source", {
+      rollout_found: meta.codex_rollout_found,
+      rollout_source: meta.codex_rollout_source,
+      rollout_path: meta.codex_rollout_path,
+      rollout_user_messages: meta.codex_rollout_user_message_count,
+      rollout_line_count: meta.codex_rollout_line_count,
+      input_messages_len: meta.input_messages_len,
+      input_messages_has_content: meta.input_messages_has_content,
+      rollout_error: meta.codex_rollout_error,
+    });
+  }
 
   if (!input.session_id) {
     log(LEVELS.ERROR, "notify.session_missing");

package/src/commands/wizard.js

@@ -102,21 +102,76 @@ async function runWizard() {
   console.log("SlackLocalVibe セットアップを開始します。");
   if (normalized) {
     console.log("既存設定が見つかりました。開始方法を選んでください。");
-    const choice = await promptSelect({
-      message: "どこから始めますか？",
-      choices: [
-        { title: "テストから始める", value: "test" },
-        { title: "リセットして最初から", value: "reset" },
-        { title: "終了（保存せず終了）", value: "exit" },
-      ],
-      initial: 0,
-    });
-    if (choice === "reset") {
-      resetStoredConfig({ log });
-    } else if (choice === "test") {
-      startFromTest = true;
-      console.log("既存設定を使って通知テストから開始します。");
-    } else {
+    while (true) {
+      const choice = await promptSelect({
+        message: "どこから始めますか？",
+        choices: [
+          { title: "アップデートを確認する", value: "update" },
+          { title: "テストから始める", value: "test" },
+          { title: "リセットして最初からセットアップ", value: "reset" },
+          { title: "終了（保存せず終了）", value: "exit" },
+        ],
+        initial: 0,
+      });
+      if (choice === "update") {
+        log(LEVELS.INFO, "wizard.update_check_start");
+        const versionInfo = await fetchUpdateVersions({ log });
+        log(LEVELS.INFO, "wizard.update_versions", {
+          installed: versionInfo.installedVersion || "unknown",
+          latest: versionInfo.latestVersion || "unknown",
+        });
+        console.log(formatInfo(`現在: ${formatVersionLabel(versionInfo.installedVersion)}`));
+        console.log(formatInfo(`最新: ${formatVersionLabel(versionInfo.latestVersion)}`));
+        if (
+          versionInfo.installedVersion &&
+          versionInfo.latestVersion &&
+          versionInfo.installedVersion === versionInfo.latestVersion
+        ) {
+          log(LEVELS.SUCCRSS, "wizard.update_latest_confirmed");
+          console.log(formatSuccess("最新バージョンです。"));
+          continue;
+        }
+
+        const updateChoice = await promptSelect({
+          message: "アップデートしますか？",
+          choices: [
+            { title: "アップデートする", value: "update" },
+            { title: "戻る", value: "back" },
+            { title: "終了（保存せず終了）", value: "exit" },
+          ],
+          initial: 0,
+        });
+        if (updateChoice === "back") {
+          log(LEVELS.INFO, "wizard.update_skipped");
+          continue;
+        }
+        if (updateChoice === "exit") {
+          throw new UserExit();
+        }
+
+        await ensureGlobalInstall({ log });
+        const postUpdate = await fetchUpdateVersions({ log });
+        log(LEVELS.SUCCRSS, "wizard.update_applied", {
+          installed: postUpdate.installedVersion || "unknown",
+          latest: postUpdate.latestVersion || "unknown",
+        });
+        console.log(formatSuccess("アップデートが完了しました。"));
+        console.log(formatInfo(`現在: ${formatVersionLabel(postUpdate.installedVersion)}`));
+        console.log(formatInfo(`最新: ${formatVersionLabel(postUpdate.latestVersion)}`));
+
+        const launchdRecommended = Boolean(normalized?.features?.launchd_enabled);
+        await promptLaunchdReinstall({ log, recommended: launchdRecommended });
+        continue;
+      }
+      if (choice === "reset") {
+        resetStoredConfig({ log });
+        break;
+      }
+      if (choice === "test") {
+        startFromTest = true;
+        console.log("既存設定を使って通知テストから開始します。");
+        break;
+      }
       throw new UserExit();
     }
   }
@@ -1070,6 +1125,124 @@ async function ensureGlobalInstall({ log }) {
   }
 }
 
+async function fetchUpdateVersions({ log }) {
+  const [installedVersion, latestVersion] = await Promise.all([
+    fetchInstalledVersion({ log }),
+    fetchRegistryVersion({ log }),
+  ]);
+  return { installedVersion, latestVersion };
+}
+
+async function fetchInstalledVersion({ log }) {
+  try {
+    const binaryPath = resolveBinaryPath();
+    const result = await spawnCommand({
+      command: binaryPath,
+      args: ["--version"],
+      cwd: process.cwd(),
+    });
+    if (result.code === 0) {
+      const version = (result.stdoutText || "").trim().split(/\s+/)[0];
+      if (version) return version;
+    }
+    log(LEVELS.WARNING, "wizard.update_installed_version_empty", {
+      stdout_len: result.stdoutLen,
+      stderr_len: result.stderrLen,
+    });
+  } catch (error) {
+    log(LEVELS.WARNING, "wizard.update_installed_version_failed", {
+      error: safeError(error),
+    });
+  }
+  return "";
+}
+
+async function fetchRegistryVersion({ log }) {
+  try {
+    const npmPath = resolveCommandPathStrict("npm");
+    const result = await spawnCommand({
+      command: npmPath,
+      args: ["view", "slacklocalvibe", "version"],
+      cwd: process.cwd(),
+    });
+    if (result.code === 0) {
+      const version = (result.stdoutText || "").trim().split(/\s+/)[0];
+      if (version) return version;
+    }
+    log(LEVELS.WARNING, "wizard.update_registry_version_empty", {
+      stdout_len: result.stdoutLen,
+      stderr_len: result.stderrLen,
+    });
+  } catch (error) {
+    log(LEVELS.WARNING, "wizard.update_registry_version_failed", {
+      error: safeError(error),
+    });
+  }
+  return "";
+}
+
+function formatVersionLabel(version) {
+  return version ? version : "不明";
+}
+
+async function promptLaunchdReinstall({ log, recommended }) {
+  const title = recommended
+    ? "launchd を再登録する（推奨）"
+    : "launchd を再登録する";
+  while (true) {
+    const choice = await promptSelect({
+      message: "更新後に launchd を再登録します",
+      choices: [
+        { title, value: "install" },
+        { title: "あとでやる", value: "skip" },
+        { title: "終了（保存せず終了）", value: "exit" },
+      ],
+      initial: 0,
+    });
+    if (choice === "skip") {
+      log(LEVELS.INFO, "wizard.launchd_reinstall_skipped");
+      return;
+    }
+    if (choice === "exit") {
+      throw new UserExit();
+    }
+    try {
+      installLaunchd();
+      log(LEVELS.SUCCRSS, "wizard.launchd_reinstalled");
+      console.log(formatSuccess("launchd を再登録しました。"));
+      return;
+    } catch (error) {
+      log(LEVELS.ERROR, "wizard.launchd_reinstall_failed", {
+        error: safeError(error),
+      });
+      console.log(formatError("launchd の再登録に失敗しました。"));
+      const detail =
+        error?.detail ||
+        error?.stderrText ||
+        error?.stdoutText ||
+        error?.message ||
+        "unknown";
+      if (detail) {
+        console.log(formatError(detail));
+      }
+      const next = await promptSelect({
+        message: "次の操作を選んでください",
+        choices: [
+          { title: "再試行", value: "retry" },
+          { title: "あとでやる", value: "skip" },
+          { title: "終了（保存せず終了）", value: "exit" },
+        ],
+      });
+      if (next === "retry") continue;
+      if (next === "skip") {
+        log(LEVELS.WARNING, "wizard.launchd_reinstall_skipped_after_error");
+        return;
+      }
+      throw new UserExit();
+    }
+  }
+}
+
 async function promptPassword({ message, validate }) {
   while (true) {
     const value = await promptVisible({ message });

package/src/lib/notify-input.js

@@ -1,4 +1,6 @@
 const fs = require("fs");
+const os = require("os");
+const path = require("path");
 
 function parseCodexNotify(rawJson) {
   const payload = JSON.parse(rawJson);
@@ -9,16 +11,9 @@ function parseCodexNotify(rawJson) {
   const turnId = payload["turn-id"] ? String(payload["turn-id"]) : undefined;
   const inputMessages = payload["input-messages"];
   const meta = buildCodexInputMeta(inputMessages);
-  const hasInputMessages = hasNonEmptyInputMessages(inputMessages);
-  if (!hasInputMessages) {
-    return {
-      tool: "codex",
-      skip: true,
-      skip_reason: "empty_input_messages",
-      meta,
-    };
-  }
-  const userText = extractUserTextFromCodex(inputMessages);
+  const rolloutResult = readCodexUserMessageFromRollout(sessionId);
+  Object.assign(meta, rolloutResult.meta || {});
+  const userText = rolloutResult.userText || "";
   const assistantText = extractAssistantText(payload["last-assistant-message"]);
   const cwd = payload?.cwd ? String(payload.cwd) : "";
 
@@ -33,16 +28,11 @@ function parseCodexNotify(rawJson) {
   };
 }
 
-function extractUserTextFromCodex(inputMessages) {
-  if (!Array.isArray(inputMessages) || inputMessages.length === 0) return "";
-  const lastMessage = inputMessages[inputMessages.length - 1];
-  return normalizeContent(lastMessage);
-}
-
 function buildCodexInputMeta(inputMessages) {
   const meta = {
     input_messages_type: Array.isArray(inputMessages) ? "array" : typeof inputMessages,
     input_messages_len: Array.isArray(inputMessages) ? inputMessages.length : 0,
+    input_messages_has_content: hasNonEmptyInputMessages(inputMessages),
     input_messages_roles: [],
     input_messages_last_role: "",
     input_messages_last_type: "",
@@ -78,6 +68,177 @@ function extractAssistantText(content) {
   return normalizeContent(content);
 }
 
+function readCodexUserMessageFromRollout(sessionId) {
+  const meta = {
+    codex_rollout_found: false,
+    codex_rollout_source: "",
+    codex_rollout_path: "",
+    codex_rollout_mtime_ms: 0,
+    codex_rollout_total: 0,
+    codex_rollout_user_message_count: 0,
+    codex_rollout_line_count: 0,
+    codex_rollout_error: "",
+  };
+  const rolloutPath = findCodexRolloutPath(sessionId, meta);
+  if (!rolloutPath) {
+    return { userText: "", meta };
+  }
+  try {
+    const content = fs.readFileSync(rolloutPath, "utf8");
+    const lines = content.split("\n").filter(Boolean);
+    meta.codex_rollout_line_count = lines.length;
+    let lastUser = "";
+    let lastTs = "";
+    let count = 0;
+    for (const line of lines) {
+      let record;
+      try {
+        record = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (record?.type !== "event_msg") continue;
+      const payload = record?.payload;
+      if (payload?.type !== "user_message") continue;
+      const text = extractCodexUserMessage(payload);
+      if (text) {
+        lastUser = text;
+        lastTs = record?.timestamp || "";
+      }
+      count += 1;
+    }
+    meta.codex_rollout_user_message_count = count;
+    if (lastTs) {
+      meta.codex_rollout_last_user_ts = lastTs;
+    }
+    return { userText: lastUser, meta };
+  } catch (error) {
+    meta.codex_rollout_error = error?.message || "rollout_read_failed";
+    return { userText: "", meta };
+  }
+}
+
+function extractCodexUserMessage(payload) {
+  if (!payload || typeof payload !== "object") return "";
+  const content =
+    payload.message ||
+    payload.text ||
+    payload.prompt ||
+    payload.input ||
+    payload.content;
+  return normalizeContent(content);
+}
+
+function findCodexRolloutPath(sessionId, meta) {
+  if (!sessionId) {
+    meta.codex_rollout_error = "session_id_missing";
+    return "";
+  }
+  const sessionsDir = path.join(os.homedir(), ".codex", "sessions");
+  meta.codex_sessions_dir = sessionsDir;
+  if (!fs.existsSync(sessionsDir)) {
+    meta.codex_rollout_error = "sessions_dir_missing";
+    return "";
+  }
+
+  const files = collectRolloutFiles(sessionsDir);
+  meta.codex_rollout_total = files.length;
+  const byName = files.filter((item) => item.name.includes(sessionId));
+  if (byName.length > 0) {
+    const best = pickLatestFile(byName);
+    if (best) {
+      meta.codex_rollout_found = true;
+      meta.codex_rollout_source = "filename";
+      meta.codex_rollout_path = best.path;
+      meta.codex_rollout_mtime_ms = best.mtimeMs;
+      return best.path;
+    }
+  }
+
+  const byContent = findRolloutByContent(files, sessionId, meta);
+  if (byContent) {
+    meta.codex_rollout_found = true;
+    meta.codex_rollout_source = "content";
+    meta.codex_rollout_path = byContent.path;
+    meta.codex_rollout_mtime_ms = byContent.mtimeMs;
+    return byContent.path;
+  }
+
+  meta.codex_rollout_error = meta.codex_rollout_error || "rollout_not_found";
+  return "";
+}
+
+function collectRolloutFiles(rootDir) {
+  const results = [];
+  const stack = [rootDir];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (!entry.name.startsWith("rollout-") || !entry.name.endsWith(".jsonl")) {
+        continue;
+      }
+      let stat;
+      try {
+        stat = fs.statSync(fullPath);
+      } catch {
+        continue;
+      }
+      results.push({
+        path: fullPath,
+        name: entry.name,
+        mtimeMs: stat.mtimeMs || 0,
+      });
+    }
+  }
+  return results;
+}
+
+function pickLatestFile(files) {
+  if (!files || files.length === 0) return null;
+  let best = files[0];
+  for (const item of files) {
+    if (item.mtimeMs > best.mtimeMs) {
+      best = item;
+    }
+  }
+  return best;
+}
+
+function findRolloutByContent(files, sessionId, meta) {
+  if (!files || files.length === 0) {
+    meta.codex_rollout_error = "rollout_files_empty";
+    return null;
+  }
+  const sorted = [...files].sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const limit = 30;
+  for (let i = 0; i < sorted.length && i < limit; i += 1) {
+    const file = sorted[i];
+    let content = "";
+    try {
+      content = fs.readFileSync(file.path, "utf8");
+    } catch {
+      continue;
+    }
+    if (content.includes(sessionId)) {
+      return file;
+    }
+  }
+  meta.codex_rollout_error = "rollout_not_matched_in_recent_files";
+  return null;
+}
+
 function extractTextDeep(value, depth = 0) {
   if (depth > 6) return "";
   if (value === null || value === undefined) return "";