slacklocalvibe 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 2001Y
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,40 @@
+# SlackLocalVibe
+
+Slack DM 通知と「返信 → CLI resume」をつなぐローカルブリッジです。
+Codex / Claude Code の完了通知を Slack に送り、スレッド返信で resume を実行します。
+
+## 必要環境
+
+- Node.js 18+
+- Slack App（Socket Mode）
+
+## インストール
+
+ユーザーが実行するのはこれだけです（初回セットアップ）。
+
+```bash
+npx slacklocalvibe
+```
+
+ウィザード内で `npm i -g slacklocalvibe` を実行し、以降の返信/常駐でグローバルコマンドを使います。
+
+## 使い方
+
+セットアップウィザードを起動します。
+
+```bash
+npx slacklocalvibe
+```
+
+### サブコマンド
+
+- 通知: `slacklocalvibe notify --tool codex|claude`
+- daemon: `slacklocalvibe daemon`
+- launchd: `slacklocalvibe launchd install|uninstall|status`
+
+launchd は **グローバル固定**です。
+
+## 設定・ログ
+
+- 設定: `~/.config/slacklocalvibe/config.json`
+- ログ: `~/Library/Logs/slacklocalvibe/`

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "slacklocalvibe",
+  "version": "0.1.0",
+  "description": "SlackLocalVibe: Codex/Claude Code turn notifications and reply→resume bridge for Slack DM (Socket Mode)",
+  "bin": {
+    "slacklocalvibe": "src/cli.js"
+  },
+  "main": "src/cli.js",
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {},
+  "keywords": [
+    "slack",
+    "cli",
+    "codex",
+    "claude",
+    "socket-mode"
+  ],
+  "author": "2001Y",
+  "license": "MIT",
+  "type": "commonjs",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "@slack/socket-mode": "^2.0.5",
+    "@slack/web-api": "^7.13.0",
+    "commander": "^14.0.2",
+    "html-to-mrkdwn": "^3.0.0",
+    "marked": "^17.0.1",
+    "prompts": "^2.4.2"
+  }
+}

package/src/cli.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+const { Command } = require("commander");
+const { runWizard } = require("./commands/wizard");
+const { runNotify } = require("./commands/notify");
+const { runDaemon } = require("./commands/daemon");
+const { runLaunchd } = require("./commands/launchd");
+
+const program = new Command();
+
+program
+  .name("slacklocalvibe")
+  .description("SlackLocalVibe: Slack DM通知 + 返信resumeブリッジ")
+  .version("0.1.0");
+
+program
+  .command("notify")
+  .argument("[payload]", "notify payload json")
+  .requiredOption("--tool <tool>", "codex | claude")
+  .action(async (_payload, options) => {
+    await runNotify({ tool: options.tool });
+  });
+
+program.command("daemon").action(async () => {
+  await runDaemon();
+});
+
+program
+  .command("launchd")
+  .argument("<action>", "install | uninstall | status")
+  .action(async (action) => {
+    await runLaunchd(action);
+  });
+
+program.action(async () => {
+  await runWizard();
+});
+
+program.parseAsync(process.argv);

package/src/commands/daemon.js

@@ -0,0 +1,289 @@
+const { SocketModeClient } = require("@slack/socket-mode");
+const { randomUUID } = require("crypto");
+const { loadConfig, normalizeConfig, assertDaemonConfig } = require("../lib/config");
+const { createLogger, LEVELS, safeError } = require("../lib/logger");
+const { daemonLogPath, notifyLogPath, wizardLogPath } = require("../lib/paths");
+const { createWebClient, postThreadMessage } = require("../lib/slack");
+const { findRoute } = require("../lib/route-store");
+const {
+  buildReplyReceivedMessage,
+  REPLY_INVALID_MESSAGE,
+  RESUME_FAILED_MESSAGE,
+} = require("../lib/messages");
+const { runCodexResume, runClaudeResume } = require("../lib/resume");
+
+function formatErrorHead(text) {
+  if (!text) return "";
+  const trimmed = String(text).replace(/\s+$/g, "").trim();
+  if (!trimmed) return "";
+  const firstLine = trimmed.split(/\r?\n/)[0].trim();
+  if (!firstLine) return "";
+  if (firstLine.length > 200) {
+    return `${firstLine.slice(0, 200)}...`;
+  }
+  return firstLine;
+}
+
+function buildResumeFailedMessage(result) {
+  const detail = formatErrorHead(result?.stderrHead || result?.stdoutHead || "");
+  if (detail) {
+    return `${RESUME_FAILED_MESSAGE}\nエラー: ${detail}`;
+  }
+  if (result?.code !== undefined && result?.code !== null) {
+    return `${RESUME_FAILED_MESSAGE}\nエラーコード: ${result.code}`;
+  }
+  return RESUME_FAILED_MESSAGE;
+}
+
+async function runDaemon() {
+  const { log } = createLogger({ filePath: daemonLogPath(), scope: "daemon" });
+  log(LEVELS.INFO, "daemon.start");
+  log(LEVELS.INFO, "daemon.runtime", {
+    argv: process.argv,
+    exec_path: process.execPath,
+    cwd: process.cwd(),
+    node: process.version,
+  });
+
+  let config;
+  try {
+    config = loadConfig();
+  } catch (error) {
+    log(LEVELS.ERROR, "daemon.config_parse_failed", { error: safeError(error) });
+    process.exitCode = 1;
+    return;
+  }
+  if (!config) {
+    log(LEVELS.ERROR, "daemon.config_missing");
+    process.exitCode = 1;
+    return;
+  }
+  config = normalizeConfig(config);
+
+  try {
+    assertDaemonConfig(config);
+  } catch (error) {
+    log(LEVELS.ERROR, "daemon.config_invalid", { error: safeError(error) });
+    process.exitCode = 1;
+    return;
+  }
+
+  const webClient = createWebClient(config.slack.bot_token);
+  const socketClient = new SocketModeClient({
+    appToken: config.slack.app_token,
+    client: webClient,
+  });
+
+  socketClient.on("error", (error) => {
+    log(LEVELS.ERROR, "daemon.socket_error", { error: safeError(error) });
+  });
+
+  socketClient.on("connected", () => {
+    log(LEVELS.SUCCRSS, "daemon.socket_connected");
+  });
+
+  socketClient.on("message", async ({ event, body, ack }) => {
+    const correlationId = randomUUID();
+    const startedAt = Date.now();
+
+    try {
+      await ack();
+      log(LEVELS.SUCCRSS, "daemon.ack", {
+        correlation_id: correlationId,
+        envelope_id: body?.envelope_id,
+      });
+    } catch (error) {
+      log(LEVELS.WARNING, "daemon.ack_failed", {
+        correlation_id: correlationId,
+        error: safeError(error),
+      });
+    }
+
+    handleMessageEvent({
+      event,
+      body,
+      log,
+      config,
+      webClient,
+      correlationId,
+      startedAt,
+    }).catch((error) => {
+      log(LEVELS.ERROR, "daemon.event_error", {
+        correlation_id: correlationId,
+        error: safeError(error),
+      });
+    });
+  });
+
+  await socketClient.start();
+}
+
+async function handleMessageEvent({
+  event,
+  body,
+  log,
+  config,
+  webClient,
+  correlationId,
+  startedAt,
+}) {
+  const skipReason = shouldSkipEvent(event);
+  if (skipReason) {
+    log(LEVELS.DEBUG, "daemon.skip_event", {
+      correlation_id: correlationId,
+      reason: skipReason,
+    });
+    return;
+  }
+
+  const text = event.text || "";
+  if (!text.trim()) {
+    log(LEVELS.DEBUG, "daemon.skip_empty", { correlation_id: correlationId });
+    return;
+  }
+
+  const routeEntry = findRoute({
+    channel: event.channel,
+    threadTs: event.thread_ts,
+  });
+
+  if (!routeEntry) {
+    await safeThreadReply({
+      log,
+      webClient,
+      channel: event.channel,
+      threadTs: event.thread_ts,
+      text: appendLogLocations(REPLY_INVALID_MESSAGE),
+      correlationId,
+      label: "daemon.reply_invalid",
+    });
+    log(LEVELS.WARNING, "daemon.route_invalid", {
+      correlation_id: correlationId,
+      reason: "route_missing",
+    });
+    return;
+  }
+
+  const replyMessage = buildReplyReceivedMessage({
+    tool: routeEntry.tool,
+    sessionId: routeEntry.session_id,
+    cwd: routeEntry.cwd || "",
+  });
+
+  log(LEVELS.STATES, "daemon.reply_payload", {
+    correlation_id: correlationId,
+    tool: routeEntry.tool,
+    session_id: routeEntry.session_id,
+    cwd: routeEntry.cwd || "",
+    text: replyMessage,
+    text_len: replyMessage.length,
+  });
+
+  await safeThreadReply({
+    log,
+    webClient,
+    channel: event.channel,
+    threadTs: event.thread_ts,
+    text: replyMessage,
+    correlationId,
+    label: "daemon.reply_received",
+  });
+
+  let result;
+  if (routeEntry.tool === "codex") {
+    result = await runCodexResume({
+      sessionId: routeEntry.session_id,
+      prompt: text,
+      cwd: routeEntry.cwd || "",
+    });
+  } else {
+    result = await runClaudeResume({
+      sessionId: routeEntry.session_id,
+      prompt: text,
+      cwd: routeEntry.cwd || "",
+    });
+  }
+
+  log(LEVELS.STATES, "daemon.resume_result", {
+    correlation_id: correlationId,
+    tool: routeEntry.tool,
+    exit_code: result?.code,
+    signal: result?.signal,
+    stdout_len: result?.stdoutLen,
+    stderr_len: result?.stderrLen,
+    stdout_head: formatErrorHead(result?.stdoutHead),
+    stderr_head: formatErrorHead(result?.stderrHead),
+  });
+
+  if (result?.code !== 0) {
+    await safeThreadReply({
+      log,
+      webClient,
+      channel: event.channel,
+      threadTs: event.thread_ts,
+      text: appendLogLocations(buildResumeFailedMessage(result)),
+      correlationId,
+      label: "daemon.reply_failed",
+    });
+  }
+
+  log(LEVELS.SUCCRSS, "daemon.event_done", {
+    correlation_id: correlationId,
+    duration_ms: Date.now() - startedAt,
+    input_len: text.length,
+  });
+}
+
+function shouldSkipEvent(event) {
+  if (!event) return "event_missing";
+  if (event.subtype) return "subtype";
+  if (event.bot_id || event.bot_profile) return "bot_message";
+  if (event.channel_type && event.channel_type !== "im") return "not_im";
+  if (!event.thread_ts) return "no_thread";
+  if (event.thread_ts === event.ts) return "not_reply";
+  return "";
+}
+
+function appendLogLocations(text) {
+  return `${text}\n\n${buildLogLocationsMessage()}`;
+}
+
+function buildLogLocationsMessage() {
+  return [
+    "ログの場所:",
+    `- notify: ${notifyLogPath()}`,
+    `- daemon: ${daemonLogPath()}`,
+    `- wizard: ${wizardLogPath()}`,
+  ].join("\n");
+}
+
+async function safeThreadReply({
+  log,
+  webClient,
+  channel,
+  threadTs,
+  text,
+  correlationId,
+  label,
+}) {
+  try {
+    await postThreadMessage({
+      client: webClient,
+      log,
+      channel,
+      threadTs,
+      text,
+    });
+    log(LEVELS.SUCCRSS, label, { correlation_id: correlationId });
+  } catch (error) {
+    log(LEVELS.ERROR, `${label}_failed`, {
+      correlation_id: correlationId,
+      error: safeError(error),
+    });
+    throw error;
+  }
+}
+
+module.exports = {
+  runDaemon,
+};

package/src/commands/launchd.js

@@ -0,0 +1,46 @@
+const { createLogger, LEVELS, safeError } = require("../lib/logger");
+const { daemonLogPath } = require("../lib/paths");
+const {
+  installLaunchd,
+  uninstallLaunchd,
+  statusLaunchd,
+} = require("../lib/launchd");
+
+async function runLaunchd(action) {
+  const { log } = createLogger({ filePath: daemonLogPath(), scope: "launchd" });
+  if (action === "install") {
+    try {
+      const result = installLaunchd();
+      log(LEVELS.SUCCRSS, "launchd.install_ok", result);
+    } catch (error) {
+      log(LEVELS.ERROR, "launchd.install_failed", { error: safeError(error) });
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (action === "uninstall") {
+    try {
+      const result = uninstallLaunchd();
+      log(LEVELS.SUCCRSS, "launchd.uninstall_ok", result);
+    } catch (error) {
+      log(LEVELS.ERROR, "launchd.uninstall_failed", { error: safeError(error) });
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (action === "status") {
+    const result = statusLaunchd();
+    if (result.status !== 0) {
+      log(LEVELS.WARNING, "launchd.status_not_installed");
+      process.exitCode = 1;
+    } else {
+      log(LEVELS.SUCCRSS, "launchd.status_ok");
+    }
+    return;
+  }
+  log(LEVELS.ERROR, "launchd.unknown_action", { action });
+  process.exitCode = 1;
+}
+module.exports = {
+  runLaunchd,
+};