slacklocalvibe 0.1.0

package/src/lib/paths.js

@@ -0,0 +1,88 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { spawnSync } = require("child_process");
+
+function homeDir() {
+  return os.homedir();
+}
+
+function configDir() {
+  return path.join(homeDir(), ".config", "slacklocalvibe");
+}
+
+function configPath() {
+  return path.join(configDir(), "config.json");
+}
+
+function routesPath() {
+  return path.join(configDir(), "routes.jsonl");
+}
+
+function logsDir() {
+  return path.join(homeDir(), "Library", "Logs", "slacklocalvibe");
+}
+
+function notifyLogPath() {
+  return path.join(logsDir(), "notify.log");
+}
+
+function daemonLogPath() {
+  return path.join(logsDir(), "daemon.log");
+}
+
+function wizardLogPath() {
+  return path.join(logsDir(), "wizard.log");
+}
+
+function launchAgentsDir() {
+  return path.join(homeDir(), "Library", "LaunchAgents");
+}
+
+function launchdPlistPath() {
+  return path.join(launchAgentsDir(), "dev.slacklocalvibe.daemon.plist");
+}
+
+function defaultPathEnv() {
+  return process.env.PATH || "";
+}
+
+module.exports = {
+  homeDir,
+  configDir,
+  configPath,
+  routesPath,
+  logsDir,
+  notifyLogPath,
+  daemonLogPath,
+  wizardLogPath,
+  launchAgentsDir,
+  launchdPlistPath,
+  defaultPathEnv,
+  resolveCommandPathStrict,
+};
+
+function resolveCommandPathStrict(command, { allowNpx = false, optional = false } = {}) {
+  const pathEnv = process.env.PATH || "";
+  const result = spawnSync("command", ["-v", command], {
+    encoding: "utf8",
+    shell: false,
+    env: { ...process.env, PATH: pathEnv },
+  });
+  if (result.status !== 0) {
+    if (optional) return "";
+    const err = new Error(`コマンドが見つかりません: ${command}`);
+    err.detail = (result.stderr || "").toString("utf8").trim();
+    throw err;
+  }
+  const resolved = (result.stdout || "").toString("utf8").trim();
+  if (!resolved) {
+    if (optional) return "";
+    throw new Error(`コマンドのパス解決に失敗しました: ${command}`);
+  }
+  if (!allowNpx && resolved.includes("/.npm/_npx/")) {
+    if (optional) return "";
+    throw new Error(`npx 由来のパスは許可しません: ${resolved}`);
+  }
+  return resolved;
+}

package/src/lib/resume.js

@@ -0,0 +1,86 @@
+const { spawn } = require("child_process");
+const { defaultPathEnv, resolveCommandPathStrict } = require("./paths");
+
+function normalizeClaudePrompt(text) {
+  const normalized = (text || "").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  return normalized.replace(/\n/g, "\\n");
+}
+
+function runCommand({ command, args, input, env, cwd }) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, PATH: defaultPathEnv(), ...env },
+      cwd,
+    });
+    let stdoutLen = 0;
+    let stderrLen = 0;
+    let stdoutHead = "";
+    let stderrHead = "";
+    const MAX_HEAD = 400;
+    child.stdout.on("data", (chunk) => {
+      stdoutLen += chunk.length;
+      if (stdoutHead.length < MAX_HEAD) {
+        stdoutHead += chunk.toString("utf8");
+        if (stdoutHead.length > MAX_HEAD) {
+          stdoutHead = stdoutHead.slice(0, MAX_HEAD);
+        }
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrLen += chunk.length;
+      if (stderrHead.length < MAX_HEAD) {
+        stderrHead += chunk.toString("utf8");
+        if (stderrHead.length > MAX_HEAD) {
+          stderrHead = stderrHead.slice(0, MAX_HEAD);
+        }
+      }
+    });
+    child.on("error", (error) => reject(error));
+    child.on("close", (code, signal) => {
+      resolve({
+        code,
+        signal,
+        stdoutLen,
+        stderrLen,
+        stdoutHead,
+        stderrHead,
+      });
+    });
+    if (input) {
+      child.stdin.write(input);
+    }
+    child.stdin.end();
+  });
+}
+
+async function runCodexResume({ sessionId, prompt, cwd }) {
+  const codexPath = resolveCommandPathStrict("codex");
+  const args = ["exec", "--skip-git-repo-check"];
+  if (cwd) {
+    args.push("--cd", cwd);
+  }
+  args.push("resume", sessionId, "-");
+  return runCommand({
+    command: codexPath,
+    args,
+    input: prompt || "",
+    cwd: cwd || undefined,
+  });
+}
+
+async function runClaudeResume({ sessionId, prompt, cwd }) {
+  const normalized = normalizeClaudePrompt(prompt || "");
+  const claudePath = resolveCommandPathStrict("claude");
+  return runCommand({
+    command: claudePath,
+    args: ["-r", sessionId, normalized],
+    cwd: cwd || undefined,
+  });
+}
+
+module.exports = {
+  runCodexResume,
+  runClaudeResume,
+  normalizeClaudePrompt,
+};

package/src/lib/route-store.js

@@ -0,0 +1,60 @@
+const fs = require("fs");
+const path = require("path");
+const { routesPath } = require("./paths");
+
+const MAX_ROUTES_BYTES = 1024 * 1024;
+const MAX_ROUTES_LINES = 2000;
+
+function recordRoute({ channel, threadTs, tool, sessionId, turnId, cwd }) {
+  const filePath = routesPath();
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const entry = {
+    ts: new Date().toISOString(),
+    channel,
+    thread_ts: threadTs,
+    tool,
+    session_id: sessionId,
+    turn_id: turnId || "",
+    cwd: cwd || "",
+  };
+  fs.appendFileSync(filePath, `${JSON.stringify(entry)}\n`, "utf8");
+  pruneRoutesIfNeeded(filePath);
+}
+
+function findRoute({ channel, threadTs }) {
+  const filePath = routesPath();
+  if (!fs.existsSync(filePath)) return null;
+  const content = fs.readFileSync(filePath, "utf8");
+  const lines = content.split("\n").filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    const line = lines[i];
+    try {
+      const entry = JSON.parse(line);
+      if (entry.channel === channel && entry.thread_ts === threadTs) {
+        return entry;
+      }
+    } catch {
+      // skip invalid line
+    }
+  }
+  return null;
+}
+
+function pruneRoutesIfNeeded(filePath) {
+  try {
+    const stat = fs.statSync(filePath);
+    if (stat.size <= MAX_ROUTES_BYTES) return;
+    const content = fs.readFileSync(filePath, "utf8");
+    const lines = content.split("\n").filter(Boolean);
+    const kept = lines.slice(-MAX_ROUTES_LINES);
+    fs.writeFileSync(filePath, `${kept.join("\n")}\n`, "utf8");
+  } catch {
+    // ignore prune errors
+  }
+}
+
+module.exports = {
+  recordRoute,
+  findRoute,
+};

package/src/lib/slack.js

@@ -0,0 +1,140 @@
+const { WebClient } = require("@slack/web-api");
+const { withTiming, LEVELS, safeError } = require("./logger");
+
+const MAX_RETRIES = 2;
+
+function createWebClient(token) {
+  return new WebClient(token);
+}
+
+async function slackApiCall(log, label, fn) {
+  let lastError;
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt += 1) {
+    try {
+      log(LEVELS.DEBUG, `${label}:call`, { attempt });
+      const result = await fn();
+      if (result?.ok === false) {
+        const err = new Error(result.error || "Slack API error");
+        err.code = result.error;
+        throw err;
+      }
+      log(LEVELS.SUCCRSS, `${label}:ok`, { attempt });
+      return result;
+    } catch (error) {
+      lastError = error;
+      log(LEVELS.WARNING, `${label}:retry`, {
+        attempt,
+        error: safeError(error),
+      });
+    }
+  }
+  throw lastError;
+}
+
+async function openDmChannel({ client, userId, log }) {
+  return withTiming(log, "slack.conversations.open", async () => {
+    const response = await slackApiCall(log, "conversations.open", () =>
+      client.conversations.open({ users: userId })
+    );
+    return response.channel?.id;
+  });
+}
+
+function logSlackMessage(log, label, payload) {
+  log(LEVELS.STATES, label, payload);
+}
+
+async function postParentMessage({ client, log, channel, text, metadata }) {
+  logSlackMessage(log, "slack.chat.postMessage.parent.request", {
+    channel,
+    text,
+    text_len: text?.length || 0,
+    has_metadata: Boolean(metadata),
+  });
+  return withTiming(log, "slack.chat.postMessage.parent", async () => {
+    const payload = {
+      channel,
+      text,
+    };
+    if (metadata) {
+      payload.metadata = metadata;
+    }
+    const response = await slackApiCall(log, "chat.postMessage.parent", () =>
+      client.chat.postMessage(payload)
+    );
+    logSlackMessage(log, "slack.chat.postMessage.parent.response", {
+      channel,
+      ts: response.ts,
+    });
+    return response.ts;
+  });
+}
+
+async function postMessage({ client, log, channel, text }) {
+  logSlackMessage(log, "slack.chat.postMessage.simple.request", {
+    channel,
+    text,
+    text_len: text?.length || 0,
+  });
+  return withTiming(log, "slack.chat.postMessage.simple", async () => {
+    const response = await slackApiCall(log, "chat.postMessage.simple", () =>
+      client.chat.postMessage({
+        channel,
+        text,
+      })
+    );
+    logSlackMessage(log, "slack.chat.postMessage.simple.response", {
+      channel,
+      ts: response.ts,
+    });
+    return response.ts;
+  });
+}
+
+async function postThreadMessage({ client, log, channel, threadTs, text }) {
+  logSlackMessage(log, "slack.chat.postMessage.thread.request", {
+    channel,
+    thread_ts: threadTs,
+    text,
+    text_len: text?.length || 0,
+  });
+  return withTiming(log, "slack.chat.postMessage.thread", async () => {
+    const response = await slackApiCall(log, "chat.postMessage.thread", () =>
+      client.chat.postMessage({
+        channel,
+        thread_ts: threadTs,
+        text,
+      })
+    );
+    logSlackMessage(log, "slack.chat.postMessage.thread.response", {
+      channel,
+      thread_ts: threadTs,
+      ts: response.ts,
+    });
+    return response.ts;
+  });
+}
+
+async function fetchParentMessage({ client, log, channel, threadTs }) {
+  return withTiming(log, "slack.conversations.history", async () => {
+    const response = await slackApiCall(log, "conversations.history", () =>
+      client.conversations.history({
+        channel,
+        latest: threadTs,
+        inclusive: true,
+        limit: 1,
+        include_all_metadata: true,
+      })
+    );
+    return response.messages?.[0];
+  });
+}
+
+module.exports = {
+  createWebClient,
+  openDmChannel,
+  postMessage,
+  postParentMessage,
+  postThreadMessage,
+  fetchParentMessage,
+};

package/src/lib/text.js

@@ -0,0 +1,62 @@
+const MAX_TEXT = 3800;
+
+function splitText(text, maxLen = MAX_TEXT) {
+  if (!text) return [""];
+  if (text.length <= maxLen) return [text];
+
+  const chunks = [];
+  let remaining = text;
+
+  while (remaining.length > maxLen) {
+    let slice = safeSlice(remaining, maxLen);
+    let cutIndex = findCutIndex(slice);
+    if (cutIndex <= 0 || cutIndex > slice.length) {
+      cutIndex = slice.length;
+    }
+    chunks.push(remaining.slice(0, cutIndex));
+    remaining = remaining.slice(cutIndex);
+  }
+
+  if (remaining.length > 0) {
+    chunks.push(remaining);
+  }
+
+  return chunks;
+}
+
+function findCutIndex(slice) {
+  const boundaries = ["\n\n", "\n", " "];
+  for (const boundary of boundaries) {
+    const idx = slice.lastIndexOf(boundary);
+    if (idx > 0) {
+      return idx + boundary.length;
+    }
+  }
+  return slice.length;
+}
+
+function safeSlice(text, maxLen) {
+  let slice = text.slice(0, maxLen);
+  if (slice.length === 0) return slice;
+  const lastChar = slice.charCodeAt(slice.length - 1);
+  if (lastChar >= 0xd800 && lastChar <= 0xdbff) {
+    slice = slice.slice(0, -1);
+  }
+  return slice;
+}
+
+function numberedChunks(text, maxLen = MAX_TEXT) {
+  const tempChunks = splitText(text, maxLen);
+  if (tempChunks.length <= 1) return tempChunks;
+
+  const total = tempChunks.length;
+  const prefixLen = `(${total}/${total}) `.length;
+  const chunks = splitText(text, maxLen - prefixLen);
+  return chunks.map((chunk, index) => `(${index + 1}/${chunks.length}) ${chunk}`);
+}
+
+module.exports = {
+  MAX_TEXT,
+  splitText,
+  numberedChunks,
+};

package/src/lib/user-config.js

@@ -0,0 +1,90 @@
+const fs = require("fs");
+const path = require("path");
+const toml = require("@iarna/toml");
+const { backupFileIfExists } = require("./config");
+const { homeDir } = require("./paths");
+
+const CODEX_NOTIFY_COMMAND = [
+  "slacklocalvibe",
+  "notify",
+  "--tool",
+  "codex",
+];
+
+const CLAUDE_NOTIFY_COMMAND = "slacklocalvibe notify --tool claude";
+
+function codexConfigPath() {
+  const base = process.env.CODEX_HOME || path.join(homeDir(), ".codex");
+  return path.join(base, "config.toml");
+}
+
+function claudeSettingsPath() {
+  return path.join(homeDir(), ".claude", "settings.json");
+}
+
+function updateCodexNotify() {
+  const filePath = codexConfigPath();
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Codex設定ファイルが見つかりません: ${filePath}`);
+  }
+  const raw = fs.readFileSync(filePath, "utf8");
+  const parsed = toml.parse(raw);
+  parsed.notify = CODEX_NOTIFY_COMMAND;
+  backupFileIfExists(filePath);
+  fs.writeFileSync(filePath, toml.stringify(parsed), "utf8");
+}
+
+function updateClaudeStopHook() {
+  const filePath = claudeSettingsPath();
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Claude設定ファイルが見つかりません: ${filePath}`);
+  }
+  const raw = fs.readFileSync(filePath, "utf8");
+  const parsed = JSON.parse(raw);
+  if (parsed.hooks && typeof parsed.hooks !== "object") {
+    throw new Error("Claude settings.json の hooks が不正な型です。");
+  }
+  parsed.hooks = parsed.hooks || {};
+
+  const stopHooks = parsed.hooks.Stop;
+  if (stopHooks && !Array.isArray(stopHooks)) {
+    throw new Error("Claude settings.json の hooks.Stop が配列ではありません。");
+  }
+
+  const newHook = { type: "command", command: CLAUDE_NOTIFY_COMMAND };
+
+  if (!Array.isArray(parsed.hooks.Stop) || parsed.hooks.Stop.length === 0) {
+    parsed.hooks.Stop = [{ hooks: [newHook] }];
+  } else {
+    let inserted = false;
+    for (const pipeline of parsed.hooks.Stop) {
+      if (!pipeline || typeof pipeline !== "object") continue;
+      if (!Array.isArray(pipeline.hooks)) {
+        pipeline.hooks = [];
+      }
+      const exists = pipeline.hooks.some(
+        (hook) => hook?.type === "command" && hook?.command === CLAUDE_NOTIFY_COMMAND
+      );
+      if (!exists) {
+        pipeline.hooks.push(newHook);
+      }
+      inserted = true;
+      break;
+    }
+    if (!inserted) {
+      parsed.hooks.Stop.push({ hooks: [newHook] });
+    }
+  }
+
+  backupFileIfExists(filePath);
+  fs.writeFileSync(filePath, JSON.stringify(parsed, null, 2), "utf8");
+}
+
+module.exports = {
+  CODEX_NOTIFY_COMMAND,
+  CLAUDE_NOTIFY_COMMAND,
+  codexConfigPath,
+  claudeSettingsPath,
+  updateCodexNotify,
+  updateClaudeStopHook,
+};