custie 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 FlyCoder
+
+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,107 @@
+<p align="center">
+  <img src="custie.png" alt="Custie" width="240" />
+</p>
+
+# Custie
+
+**Claude Code, inside your Slack.** Your team gets an AI that can read your codebase, edit files, run commands, and use every Claude Code skill -- all from a Slack thread.
+
+## Why Custie?
+
+Claude Code is powerful, but it lives in your terminal. Custie brings the **full Claude Code experience** into Slack:
+
+- **Ask about your codebase** -- `@custie what does the auth middleware do?`
+- **Make changes** -- `@custie add input validation to the signup endpoint`
+- **Run commands** -- `@custie run the test suite and fix any failures`
+- **Use skills & MCP servers** -- everything Claude Code can do, your bot can do
+
+Sessions persist across messages. Start a conversation in a thread, come back hours later, and pick up right where you left off.
+
+<p align="center">
+  <img src="how.png" alt="Custie in action" width="480" />
+</p>
+
+## How It Works
+
+Custie runs on your machine (or server) and connects to Slack via **Socket Mode** -- no webhooks, no tunnels, no public URLs. When someone mentions the bot, it spawns a real Claude Code process with full access to your project.
+
+```
+@custie in Slack  -->  Custie server  -->  Claude Code CLI  -->  your codebase
+```
+
+## Get Started
+
+```bash
+npm install -g @anthropic-ai/claude-code   # prerequisite
+npm install -g custie                       # install custie
+custie setup                                # configure Slack app + tokens
+custie start                                # run the bot
+```
+
+That's it. Go to Slack and `@custie hello`.
+
+> **Want it always running?** Run `custie install` to set up a background service (launchd on macOS, systemd on Linux).
+
+## Customise Your Bot
+
+**System prompt** -- Define your bot's personality and behaviour:
+
+```bash
+custie prompt    # opens ~/.config/custie/prompt.md in your editor
+```
+
+**Access control** -- By default, only the owner can use the bot (it runs with full filesystem access). Add trusted user IDs to open it up:
+
+```bash
+custie config --edit
+```
+
+## CLI Reference
+
+| Command | What it does |
+|---|---|
+| `custie setup` | Automated setup via Playwright (falls back to manual) |
+| `custie setup --manual` | Manual setup (paste tokens yourself) |
+| `custie start` | Run the bot (foreground) |
+| `custie install` | Install as background service |
+| `custie uninstall` | Remove background service |
+| `custie prompt` | Edit system prompt |
+| `custie config` | Show current config |
+| `custie config --edit` | Edit config file |
+
+## Configuration
+
+All config lives in `~/.config/custie/`:
+
+| File | Purpose |
+|---|---|
+| `config.env` | Slack tokens, working directory, access control |
+| `prompt.md` | System prompt (bot personality & instructions) |
+
+| Variable | Required | Description |
+|---|---|---|
+| `SLACK_BOT_TOKEN` | Yes | Bot User OAuth Token (`xoxb-...`) |
+| `SLACK_APP_TOKEN` | Yes | App-Level Token (`xapp-...`) |
+| `SLACK_SIGNING_SECRET` | Yes | From Slack app Basic Information |
+| `CLAUDE_CWD` | No | Working directory for Claude |
+| `BOT_NAME` | No | Display name (default: Custie) |
+| `OWNER_USER_ID` | No | Your Slack user ID |
+| `ALLOWED_USER_IDS` | No | Who can use the bot (defaults to owner) |
+
+## Development
+
+```bash
+git clone <repo-url> && cd custie
+pnpm install
+pnpm run dev       # hot-reload
+pnpm run build     # compile
+pnpm run lint      # oxlint
+```
+
+## Architecture
+
+![Architecture](architecture.svg)
+
+## Licence
+
+MIT

package/dist/chunk-55T4S4ZY.js

@@ -0,0 +1,521 @@
+#!/usr/bin/env node
+
+// src/config.ts
+import dotenv from "dotenv";
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/paths.ts
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+var home = homedir();
+var XDG_CONFIG_HOME = process.env["XDG_CONFIG_HOME"] || join(home, ".config");
+var XDG_DATA_HOME = process.env["XDG_DATA_HOME"] || join(home, ".local", "share");
+var paths = {
+  CONFIG_DIR: join(XDG_CONFIG_HOME, "custie"),
+  DATA_DIR: join(XDG_DATA_HOME, "custie"),
+  get CONFIG_FILE() {
+    return join(this.CONFIG_DIR, "config.env");
+  },
+  get PROMPT_FILE() {
+    return join(this.CONFIG_DIR, "prompt.md");
+  },
+  get DB_FILE() {
+    return join(this.DATA_DIR, "custie.db");
+  },
+  get LOG_DIR() {
+    return join(this.DATA_DIR, "logs");
+  },
+  PACKAGE_ROOT: resolve(import.meta.dirname, "..")
+};
+function ensureDirs() {
+  for (const dir of [paths.CONFIG_DIR, paths.DATA_DIR, paths.LOG_DIR]) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+
+// src/config.ts
+function loadEnvFiles() {
+  if (existsSync2(paths.CONFIG_FILE)) {
+    dotenv.config({ path: paths.CONFIG_FILE, override: false });
+  }
+  const repoEnv = resolve2(process.cwd(), ".env");
+  if (existsSync2(repoEnv)) {
+    dotenv.config({ path: repoEnv, override: false });
+  }
+}
+function requireEnv(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
+}
+function loadConfig() {
+  const ownerUserId = process.env["OWNER_USER_ID"] || void 0;
+  const allowedUserIds = new Set(
+    (process.env["ALLOWED_USER_IDS"] ?? "").split(",").map((s) => s.trim()).filter(Boolean)
+  );
+  if (ownerUserId && allowedUserIds.size > 0) {
+    allowedUserIds.add(ownerUserId);
+  }
+  return {
+    slackBotToken: requireEnv("SLACK_BOT_TOKEN"),
+    slackAppToken: requireEnv("SLACK_APP_TOKEN"),
+    slackSigningSecret: requireEnv("SLACK_SIGNING_SECRET"),
+    claudeCwd: process.env["CLAUDE_CWD"] ?? process.cwd(),
+    claudeConfigDir: process.env["CLAUDE_CONFIG_DIR"] || void 0,
+    botName: process.env["BOT_NAME"] ?? "Custie",
+    allowedUserIds,
+    maxTurns: parseInt(process.env["MAX_TURNS"] ?? "10", 10),
+    ownerUserId
+  };
+}
+
+// src/slack/app.ts
+import { App } from "@slack/bolt";
+function createSlackApp(config) {
+  return new App({
+    token: config.slackBotToken,
+    appToken: config.slackAppToken,
+    signingSecret: config.slackSigningSecret,
+    socketMode: true
+  });
+}
+
+// src/claude/agent.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { resolve as resolve3 } from "path";
+var debug = process.env["DEBUG"] === "true";
+function loadSystemPrompt() {
+  const customPath = paths.PROMPT_FILE;
+  const defaultPath = resolve3(paths.PACKAGE_ROOT, "system.default.md");
+  const filePath = existsSync3(customPath) ? customPath : defaultPath;
+  return readFileSync(filePath, "utf-8").trim();
+}
+function buildSystemPrompt(botName) {
+  return loadSystemPrompt().replaceAll("{{botName}}", botName);
+}
+function buildArgs(prompt, botName, resumeSessionId) {
+  const args = [
+    "--print",
+    "--output-format",
+    "json",
+    "--dangerously-skip-permissions",
+    "--no-chrome",
+    "--append-system-prompt",
+    buildSystemPrompt(botName),
+    "--setting-sources",
+    "user,project,local"
+  ];
+  if (resumeSessionId) {
+    args.push("--resume", resumeSessionId);
+  }
+  args.push(prompt);
+  return args;
+}
+function runCli(prompt, cwd, botName, claudeConfigDir, resumeSessionId) {
+  return new Promise((resolve4, reject) => {
+    const args = buildArgs(prompt, botName, resumeSessionId);
+    const env = { ...process.env };
+    if (claudeConfigDir) {
+      env["CLAUDE_CONFIG_DIR"] = claudeConfigDir;
+    }
+    if (debug) {
+      console.log(`[agent] spawning claude CLI in ${cwd}`);
+      console.log(`[agent] args: ${args.join(" ")}`);
+    }
+    const child = spawn("claude", args, {
+      cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    child.stdin.end();
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("error", (err) => {
+      reject(new Error(`Failed to spawn claude CLI: ${err.message}`));
+    });
+    child.on("close", (code) => {
+      if (debug && stderr) {
+        console.log(`[agent] stderr: ${stderr.trim()}`);
+      }
+      if (code !== 0 && !stdout.trim()) {
+        reject(new Error(`claude CLI exited with code ${code}: ${stderr.trim()}`));
+        return;
+      }
+      try {
+        const result = JSON.parse(stdout.trim());
+        const sessionId = result.session_id ?? resumeSessionId ?? "";
+        if (result.type === "result" && result.subtype === "success") {
+          resolve4({ sessionId, text: result.result ?? "" });
+          return;
+        }
+        if (debug) console.log(`[agent] error result:`, JSON.stringify(result));
+        if (result.subtype === "error_max_turns") {
+          resolve4({
+            sessionId,
+            text: `That query was a bit too complex for me to handle here. You can continue this session directly:
+\`claude --resume ${sessionId}\``
+          });
+          return;
+        }
+        const errors = (result.errors ?? []).filter(Boolean).join(", ") || "Unknown error";
+        resolve4({ sessionId, text: `Error: ${errors}` });
+      } catch {
+        resolve4({ sessionId: resumeSessionId ?? "", text: stdout.trim() || "No response" });
+      }
+    });
+  });
+}
+async function askClaude(prompt, cwd, botName, _maxTurns, claudeConfigDir, resumeSessionId) {
+  try {
+    return await runCli(prompt, cwd, botName, claudeConfigDir, resumeSessionId);
+  } catch (err) {
+    if (resumeSessionId) {
+      if (debug) console.log(`[agent] session resume failed, starting fresh session`);
+      return await runCli(prompt, cwd, botName, claudeConfigDir);
+    }
+    throw err;
+  }
+}
+
+// src/queue/message-queue.ts
+var MessageQueue = class {
+  chains = /* @__PURE__ */ new Map();
+  enqueue(threadKey, task) {
+    const prev = this.chains.get(threadKey) ?? Promise.resolve();
+    const next = prev.then(task).catch((err) => {
+      console.error(`[queue] Error processing ${threadKey}:`, err);
+    });
+    this.chains.set(threadKey, next);
+  }
+};
+
+// src/slack/formatters.ts
+var SLACK_MAX_LENGTH = 2900;
+function toSlackMarkdown(text) {
+  let result = text;
+  result = result.replace(/```\w*\n/g, "```\n");
+  result = result.replace(/\*\*(.+?)\*\*/g, "*$1*");
+  result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "<$2|$1>");
+  result = result.replace(/^#{1,6}\s+(.+)$/gm, "*$1*");
+  return result;
+}
+function splitMessage(text) {
+  if (text.length <= SLACK_MAX_LENGTH) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= SLACK_MAX_LENGTH) {
+      chunks.push(remaining);
+      break;
+    }
+    let splitAt = remaining.lastIndexOf("\n", SLACK_MAX_LENGTH);
+    if (splitAt < SLACK_MAX_LENGTH / 2) {
+      splitAt = remaining.lastIndexOf(" ", SLACK_MAX_LENGTH);
+    }
+    if (splitAt < SLACK_MAX_LENGTH / 2) {
+      splitAt = SLACK_MAX_LENGTH;
+    }
+    chunks.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt).trimStart();
+  }
+  return chunks;
+}
+
+// src/slack/listeners.ts
+var REJECT_MESSAGES = [
+  "Sorry, I'm a personal assistant and only respond to my owner. :bow:",
+  "I appreciate the interest, but I'm exclusively dedicated to my owner. :lock:",
+  "Flattered you'd ask, but I'm a one-person bot. :robot_face:",
+  "I'm on a strict guest list, and you're not on it \u2014 yet! :clipboard:",
+  "My owner keeps me on a short leash. Nothing personal! :dog:"
+];
+function getRejectMessage() {
+  return REJECT_MESSAGES[Math.floor(Math.random() * REJECT_MESSAGES.length)];
+}
+var debug2 = process.env["DEBUG"] === "true";
+var nameCache = /* @__PURE__ */ new Map();
+async function resolveUser(client, userId) {
+  const cached = nameCache.get(userId);
+  if (cached) return cached;
+  try {
+    const res = await client.users.info({ user: userId });
+    const name = res.user?.real_name || res.user?.name || userId;
+    nameCache.set(userId, name);
+    return name;
+  } catch {
+    return userId;
+  }
+}
+async function resolveChannel(client, channelId) {
+  const cached = nameCache.get(channelId);
+  if (cached) return cached;
+  try {
+    const res = await client.conversations.info({ channel: channelId });
+    const name = res.channel?.name || channelId;
+    nameCache.set(channelId, name);
+    return name;
+  } catch {
+    return channelId;
+  }
+}
+var SUBTEAM_MENTION_PATTERN = /<!subteam\^(S[A-Z0-9]+)(?:\|[^>]*)?>/g;
+var SESSION_ID_PATTERN = /claude\s+--resume\s+([0-9a-f-]{36})/;
+async function extractSessionFromParent(client, channelId, threadTs) {
+  try {
+    const res = await client.conversations.replies({
+      channel: channelId,
+      ts: threadTs,
+      limit: 1,
+      inclusive: true
+    });
+    const parentText = res.messages?.[0]?.text ?? "";
+    const match = parentText.match(SESSION_ID_PATTERN);
+    return match?.[1];
+  } catch {
+    return void 0;
+  }
+}
+var groupMemberCache = /* @__PURE__ */ new Map();
+var GROUP_CACHE_TTL = 10 * 60 * 1e3;
+async function isOwnerInSubteam(client, subteamId, ownerUserId) {
+  const cached = groupMemberCache.get(subteamId);
+  if (cached && Date.now() - cached.fetchedAt < GROUP_CACHE_TTL) {
+    return cached.members.has(ownerUserId);
+  }
+  try {
+    const res = await client.usergroups.users.list({ usergroup: subteamId });
+    const members = new Set(res.users ?? []);
+    groupMemberCache.set(subteamId, { members, fetchedAt: Date.now() });
+    return members.has(ownerUserId);
+  } catch {
+    return false;
+  }
+}
+function registerListeners(app, store, config) {
+  const { claudeCwd, claudeConfigDir, botName, allowedUserIds, maxTurns, ownerUserId } = config;
+  const queue = new MessageQueue();
+  let botUserId;
+  async function ensureBotUserId(client) {
+    if (botUserId) return botUserId;
+    const auth = await client.auth.test();
+    botUserId = auth.user_id;
+    return botUserId;
+  }
+  async function handleMessage(client, say, channelId, sessionKey, prompt, sessionId, threadTs) {
+    const typingMsg = await client.chat.postMessage({
+      channel: channelId,
+      ...threadTs ? { thread_ts: threadTs } : {},
+      text: "_Thinking ..._"
+    });
+    try {
+      const response = await askClaude(prompt, claudeCwd, botName, maxTurns, claudeConfigDir, sessionId);
+      store.saveSession(channelId, sessionKey, response.sessionId);
+      const formatted = toSlackMarkdown(response.text);
+      const chunks = splitMessage(formatted);
+      if (debug2) {
+        console.log(`[response] length=${response.text.length} chunks=${chunks.length} chunkSizes=[${chunks.map((c) => c.length).join(",")}]`);
+      }
+      await client.chat.update({
+        channel: channelId,
+        ts: typingMsg.ts,
+        text: chunks[0]
+      });
+      for (let i = 1; i < chunks.length; i++) {
+        await say({ text: chunks[i], ...threadTs ? { thread_ts: threadTs } : {} });
+      }
+    } catch (err) {
+      console.error("[listener] Error handling message:", err);
+      await client.chat.update({
+        channel: channelId,
+        ts: typingMsg.ts,
+        text: "Sorry, something went wrong. Please try again."
+      });
+    } finally {
+    }
+  }
+  app.event("app_mention", async ({ event, client, say }) => {
+    const threadTs = event.thread_ts ?? event.ts;
+    const channelId = event.channel;
+    const threadKey = `${channelId}:${threadTs}`;
+    if (!event.user) return;
+    if (allowedUserIds.size > 0 && !allowedUserIds.has(event.user)) {
+      await say({ text: getRejectMessage(), thread_ts: threadTs });
+      return;
+    }
+    const userId = await ensureBotUserId(client);
+    const prompt = event.text.replace(new RegExp(`<@${userId}>`, "g"), "").trim();
+    if (!prompt) return;
+    if (debug2) {
+      const [userName, channelName] = await Promise.all([
+        resolveUser(client, event.user),
+        resolveChannel(client, channelId)
+      ]);
+      console.log(`[mention] user=${userName} channel=#${channelName} thread=${threadTs} prompt="${prompt}"`);
+    }
+    queue.enqueue(threadKey, async () => {
+      let sessionId = store.getSession(channelId, threadTs)?.sessionId;
+      if (!sessionId) {
+        sessionId = await extractSessionFromParent(client, channelId, threadTs);
+        if (debug2 && sessionId) {
+          console.log(`[mention] resuming session from parent message: ${sessionId}`);
+        }
+      }
+      await handleMessage(client, say, channelId, threadTs, prompt, sessionId, threadTs);
+    });
+  });
+  app.event("message", async ({ event, client, say }) => {
+    if (!("text" in event) || !event.text) return;
+    if ("bot_id" in event && event.bot_id) return;
+    if ("subtype" in event && event.subtype) return;
+    if (ownerUserId) {
+      let ownerMentioned = event.text.includes(`<@${ownerUserId}>`);
+      if (!ownerMentioned) {
+        const subteamIds = [...event.text.matchAll(SUBTEAM_MENTION_PATTERN)].map((m) => m[1]);
+        for (const subteamId of subteamIds) {
+          if (await isOwnerInSubteam(client, subteamId, ownerUserId)) {
+            ownerMentioned = true;
+            break;
+          }
+        }
+      }
+      if (ownerMentioned) {
+        try {
+          await client.reactions.add({
+            channel: event.channel,
+            timestamp: event.ts,
+            name: "eyes"
+          });
+        } catch (err) {
+          if (debug2) console.log("[owner-mention] Failed to add eyes reaction:", err);
+        }
+      }
+    }
+    const senderId = "user" in event ? event.user : void 0;
+    if (allowedUserIds.size > 0 && (!senderId || !allowedUserIds.has(senderId))) return;
+    const channelId = event.channel;
+    const channelType = "channel_type" in event ? event.channel_type : void 0;
+    const isDM = channelType === "im";
+    if (isDM) {
+      const threadTs2 = "thread_ts" in event ? event.thread_ts : void 0;
+      const sessionKey = threadTs2 ?? channelId;
+      const threadKey2 = `${channelId}:${sessionKey}`;
+      const prompt2 = event.text.trim();
+      if (!prompt2) return;
+      if (debug2) {
+        const userName = senderId ? await resolveUser(client, senderId) : "unknown";
+        console.log(`[dm] user=${userName} thread=${sessionKey} prompt="${prompt2}"`);
+      }
+      queue.enqueue(threadKey2, async () => {
+        const session2 = store.getSession(channelId, sessionKey);
+        await handleMessage(client, say, channelId, sessionKey, prompt2, session2?.sessionId, threadTs2);
+      });
+      return;
+    }
+    if (!("thread_ts" in event) || !event.thread_ts) return;
+    const threadTs = event.thread_ts;
+    const threadKey = `${channelId}:${threadTs}`;
+    const session = store.getSession(channelId, threadTs);
+    if (!session) return;
+    const userId = await ensureBotUserId(client);
+    if (event.text.includes(`<@${userId}>`)) return;
+    if (/<@U[A-Z0-9]+>/.test(event.text)) return;
+    const prompt = event.text.trim();
+    if (!prompt) return;
+    if (debug2) {
+      const [userName, channelName] = await Promise.all([
+        senderId ? resolveUser(client, senderId) : Promise.resolve("unknown"),
+        resolveChannel(client, channelId)
+      ]);
+      console.log(`[thread] user=${userName} channel=#${channelName} thread=${threadTs} prompt="${prompt}"`);
+    }
+    queue.enqueue(threadKey, async () => {
+      await handleMessage(client, say, channelId, threadTs, prompt, session.sessionId, threadTs);
+    });
+  });
+}
+
+// src/store/session-store.ts
+import Database from "better-sqlite3";
+var SessionStore = class {
+  db;
+  constructor(dbPath) {
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.init();
+  }
+  init() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        channel_id TEXT NOT NULL,
+        thread_ts TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+        PRIMARY KEY (channel_id, thread_ts)
+      )
+    `);
+  }
+  getSession(channelId, threadTs) {
+    const row = this.db.prepare("SELECT * FROM sessions WHERE channel_id = ? AND thread_ts = ?").get(channelId, threadTs);
+    if (!row) return void 0;
+    return {
+      channelId: row.channel_id,
+      threadTs: row.thread_ts,
+      sessionId: row.session_id,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  saveSession(channelId, threadTs, sessionId) {
+    this.db.prepare(
+      `INSERT INTO sessions (channel_id, thread_ts, session_id)
+         VALUES (?, ?, ?)
+         ON CONFLICT (channel_id, thread_ts)
+         DO UPDATE SET session_id = excluded.session_id, updated_at = datetime('now')`
+    ).run(channelId, threadTs, sessionId);
+  }
+  deleteSession(channelId, threadTs) {
+    this.db.prepare("DELETE FROM sessions WHERE channel_id = ? AND thread_ts = ?").run(channelId, threadTs);
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/index.ts
+async function startServer() {
+  ensureDirs();
+  const config = loadConfig();
+  const store = new SessionStore(paths.DB_FILE);
+  const app = createSlackApp(config);
+  registerListeners(app, store, config);
+  await app.start();
+  console.log("[custie] Server is running (Socket Mode)");
+  const shutdown = () => {
+    console.log("[custie] Shutting down...");
+    store.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+export {
+  paths,
+  ensureDirs,
+  loadEnvFiles,
+  startServer
+};

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+
+export {  }