slacklocalvibe 0.1.0

package/src/lib/config.js

@@ -0,0 +1,101 @@
+const fs = require("fs");
+const path = require("path");
+const { configPath, configDir } = require("./paths");
+
+function loadConfig() {
+  const filePath = configPath();
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  const raw = fs.readFileSync(filePath, "utf8");
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    const err = new Error(`設定ファイルのJSON解析に失敗しました: ${filePath}`);
+    err.cause = error;
+    throw err;
+  }
+}
+
+function writeConfig(config) {
+  const dir = configDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = configPath();
+  backupFileIfExists(filePath);
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2), "utf8");
+  try {
+    fs.chmodSync(filePath, 0o600);
+  } catch (error) {
+    const err = new Error(`設定ファイルの権限変更に失敗しました: ${filePath}`);
+    err.cause = error;
+    throw err;
+  }
+}
+
+function backupFileIfExists(filePath) {
+  if (!fs.existsSync(filePath)) return;
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${filePath}.bak-${timestamp}`;
+  fs.copyFileSync(filePath, backupPath);
+}
+
+function normalizeConfig(config) {
+  const normalized = {
+    slack: {
+      bot_token: config?.slack?.bot_token || "",
+      app_token: config?.slack?.app_token || "",
+    },
+    destinations: {
+      dm: {
+        enabled: Boolean(config?.destinations?.dm?.enabled),
+        target_user_id: config?.destinations?.dm?.target_user_id || "",
+      },
+    },
+    features: {
+      reply_resume: Boolean(config?.features?.reply_resume),
+      launchd_enabled: Boolean(config?.features?.launchd_enabled),
+    },
+  };
+
+  if (!normalized.features.reply_resume) {
+    normalized.features.launchd_enabled = false;
+  }
+
+  return normalized;
+}
+
+function assertNotifyConfig(config) {
+  if (!config?.slack?.bot_token) {
+    throw new Error("slack.bot_token が未設定です。");
+  }
+  const dmEnabled = Boolean(config?.destinations?.dm?.enabled);
+  if (!dmEnabled) {
+    throw new Error("destinations.dm.enabled が false のため通知できません。");
+  }
+  if (!config?.destinations?.dm?.target_user_id) {
+    throw new Error("destinations.dm.target_user_id が未設定です。");
+  }
+}
+
+function assertDaemonConfig(config) {
+  if (!config?.slack?.bot_token) {
+    throw new Error("slack.bot_token が未設定です。");
+  }
+  if (!config?.slack?.app_token) {
+    throw new Error("slack.app_token が未設定です。");
+  }
+  if (!config?.features?.reply_resume) {
+    throw new Error("features.reply_resume が false のため daemon を起動できません。");
+  }
+}
+
+module.exports = {
+  loadConfig,
+  writeConfig,
+  backupFileIfExists,
+  normalizeConfig,
+  assertNotifyConfig,
+  assertDaemonConfig,
+  configPath,
+  configDir,
+};

package/src/lib/launchd.js

@@ -0,0 +1,237 @@
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const {
+  launchAgentsDir,
+  launchdPlistPath,
+  daemonLogPath,
+  resolveCommandPathStrict,
+} = require("./paths");
+
+function buildDaemonPathEnv() {
+  const parts = [];
+  const add = (value) => {
+    if (!value) return;
+    const dir = value.trim();
+    if (!dir) return;
+    if (parts.includes(dir)) return;
+    parts.push(dir);
+  };
+  add(path.dirname(process.execPath));
+  const codexPath = resolveCommandPathStrict("codex", { optional: true });
+  const claudePath = resolveCommandPathStrict("claude", { optional: true });
+  add(codexPath ? path.dirname(codexPath) : "");
+  add(claudePath ? path.dirname(claudePath) : "");
+  return parts.join(":");
+}
+
+function installLaunchd({ cliPath } = {}) {
+  const binaryPath = cliPath || resolveBinaryPath();
+  if (!binaryPath) {
+    throw new Error("slacklocalvibe の実行ファイルが見つかりません。");
+  }
+
+  uninstallLaunchd({ allowMissing: true });
+
+  const plistPath = launchdPlistPath();
+  fs.mkdirSync(launchAgentsDir(), { recursive: true });
+  fs.writeFileSync(plistPath, buildPlist(binaryPath), "utf8");
+
+  const uid = process.getuid();
+  const label = "dev.slacklocalvibe.daemon";
+  const launchctlPath = resolveCommandPathStrict("launchctl");
+  let result = spawnSync(launchctlPath, ["bootstrap", `gui/${uid}`, plistPath], {
+    stdio: "pipe",
+    env: process.env,
+  });
+
+  if (result.status !== 0) {
+    const stderrText = (result.stderr || "").toString("utf8").trim();
+    const stdoutText = (result.stdout || "").toString("utf8").trim();
+    const detail = stderrText || stdoutText || "";
+    const shouldRetry =
+      result.status === 5 ||
+      /input\/output error/i.test(detail);
+    if (shouldRetry) {
+      spawnSync(launchctlPath, ["bootout", `gui/${uid}/${label}`], {
+        stdio: "pipe",
+        env: process.env,
+      });
+      const sleepPath = resolveCommandPathStrict("sleep");
+      spawnSync(sleepPath, ["0.2"], { stdio: "ignore", env: process.env });
+      result = spawnSync(launchctlPath, ["bootstrap", `gui/${uid}`, plistPath], {
+        stdio: "pipe",
+        env: process.env,
+      });
+    }
+  }
+
+  if (result.status !== 0) {
+    const err = new Error("launchctl bootstrap に失敗しました。");
+    err.code = result.status;
+    err.stderrLen = result.stderr?.length || 0;
+    err.stderrText = (result.stderr || "").toString("utf8").trim();
+    err.stdoutText = (result.stdout || "").toString("utf8").trim();
+    err.detail = err.stderrText || err.stdoutText || "";
+    throw err;
+  }
+
+  return { plistPath };
+}
+
+function uninstallLaunchd({ allowMissing = false } = {}) {
+  const uid = process.getuid();
+  const label = "dev.slacklocalvibe.daemon";
+  const launchctlPath = resolveCommandPathStrict("launchctl");
+  const statusResult = spawnSync(launchctlPath, ["print", `gui/${uid}/${label}`], {
+    stdio: "pipe",
+    env: process.env,
+  });
+  const plistPath = launchdPlistPath();
+  const hasPlist = fs.existsSync(plistPath);
+
+  if (statusResult.status !== 0 && !hasPlist) {
+    if (allowMissing) {
+      return { installed: false, bootoutStatus: statusResult.status };
+    }
+    const err = new Error("launchd が未登録のためアンインストールできません。");
+    err.code = statusResult.status;
+    throw err;
+  }
+
+  let result = statusResult;
+  if (statusResult.status === 0) {
+    result = spawnSync(launchctlPath, ["bootout", `gui/${uid}/${label}`], {
+      stdio: "pipe",
+      env: process.env,
+    });
+    if (result.status !== 0) {
+      const stderrText = (result.stderr || "").toString("utf8").trim();
+      const stdoutText = (result.stdout || "").toString("utf8").trim();
+      const detail = stderrText || stdoutText || "";
+      const err = new Error("launchctl bootout に失敗しました。");
+      err.code = result.status;
+      err.detail = detail;
+      throw err;
+    }
+  }
+
+  if (hasPlist) {
+    fs.unlinkSync(plistPath);
+  }
+
+  return {
+    installed: statusResult.status === 0 || hasPlist,
+    bootoutStatus: result.status,
+    bootoutStderrLen: result.stderr?.length || 0,
+  };
+}
+
+function statusLaunchd() {
+  const uid = process.getuid();
+  const label = "dev.slacklocalvibe.daemon";
+  const launchctlPath = resolveCommandPathStrict("launchctl");
+  const result = spawnSync(launchctlPath, ["print", `gui/${uid}/${label}`], {
+    stdio: "pipe",
+    env: process.env,
+  });
+  return { status: result.status };
+}
+
+function resolveNpmBinDir() {
+  const npmPath = resolveCommandPathStrict("npm");
+  const npmResult = spawnSync(npmPath, ["bin", "-g"], {
+    encoding: "utf8",
+    shell: false,
+    env: process.env,
+  });
+  if (npmResult.status === 0) {
+    const binDir = npmResult.stdout.trim();
+    if (binDir) return binDir;
+  }
+  return "";
+}
+
+function resolveNpmPrefix() {
+  const npmPath = resolveCommandPathStrict("npm");
+  const prefixResult = spawnSync(npmPath, ["prefix", "-g"], {
+    encoding: "utf8",
+    shell: false,
+    env: process.env,
+  });
+  if (prefixResult.status === 0) {
+    const prefix = prefixResult.stdout.trim();
+    if (prefix) return prefix;
+  }
+  const configResult = spawnSync(npmPath, ["config", "get", "prefix"], {
+    encoding: "utf8",
+    shell: false,
+    env: process.env,
+  });
+  if (configResult.status === 0) {
+    const prefix = configResult.stdout.trim();
+    if (prefix) return prefix;
+  }
+  return "";
+}
+
+function resolveBinaryPath() {
+  const npmBinDir = resolveNpmBinDir();
+  if (npmBinDir) {
+    const candidate = path.join(npmBinDir, "slacklocalvibe");
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  const npmPrefix = resolveNpmPrefix();
+  if (npmPrefix) {
+    const candidate = path.join(npmPrefix, "bin", "slacklocalvibe");
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error("slacklocalvibe のグローバル実行ファイルが見つかりません。");
+}
+
+function buildPlist(cliPath) {
+  const logPath = daemonLogPath();
+  const envPath = buildDaemonPathEnv();
+  const nodePath = process.execPath;
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>dev.slacklocalvibe.daemon</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${cliPath}</string>
+    <string>daemon</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>StandardOutPath</key>
+  <string>${logPath}</string>
+  <key>StandardErrorPath</key>
+  <string>${logPath}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${envPath}</string>
+  </dict>
+</dict>
+</plist>`;
+}
+
+module.exports = {
+  installLaunchd,
+  uninstallLaunchd,
+  statusLaunchd,
+  resolveBinaryPath,
+};

package/src/lib/logger.js

@@ -0,0 +1,67 @@
+const fs = require("fs");
+const path = require("path");
+
+const LEVELS = {
+  INFO: "INFO",
+  DEBUG: "DEBUG",
+  STATES: "STATES",
+  SUCCRSS: "SUCCRSS",
+  WARNING: "WARNING",
+  ERROR: "ERROR",
+};
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function createLogger({ filePath, scope }) {
+  ensureDir(path.dirname(filePath));
+
+  function log(level, message, data = {}) {
+    const payload = {
+      ts: new Date().toISOString(),
+      level,
+      scope,
+      message,
+      ...data,
+    };
+    fs.appendFileSync(filePath, `${JSON.stringify(payload)}\n`, "utf8");
+  }
+
+  return {
+    log,
+    LEVELS,
+  };
+}
+
+async function withTiming(log, label, fn, data = {}) {
+  const start = Date.now();
+  try {
+    const result = await fn();
+    log(LEVELS.SUCCRSS, label, { ...data, duration_ms: Date.now() - start });
+    return result;
+  } catch (error) {
+    log(LEVELS.ERROR, label, {
+      ...data,
+      duration_ms: Date.now() - start,
+      error: safeError(error),
+    });
+    throw error;
+  }
+}
+
+function safeError(error) {
+  if (!error) return undefined;
+  return {
+    name: error.name,
+    message: error.message,
+    code: error.code,
+  };
+}
+
+module.exports = {
+  createLogger,
+  withTiming,
+  LEVELS,
+  safeError,
+};

package/src/lib/markdown-to-mrkdwn.js

@@ -0,0 +1,15 @@
+const { marked } = require("marked");
+const htmlToMrkdwn = require("html-to-mrkdwn");
+
+function markdownToMrkdwn(text) {
+  if (!text) return "";
+  const html = marked.parse(text);
+  const result = htmlToMrkdwn(html);
+  if (typeof result === "string") return result;
+  if (result && typeof result.text === "string") return result.text;
+  throw new Error("markdown_to_mrkdwn_invalid_output");
+}
+
+module.exports = {
+  markdownToMrkdwn,
+};

package/src/lib/messages.js

@@ -0,0 +1,58 @@
+function quoteShell(value) {
+  const text = String(value ?? "");
+  if (!text) return "''";
+  if (/^[A-Za-z0-9_./:-]+$/.test(text)) return text;
+  return `'${text.replace(/'/g, "'\\''")}'`;
+}
+
+function buildResumeCommand({ tool, sessionId, cwd }) {
+  const safeSession = quoteShell(sessionId || "");
+  if (tool === "codex") {
+    const parts = [
+      "codex",
+      "exec",
+      "--skip-git-repo-check",
+      "resume",
+      safeSession,
+      "-",
+    ];
+    const command = parts.join(" ");
+    if (cwd) {
+      return `cd ${quoteShell(cwd)} && ${command}`;
+    }
+    return command;
+  }
+  const command = `claude -r ${safeSession}`;
+  if (cwd) {
+    return `cd ${quoteShell(cwd)} && ${command}`;
+  }
+  return command;
+}
+
+function buildReplyReceivedMessage({ tool, sessionId, cwd }) {
+  const resumeCommand = buildResumeCommand({ tool, sessionId, cwd });
+  return [
+    "返信を受領しました。",
+    "これを `resume` として実行しました。結果は新規スレッドが作成されます。",
+    `CLI再開：\`${resumeCommand}\``,
+    "VSCode拡張機能など：ウィンドウ再読込など",
+  ].join("\n");
+}
+
+const REPLY_INVALID_MESSAGE =
+  "この返信は `SlackLocalVibe` の通知スレッドとして認識できませんでした（route 情報が見つからない/不正）。\n" +
+  "**通知（親）メッセージ**に対してスレッド返信してください。\n" +
+  "（補足：このスレッドでは `resume` は実行しません）";
+
+const RESUME_FAILED_MESSAGE =
+  "`resume` の実行に失敗しました。\n" +
+  "詳細はCLIログをご確認ください。";
+
+const TEST_PROMPT = "あなたは誰？";
+
+module.exports = {
+  buildReplyReceivedMessage,
+  REPLY_INVALID_MESSAGE,
+  RESUME_FAILED_MESSAGE,
+  TEST_PROMPT,
+};

package/src/lib/notify-input.js

@@ -0,0 +1,191 @@
+const fs = require("fs");
+
+function parseCodexNotify(rawJson) {
+  const payload = JSON.parse(rawJson);
+  if (payload?.type !== "agent-turn-complete") {
+    return null;
+  }
+  const sessionId = String(payload["thread-id"] || "");
+  const turnId = payload["turn-id"] ? String(payload["turn-id"]) : undefined;
+  const inputMessages = payload["input-messages"];
+  const meta = buildCodexInputMeta(inputMessages);
+  const userText = extractUserTextFromCodex(inputMessages);
+  const assistantText = extractAssistantText(payload["last-assistant-message"]);
+  const cwd = payload?.cwd ? String(payload.cwd) : "";
+
+  return {
+    tool: "codex",
+    session_id: sessionId,
+    turn_id: turnId,
+    cwd,
+    user_text: userText || "（ユーザーメッセージ抽出失敗）",
+    assistant_text: assistantText || "（本文抽出失敗）",
+    meta,
+  };
+}
+
+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_roles: [],
+    input_messages_last_role: "",
+    input_messages_last_type: "",
+    input_messages_last_keys: [],
+    input_messages_last_content_keys: [],
+  };
+  if (Array.isArray(inputMessages) && inputMessages.length > 0) {
+    const roles = [];
+    for (const message of inputMessages) {
+      const role = message?.role;
+      if (role && !roles.includes(role)) {
+        roles.push(role);
+      }
+    }
+    meta.input_messages_roles = roles;
+    const lastMessage = inputMessages[inputMessages.length - 1];
+    meta.input_messages_last_role = lastMessage?.role || "";
+    meta.input_messages_last_type = Array.isArray(lastMessage)
+      ? "array"
+      : typeof lastMessage;
+    if (lastMessage && typeof lastMessage === "object" && !Array.isArray(lastMessage)) {
+      meta.input_messages_last_keys = Object.keys(lastMessage).slice(0, 20);
+      const content = lastMessage.content;
+      if (content && typeof content === "object" && !Array.isArray(content)) {
+        meta.input_messages_last_content_keys = Object.keys(content).slice(0, 20);
+      }
+    }
+  }
+  return meta;
+}
+
+function extractAssistantText(content) {
+  return normalizeContent(content);
+}
+
+function extractTextDeep(value, depth = 0) {
+  if (depth > 6) return "";
+  if (value === null || value === undefined) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => extractTextDeep(item, depth + 1)).join("");
+  }
+  if (typeof value === "object") {
+    const preferredKeys = [
+      "text",
+      "content",
+      "message",
+      "input",
+      "prompt",
+      "input_text",
+      "inputText",
+      "value",
+    ];
+    for (const key of preferredKeys) {
+      if (value[key] !== undefined) {
+        const text = extractTextDeep(value[key], depth + 1);
+        if (text) return text;
+      }
+    }
+    return Object.values(value)
+      .map((item) => extractTextDeep(item, depth + 1))
+      .join("");
+  }
+  return "";
+}
+
+function normalizeContent(content) {
+  return extractTextDeep(content);
+}
+
+function parseClaudeHook(rawJson) {
+  const payload = JSON.parse(rawJson);
+  if (payload?.hook_event_name !== "Stop") {
+    return null;
+  }
+  if (payload?.stop_hook_active === true) {
+    return null;
+  }
+
+  const sessionId = String(payload?.session_id || "");
+  const transcriptPath = payload?.transcript_path;
+  const cwd = payload?.cwd ? String(payload.cwd) : "";
+  let userText = "";
+  let assistantText = "";
+  let transcriptError = "";
+
+  if (transcriptPath) {
+    try {
+      const { lastUser, lastAssistant } = readTranscript(transcriptPath);
+      userText = lastUser || "";
+      assistantText = lastAssistant || "";
+    } catch (error) {
+      transcriptError = error?.message || "transcript_read_failed";
+    }
+  } else {
+    transcriptError = "transcript_path_missing";
+  }
+
+  return {
+    tool: "claude",
+    session_id: sessionId,
+    cwd,
+    user_text: userText || "（ユーザーメッセージ抽出失敗）",
+    assistant_text: assistantText || `（本文抽出エラー: ${transcriptError || "unknown"}）`,
+  };
+}
+
+function readTranscript(filePath) {
+  const content = fs.readFileSync(filePath, "utf8");
+  const lines = content.split("\n").filter(Boolean);
+  let lastUser = "";
+  let lastAssistant = "";
+
+  for (const line of lines) {
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const { role, text } = extractRoleAndText(record);
+    if (!role || !text) continue;
+    if (role === "user") lastUser = text;
+    if (role === "assistant") lastAssistant = text;
+  }
+
+  return { lastUser, lastAssistant };
+}
+
+function extractRoleAndText(record) {
+  if (!record || typeof record !== "object") return {};
+
+  let role = record.role || record.message?.role || record.data?.role || "";
+  if (!role) {
+    if (record.type === "assistant") role = "assistant";
+    if (record.type === "user") role = "user";
+  }
+
+  const content =
+    record.content ||
+    record.message?.content ||
+    record.data?.content ||
+    record.text ||
+    record.message?.text;
+
+  const text = normalizeContent(content);
+  return { role, text };
+}
+
+module.exports = {
+  parseCodexNotify,
+  parseClaudeHook,
+  normalizeContent,
+};