custie 1.0.0

package/dist/cli.js

@@ -0,0 +1,850 @@
+#!/usr/bin/env node
+import {
+  ensureDirs,
+  loadEnvFiles,
+  paths,
+  startServer
+} from "./chunk-55T4S4ZY.js";
+
+// src/commands/start.ts
+async function runStart() {
+  loadEnvFiles();
+  await startServer();
+}
+
+// src/commands/prompt.ts
+import { existsSync, copyFileSync } from "fs";
+import { spawn } from "child_process";
+import { resolve } from "path";
+async function runPrompt() {
+  ensureDirs();
+  if (!existsSync(paths.PROMPT_FILE)) {
+    const defaultPrompt = resolve(paths.PACKAGE_ROOT, "system.default.md");
+    if (!existsSync(defaultPrompt)) {
+      console.error("[custie] system.default.md not found in package root.");
+      process.exit(1);
+    }
+    copyFileSync(defaultPrompt, paths.PROMPT_FILE);
+    console.log(`[custie] Copied default prompt to ${paths.PROMPT_FILE}`);
+  }
+  const editor = process.env["EDITOR"] || "vi";
+  console.log(`[custie] Opening ${paths.PROMPT_FILE} in ${editor}...`);
+  const child = spawn(editor, [paths.PROMPT_FILE], { stdio: "inherit" });
+  return new Promise((resolve5, reject) => {
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve5();
+      } else {
+        reject(new Error(`Editor exited with code ${code}`));
+      }
+    });
+    child.on("error", (err) => {
+      reject(new Error(`Failed to open editor: ${err.message}`));
+    });
+  });
+}
+
+// src/commands/config.ts
+import { existsSync as existsSync2, readFileSync, writeFileSync } from "fs";
+import { spawn as spawn2 } from "child_process";
+import { resolve as resolve2 } from "path";
+function maskToken(value) {
+  if (!value || value.length < 12) return "****";
+  return value.slice(0, 8) + "..." + value.slice(-4);
+}
+function isSensitive(key) {
+  const lower = key.toLowerCase();
+  return lower.includes("token") || lower.includes("secret");
+}
+function printConfig() {
+  loadEnvFiles();
+  console.log("\n  Paths:");
+  console.log(`    Config dir:   ${paths.CONFIG_DIR}`);
+  console.log(`    Data dir:     ${paths.DATA_DIR}`);
+  console.log(`    Config file:  ${paths.CONFIG_FILE} ${existsSync2(paths.CONFIG_FILE) ? "(exists)" : "(not found)"}`);
+  console.log(`    Prompt file:  ${paths.PROMPT_FILE} ${existsSync2(paths.PROMPT_FILE) ? "(exists)" : "(not found)"}`);
+  console.log(`    Database:     ${paths.DB_FILE} ${existsSync2(paths.DB_FILE) ? "(exists)" : "(not found)"}`);
+  console.log(`    Log dir:      ${paths.LOG_DIR}`);
+  const repoEnv = resolve2(process.cwd(), ".env");
+  console.log(`    Repo .env:    ${repoEnv} ${existsSync2(repoEnv) ? "(exists)" : "(not found)"}`);
+  const envKeys = [
+    "SLACK_BOT_TOKEN",
+    "SLACK_APP_TOKEN",
+    "SLACK_SIGNING_SECRET",
+    "CLAUDE_CWD",
+    "CLAUDE_CONFIG_DIR",
+    "BOT_NAME",
+    "ALLOWED_USER_IDS",
+    "OWNER_USER_ID",
+    "MAX_TURNS"
+  ];
+  console.log("\n  Environment:");
+  for (const key of envKeys) {
+    const value = process.env[key] ?? "";
+    const display = isSensitive(key) && value ? maskToken(value) : value || "(not set)";
+    console.log(`    ${key}=${display}`);
+  }
+  console.log("");
+}
+function editConfig() {
+  ensureDirs();
+  if (!existsSync2(paths.CONFIG_FILE)) {
+    const defaultEnv = resolve2(paths.PACKAGE_ROOT, ".env.example");
+    if (existsSync2(defaultEnv)) {
+      const content = readFileSync(defaultEnv, "utf-8");
+      writeFileSync(paths.CONFIG_FILE, content);
+    } else {
+      writeFileSync(paths.CONFIG_FILE, "");
+    }
+    console.log(`[custie] Created ${paths.CONFIG_FILE}`);
+  }
+  const editor = process.env["EDITOR"] || "vi";
+  console.log(`[custie] Opening ${paths.CONFIG_FILE} in ${editor}...`);
+  const child = spawn2(editor, [paths.CONFIG_FILE], { stdio: "inherit" });
+  return new Promise((resolve5, reject) => {
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve5();
+      } else {
+        reject(new Error(`Editor exited with code ${code}`));
+      }
+    });
+    child.on("error", (err) => {
+      reject(new Error(`Failed to open editor: ${err.message}`));
+    });
+  });
+}
+async function runConfig(args) {
+  if (args.includes("--path")) {
+    console.log(paths.CONFIG_FILE);
+    return;
+  }
+  if (args.includes("--edit")) {
+    await editConfig();
+    return;
+  }
+  printConfig();
+}
+
+// src/commands/setup.ts
+import { createInterface } from "readline";
+import { existsSync as existsSync3, copyFileSync as copyFileSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+import { tmpdir } from "os";
+function log(msg) {
+  console.log(`
+\x1B[36m>\x1B[0m ${msg}`);
+}
+function success(msg) {
+  console.log(`\x1B[32m+\x1B[0m ${msg}`);
+}
+function warn(msg) {
+  console.log(`\x1B[33m!\x1B[0m ${msg}`);
+}
+function error(msg) {
+  console.error(`\x1B[31mx\x1B[0m ${msg}`);
+}
+function mask(token) {
+  if (!token || token.length < 12) return "****";
+  return token.slice(0, 8) + "..." + token.slice(-4);
+}
+function createPrompt() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  function ask(question) {
+    return new Promise((resolve5) => rl.question(question, resolve5));
+  }
+  async function promptToken(name, prefix) {
+    while (true) {
+      const value = (await ask(`  ${name}: `)).trim();
+      if (!value) {
+        warn("Value is required.");
+        continue;
+      }
+      if (!value.startsWith(prefix)) {
+        warn(`Expected value starting with "${prefix}".`);
+        continue;
+      }
+      return value;
+    }
+  }
+  async function promptRequired(name) {
+    while (true) {
+      const value = (await ask(`  ${name}: `)).trim();
+      if (value) return value;
+      warn("Value is required.");
+    }
+  }
+  async function promptOptional(label, defaultValue = "") {
+    const defaultStr = defaultValue ? ` (default: ${defaultValue})` : " (leave blank to skip)";
+    const value = (await ask(`  ${label}${defaultStr}: `)).trim();
+    return value || defaultValue;
+  }
+  return { rl, ask, promptToken, promptRequired, promptOptional };
+}
+async function manualSetup() {
+  const { rl, ask, promptToken, promptRequired, promptOptional } = createPrompt();
+  try {
+    if (existsSync3(paths.CONFIG_FILE)) {
+      const answer = await ask(
+        `
+  Config already exists at ${paths.CONFIG_FILE}. Reconfigure? (y/N) `
+      );
+      if (answer.trim().toLowerCase() !== "y") {
+        success("Keeping existing config.");
+        return;
+      }
+    }
+    log("Let's configure your Slack app tokens.");
+    console.log(`
+  1. Go to https://api.slack.com/apps and create (or select) your app.
+     Tip: Use the manifest file for quick setup \u2014 see slack-app-manifest.yml
+  2. Under "OAuth & Permissions", install the app to your workspace.
+     Copy the \x1B[1mBot User OAuth Token\x1B[0m (starts with xoxb-).
+  3. Under "Basic Information > App-Level Tokens", create a token with
+     the \x1B[1mconnections:write\x1B[0m scope. Copy the token (starts with xapp-).
+  4. Under "Basic Information", copy the \x1B[1mSigning Secret\x1B[0m.
+  `);
+    const botToken = await promptToken("SLACK_BOT_TOKEN", "xoxb-");
+    const appToken = await promptToken("SLACK_APP_TOKEN", "xapp-");
+    const signingSecret = await promptRequired("SLACK_SIGNING_SECRET");
+    log("A few more settings to configure...\n");
+    const claudeCwd = await promptOptional(
+      "CLAUDE_CWD -- working directory for Claude sessions",
+      process.cwd()
+    );
+    const claudeConfigDir = await promptOptional(
+      "CLAUDE_CONFIG_DIR -- Claude config directory (e.g. ~/.claude-custie)"
+    );
+    const botName = await promptOptional("BOT_NAME -- display name in system prompt", "Custie");
+    console.log(
+      `
+  \x1B[2mTip: Find your Slack user ID by clicking your profile > ... > Copy member ID\x1B[0m`
+    );
+    const ownerUserId = await promptOptional(
+      "OWNER_USER_ID -- your Slack user ID for mention monitoring"
+    );
+    const defaultAllowed = ownerUserId || "";
+    const allowedUserIds = await promptOptional(
+      "ALLOWED_USER_IDS -- comma-separated user IDs",
+      defaultAllowed
+    );
+    if (!allowedUserIds) {
+      warn(
+        "No ALLOWED_USER_IDS set -- the bot runs with --dangerously-skip-permissions, so anyone in the workspace can execute commands. Consider restricting access."
+      );
+    }
+    writeConfigFile({
+      botToken,
+      appToken,
+      signingSecret,
+      claudeCwd,
+      claudeConfigDir,
+      botName,
+      ownerUserId,
+      allowedUserIds
+    });
+    copyDefaultPrompt();
+    printNextSteps();
+  } finally {
+    rl.close();
+  }
+}
+async function browserSetup() {
+  const { chromium } = await import("playwright");
+  const MANIFEST_PATH = resolve3(paths.PACKAGE_ROOT, "slack-app-manifest.yml");
+  if (!existsSync3(MANIFEST_PATH)) {
+    error(`Manifest not found: ${MANIFEST_PATH}`);
+    process.exit(1);
+  }
+  const manifestYaml = readFileSync2(MANIFEST_PATH, "utf-8");
+  success("Manifest loaded from slack-app-manifest.yml");
+  const DEBUG = process.argv.includes("--debug");
+  const SLOW_MO = DEBUG ? 200 : 50;
+  const USER_DATA_DIR = resolve3(tmpdir(), "custie-playwright-profile");
+  const { rl, ask, promptOptional } = createPrompt();
+  let context;
+  try {
+    log("Launching browser...");
+    context = await chromium.launchPersistentContext(USER_DATA_DIR, {
+      headless: false,
+      slowMo: SLOW_MO,
+      viewport: { width: 1280, height: 900 },
+      args: ["--disable-blink-features=AutomationControlled"]
+    });
+    const page = context.pages()[0] || await context.newPage();
+    log("Opening Slack API dashboard...");
+    await page.goto("https://api.slack.com/apps");
+    const createBtn = page.locator(
+      'a:has-text("Create New App"), button:has-text("Create New App")'
+    );
+    const isLoggedIn = await createBtn.first().isVisible({ timeout: 3e3 }).catch(() => false);
+    if (!isLoggedIn) {
+      log("Please log in to Slack in the browser window. Waiting up to 5 minutes...");
+      await createBtn.first().waitFor({ state: "visible", timeout: 3e5 });
+    }
+    success("Authenticated with Slack.");
+    log("Creating new Slack App from manifest...");
+    await createBtn.first().click();
+    await page.waitForTimeout(1e3);
+    await page.locator(
+      'button:has-text("From an app manifest"), a:has-text("From an app manifest")'
+    ).first().click();
+    await page.waitForTimeout(1e3);
+    const nextBtn = page.locator('button:has-text("Next")');
+    await nextBtn.first().waitFor({ state: "visible", timeout: 1e4 });
+    await page.waitForTimeout(500);
+    await nextBtn.first().click();
+    await page.waitForTimeout(1500);
+    const yamlTab = page.locator('button:has-text("YAML"), [role="tab"]:has-text("YAML")');
+    if (await yamlTab.first().isVisible({ timeout: 3e3 }).catch(() => false)) {
+      await yamlTab.first().click();
+      await page.waitForTimeout(500);
+    }
+    const textarea = page.locator("textarea").first();
+    const hasTextarea = await textarea.isVisible({ timeout: 2e3 }).catch(() => false);
+    if (hasTextarea) {
+      await textarea.click();
+      await page.keyboard.press("Meta+A");
+      await page.keyboard.press("Backspace");
+      await page.waitForTimeout(200);
+      await textarea.fill(manifestYaml);
+    } else {
+      const editor = page.locator('.CodeMirror, [role="textbox"], [contenteditable="true"]').first();
+      await editor.click();
+      await page.keyboard.press("Meta+A");
+      await page.keyboard.press("Backspace");
+      await page.waitForTimeout(200);
+      await page.keyboard.insertText(manifestYaml);
+    }
+    await page.waitForTimeout(500);
+    await nextBtn.first().waitFor({ state: "visible", timeout: 1e4 });
+    await nextBtn.first().click();
+    await page.waitForTimeout(1500);
+    const createAppBtn = page.locator('button:has-text("Create")');
+    await createAppBtn.first().waitFor({ state: "visible", timeout: 1e4 });
+    await createAppBtn.first().click();
+    await page.waitForURL("**/apps/A*", { timeout: 3e4 });
+    const appUrl = page.url();
+    const appId = appUrl.match(/\/apps\/(A[A-Z0-9]+)/)?.[1];
+    success(`App created! ID: ${appId}`);
+    log("Extracting Signing Secret...");
+    await page.waitForSelector("text=Signing Secret", { timeout: 1e4 });
+    const signingSection = page.locator("text=Signing Secret").locator("..");
+    const showBtn = signingSection.locator('button:has-text("Show"), a:has-text("Show")');
+    if (await showBtn.first().isVisible({ timeout: 3e3 }).catch(() => false)) {
+      await showBtn.first().click();
+      await page.waitForTimeout(500);
+    }
+    let signingSecret = await signingSection.locator("input").first().inputValue().catch(() => "");
+    if (!signingSecret) {
+      signingSecret = await page.evaluate(() => {
+        const labels = [...document.querySelectorAll("*")].filter(
+          (el) => el.textContent?.trim() === "Signing Secret"
+        );
+        for (const label of labels) {
+          const container = label.closest("div");
+          if (!container) continue;
+          const input = container.querySelector("input");
+          if (input?.value) return input.value;
+        }
+        return "";
+      });
+    }
+    if (!signingSecret) {
+      warn("Could not auto-extract Signing Secret. Please copy it from the browser.");
+      signingSecret = await ask("  Paste your Signing Secret here: ");
+    }
+    success(`Signing Secret: ${mask(signingSecret)}`);
+    log("Generating App-Level Token (Socket Mode)...");
+    const tokenSection = page.locator("text=App-Level Tokens");
+    await tokenSection.first().scrollIntoViewIfNeeded();
+    await page.waitForTimeout(500);
+    const generateBtn = page.locator(
+      'button:has-text("Generate Token"), a:has-text("Generate Token")'
+    );
+    await generateBtn.first().click();
+    await page.waitForTimeout(1e3);
+    const nameInput = page.locator(
+      'input[placeholder*="oken"], input[placeholder*="name"], input[name*="token"]'
+    );
+    await nameInput.first().waitFor({ state: "visible", timeout: 1e4 });
+    await nameInput.first().fill("socket-mode");
+    await page.waitForTimeout(500);
+    const addScopeBtn = page.locator(
+      'button:has-text("Add Scope"), a:has-text("Add Scope")'
+    );
+    await addScopeBtn.first().click();
+    await page.waitForTimeout(500);
+    await page.locator("text=connections:write").first().click();
+    await page.waitForTimeout(500);
+    const genBtn = page.locator('button:has-text("Generate")');
+    await genBtn.first().click();
+    await page.waitForTimeout(2e3);
+    let appToken = await page.evaluate(() => {
+      const els = [...document.querySelectorAll("input, code, span, div")];
+      for (const el of els) {
+        const val = el.value || el.textContent || "";
+        if (val.trim().startsWith("xapp-")) return val.trim();
+      }
+      return "";
+    });
+    if (!appToken) {
+      warn("Could not auto-extract App-Level Token. Please copy it from the browser.");
+      appToken = await ask("  Paste your App-Level Token (xapp-...): ");
+    }
+    const doneBtn = page.locator('button:has-text("Done")');
+    if (await doneBtn.first().isVisible({ timeout: 2e3 }).catch(() => false)) {
+      await doneBtn.first().click();
+      await page.waitForTimeout(500);
+    }
+    success(`App-Level Token: ${mask(appToken)}`);
+    log("Installing app to workspace...");
+    const installLink = page.locator('a:has-text("Install App")');
+    if (await installLink.first().isVisible({ timeout: 3e3 }).catch(() => false)) {
+      await installLink.first().click();
+    } else {
+      await page.goto(`https://api.slack.com/apps/${appId}/install-on-team`);
+    }
+    await page.waitForTimeout(1500);
+    const installBtn = page.locator(
+      'button:has-text("Install to Workspace"), a:has-text("Install to Workspace")'
+    );
+    await installBtn.first().waitFor({ state: "visible", timeout: 1e4 });
+    await installBtn.first().click();
+    await page.waitForTimeout(2e3);
+    const allowBtn = page.locator('button:has-text("Allow")');
+    if (await allowBtn.first().isVisible({ timeout: 5e3 }).catch(() => false)) {
+      await allowBtn.first().click();
+      await page.waitForTimeout(2e3);
+    }
+    await page.waitForSelector("text=Bot User OAuth Token", { timeout: 15e3 });
+    let botToken = await page.evaluate(() => {
+      const els = [...document.querySelectorAll("input")];
+      for (const el of els) {
+        if (el.value?.startsWith("xoxb-")) return el.value;
+      }
+      return "";
+    });
+    if (!botToken) {
+      const showBotBtn = page.locator('button:has-text("Show"), a:has-text("Show")').first();
+      if (await showBotBtn.isVisible({ timeout: 2e3 }).catch(() => false)) {
+        await showBotBtn.click();
+        await page.waitForTimeout(500);
+        botToken = await page.evaluate(() => {
+          const els = [...document.querySelectorAll("input")];
+          for (const el of els) {
+            if (el.value?.startsWith("xoxb-")) return el.value;
+          }
+          return "";
+        });
+      }
+    }
+    if (!botToken) {
+      warn("Could not auto-extract Bot Token. Please copy it from the browser.");
+      botToken = await ask("  Paste your Bot User OAuth Token (xoxb-...): ");
+    }
+    success(`Bot Token: ${mask(botToken)}`);
+    log("A few more settings to configure...\n");
+    const claudeCwd = await promptOptional(
+      "CLAUDE_CWD -- working directory for Claude sessions",
+      process.cwd()
+    );
+    const claudeConfigDir = await promptOptional(
+      "CLAUDE_CONFIG_DIR -- Claude config directory (e.g. ~/.claude-custie)"
+    );
+    const botName = await promptOptional(
+      "BOT_NAME -- display name in system prompt",
+      "Custie"
+    );
+    console.log(
+      `
+  \x1B[2mTip: Find your Slack user ID by clicking your profile > ... > Copy member ID\x1B[0m`
+    );
+    const ownerUserId = await promptOptional(
+      "OWNER_USER_ID -- your Slack user ID for mention monitoring"
+    );
+    const defaultAllowed = ownerUserId || "";
+    const allowedUserIds = await promptOptional(
+      "ALLOWED_USER_IDS -- comma-separated user IDs",
+      defaultAllowed
+    );
+    if (!allowedUserIds) {
+      warn(
+        "No ALLOWED_USER_IDS set -- the bot runs with --dangerously-skip-permissions, so anyone in the workspace can execute commands. Consider restricting access."
+      );
+    }
+    writeConfigFile({
+      botToken: botToken.trim(),
+      appToken: appToken.trim(),
+      signingSecret: signingSecret.trim(),
+      claudeCwd,
+      claudeConfigDir,
+      botName,
+      ownerUserId,
+      allowedUserIds
+    });
+    copyDefaultPrompt();
+    printNextSteps();
+    if (!DEBUG) {
+      await context.close();
+    } else {
+      log("Debug mode: browser stays open. Press Ctrl+C to exit.");
+      await new Promise(() => {
+      });
+    }
+  } catch (err) {
+    error(`Setup failed: ${err.message}`);
+    if (process.argv.includes("--debug")) console.error(err);
+    try {
+      const pages = context?.pages();
+      if (pages?.[0]) {
+        const screenshotPath = resolve3(paths.PACKAGE_ROOT, "setup-error.png");
+        await pages[0].screenshot({ path: screenshotPath, fullPage: true });
+        warn(`Screenshot saved to: ${screenshotPath}`);
+      }
+    } catch {
+    }
+    warn("Browser left open for manual inspection. Press Ctrl+C to exit.");
+    await new Promise(() => {
+    });
+  } finally {
+    rl.close();
+  }
+}
+function writeConfigFile(config) {
+  const envContent = [
+    `# Slack Bot Token (xoxb-...)`,
+    `SLACK_BOT_TOKEN=${config.botToken}`,
+    ``,
+    `# Slack App-Level Token for Socket Mode (xapp-...)`,
+    `SLACK_APP_TOKEN=${config.appToken}`,
+    ``,
+    `# Slack Signing Secret`,
+    `SLACK_SIGNING_SECRET=${config.signingSecret}`,
+    ``,
+    `# Default working directory for Claude sessions (optional)`,
+    `CLAUDE_CWD=${config.claudeCwd}`,
+    ``,
+    `# Claude config directory for session storage (optional, e.g. ~/.claude-custie)`,
+    `CLAUDE_CONFIG_DIR=${config.claudeConfigDir}`,
+    ``,
+    `# Bot display name used in system prompt (default: Custie)`,
+    `BOT_NAME=${config.botName}`,
+    ``,
+    `# Comma-separated Slack user IDs allowed to interact (empty = everyone)`,
+    `# If set, the owner is automatically included -- no need to duplicate`,
+    `ALLOWED_USER_IDS=${config.allowedUserIds}`,
+    ``,
+    `# Owner's Slack user ID -- bot reacts with eyes when owner is mentioned`,
+    `# Does not restrict access on its own; only ALLOWED_USER_IDS controls who can use the bot`,
+    `OWNER_USER_ID=${config.ownerUserId}`,
+    ``
+  ].join("\n");
+  writeFileSync2(paths.CONFIG_FILE, envContent);
+  success(`Config written to ${paths.CONFIG_FILE}`);
+}
+function printNextSteps() {
+  log("Setup complete! Next steps:\n");
+  console.log("  1. Set your bot avatar:");
+  console.log("     Go to https://api.slack.com/apps \u2192 your app \u2192 Basic Information");
+  console.log('     Scroll to "Display Information" and upload an app icon.\n');
+  console.log("  2. Customise the system prompt (optional):");
+  console.log(`     Run \x1B[1mcustie prompt\x1B[0m to edit ${paths.PROMPT_FILE}
+`);
+  console.log("  3. Start the bot:");
+  console.log("     Run \x1B[1mcustie start\x1B[0m\n");
+  console.log("  4. Install as a background service (optional):");
+  console.log("     Run \x1B[1mcustie install\x1B[0m\n");
+}
+function copyDefaultPrompt() {
+  if (!existsSync3(paths.PROMPT_FILE)) {
+    const defaultPrompt = resolve3(paths.PACKAGE_ROOT, "system.default.md");
+    if (existsSync3(defaultPrompt)) {
+      copyFileSync2(defaultPrompt, paths.PROMPT_FILE);
+      success(`Default prompt copied to ${paths.PROMPT_FILE}`);
+    }
+  }
+}
+async function runSetup(args) {
+  console.log("\n\x1B[1mCustie Setup\x1B[0m\n");
+  ensureDirs();
+  if (args.includes("--manual")) {
+    await manualSetup();
+    return;
+  }
+  try {
+    await import("playwright");
+    await browserSetup();
+  } catch {
+    warn(
+      "Playwright not installed -- falling back to manual setup.\n  For automated browser setup, run:\n  pnpm add -D playwright && pnpx playwright install chromium\n"
+    );
+    await manualSetup();
+  }
+}
+
+// src/commands/install.ts
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync } from "fs";
+import { execSync } from "child_process";
+import { dirname, join, resolve as resolve4 } from "path";
+import { homedir, platform } from "os";
+var PLIST_NAME = "io.flycoder.custie.plist";
+var SYSTEMD_SERVICE = "custie.service";
+function log2(msg) {
+  console.log(`
+\x1B[36m>\x1B[0m ${msg}`);
+}
+function success2(msg) {
+  console.log(`\x1B[32m+\x1B[0m ${msg}`);
+}
+function warn2(msg) {
+  console.log(`\x1B[33m!\x1B[0m ${msg}`);
+}
+function run(cmd, opts = {}) {
+  return execSync(cmd, {
+    encoding: "utf-8",
+    stdio: opts.silent ? "pipe" : "inherit"
+  }).toString().trim();
+}
+function detectCustieBin() {
+  const argv1 = process.argv[1];
+  if (argv1) {
+    return resolve4(argv1);
+  }
+  try {
+    return run("which custie", { silent: true });
+  } catch {
+    return "custie";
+  }
+}
+function readEnvFile() {
+  if (!existsSync4(paths.CONFIG_FILE)) return {};
+  const vars = {};
+  for (const line of readFileSync3(paths.CONFIG_FILE, "utf-8").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    const val = trimmed.slice(eq + 1).trim();
+    if (val) vars[key] = val;
+  }
+  return vars;
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+async function installMacOS() {
+  log2("Setting up macOS LaunchAgent...");
+  const custieBin = detectCustieBin();
+  const nodePath = process.execPath;
+  const logDir = paths.LOG_DIR;
+  mkdirSync(logDir, { recursive: true });
+  const envVars = readEnvFile();
+  const plist = `<?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>io.flycoder.custie</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>${custieBin}</string>
+    <string>start</string>
+  </array>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${dirname(nodePath)}:/usr/local/bin:/usr/bin:/bin</string>
+${Object.entries(envVars).map(([k, v]) => `    <key>${k}</key>
+    <string>${escapeXml(v)}</string>`).join("\n")}
+  </dict>
+
+  <key>RunAtLoad</key>
+  <true/>
+
+  <key>KeepAlive</key>
+  <true/>
+
+  <key>StandardOutPath</key>
+  <string>${join(logDir, "custie.log")}</string>
+
+  <key>StandardErrorPath</key>
+  <string>${join(logDir, "custie-error.log")}</string>
+</dict>
+</plist>`;
+  const agentDir = join(homedir(), "Library", "LaunchAgents");
+  mkdirSync(agentDir, { recursive: true });
+  const plistPath = join(agentDir, PLIST_NAME);
+  try {
+    run(`launchctl unload "${plistPath}"`, { silent: true });
+  } catch {
+  }
+  try {
+    unlinkSync(plistPath);
+  } catch {
+  }
+  writeFileSync3(plistPath, plist);
+  run(`launchctl load "${plistPath}"`, { silent: true });
+  success2("LaunchAgent installed and loaded.");
+  console.log(`  Logs: ${logDir}`);
+  console.log(`  Check: launchctl list | grep custie`);
+}
+async function installLinux() {
+  log2("Setting up systemd user service...");
+  const custieBin = detectCustieBin();
+  const nodePath = process.execPath;
+  const logDir = paths.LOG_DIR;
+  mkdirSync(logDir, { recursive: true });
+  const envVars = readEnvFile();
+  const envLines = Object.entries(envVars).map(([k, v]) => `Environment="${k}=${v}"`).join("\n");
+  const unit = `[Unit]
+Description=Custie Slack Bot
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${custieBin} start
+Restart=on-failure
+RestartSec=5
+${envLines}
+Environment="PATH=${dirname(nodePath)}:/usr/local/bin:/usr/bin:/bin"
+
+StandardOutput=append:${join(logDir, "custie.log")}
+StandardError=append:${join(logDir, "custie-error.log")}
+
+[Install]
+WantedBy=default.target
+`;
+  const unitDir = join(homedir(), ".config", "systemd", "user");
+  mkdirSync(unitDir, { recursive: true });
+  writeFileSync3(join(unitDir, SYSTEMD_SERVICE), unit);
+  run("systemctl --user daemon-reload", { silent: true });
+  run("systemctl --user enable --now custie", { silent: true });
+  success2("systemd user service installed and started.");
+  console.log(`  Logs: ${logDir}`);
+  console.log(`  Check: systemctl --user status custie`);
+}
+async function runInstall() {
+  ensureDirs();
+  const os = platform();
+  if (os === "darwin") {
+    await installMacOS();
+  } else if (os === "linux") {
+    await installLinux();
+  } else {
+    warn2(`Unsupported platform: ${os}. You'll need to configure autostart manually.`);
+  }
+}
+
+// src/commands/uninstall.ts
+import { unlinkSync as unlinkSync2 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { join as join2 } from "path";
+import { homedir as homedir2, platform as platform2 } from "os";
+var PLIST_NAME2 = "io.flycoder.custie.plist";
+var SYSTEMD_SERVICE2 = "custie.service";
+function log3(msg) {
+  console.log(`
+\x1B[36m>\x1B[0m ${msg}`);
+}
+function success3(msg) {
+  console.log(`\x1B[32m+\x1B[0m ${msg}`);
+}
+function warn3(msg) {
+  console.log(`\x1B[33m!\x1B[0m ${msg}`);
+}
+function run2(cmd) {
+  execSync2(cmd, { encoding: "utf-8", stdio: "pipe" });
+}
+async function runUninstall() {
+  const os = platform2();
+  log3("Uninstalling Custie service...");
+  if (os === "darwin") {
+    const plistPath = join2(homedir2(), "Library", "LaunchAgents", PLIST_NAME2);
+    try {
+      run2(`launchctl unload "${plistPath}"`);
+    } catch {
+    }
+    try {
+      unlinkSync2(plistPath);
+    } catch {
+    }
+    success3("LaunchAgent removed.");
+  } else if (os === "linux") {
+    try {
+      run2("systemctl --user disable --now custie");
+    } catch {
+    }
+    const unitPath = join2(homedir2(), ".config", "systemd", "user", SYSTEMD_SERVICE2);
+    try {
+      unlinkSync2(unitPath);
+    } catch {
+    }
+    try {
+      run2("systemctl --user daemon-reload");
+    } catch {
+    }
+    success3("systemd user service removed.");
+  } else {
+    warn3(`Unsupported platform: ${os}`);
+  }
+  console.log("\n  Config and data directories were NOT removed.");
+}
+
+// src/cli.ts
+var USAGE = `
+  Usage: custie <command> [options]
+
+  Commands:
+    start        Start the Slack bot server
+    setup        Interactive first-time setup (--browser for Playwright automation)
+    install      Install as a system service (launchd / systemd)
+    uninstall    Remove the system service
+    prompt       Edit the system prompt in $EDITOR
+    config       Show resolved config (--edit to edit, --path for file path)
+
+  Options:
+    -h, --help   Show this help message
+`;
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  switch (command) {
+    case "start":
+      await runStart();
+      break;
+    case "setup":
+      await runSetup(args.slice(1));
+      break;
+    case "install":
+      await runInstall();
+      break;
+    case "uninstall":
+      await runUninstall();
+      break;
+    case "prompt":
+      await runPrompt();
+      break;
+    case "config":
+      await runConfig(args.slice(1));
+      break;
+    case "-h":
+    case "--help":
+    case void 0:
+      console.log(USAGE);
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.log(USAGE);
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error("[custie] Fatal error:", err);
+  process.exit(1);
+});