slackhive 0.1.44 → 0.1.45

package/cli/dist/index.js

@@ -6,9 +6,16 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -25,6 +32,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // node_modules/commander/lib/error.js
 var require_error = __commonJS({
@@ -15199,12 +15207,365 @@ var require_prompts3 = __commonJS({
   }
 });
 
+// src/commands/manage.ts
+var manage_exports = {};
+__export(manage_exports, {
+  logs: () => logs,
+  start: () => start,
+  status: () => status,
+  stop: () => stop,
+  update: () => update
+});
+function getConfigPath() {
+  return (0, import_path.join)(getSlackhiveDir(), "config.json");
+}
+function saveProjectDir(dir) {
+  const configPath = getConfigPath();
+  (0, import_fs.mkdirSync)((0, import_path.join)(configPath, ".."), { recursive: true });
+  (0, import_fs.writeFileSync)(configPath, JSON.stringify({ projectDir: dir }));
+}
+function findProjectDir() {
+  const isSlackHiveDir = (d) => (0, import_fs.existsSync)((0, import_path.join)(d, "package.json")) && (0, import_fs.existsSync)((0, import_path.join)(d, "apps", "runner"));
+  if (isSlackHiveDir(process.cwd())) {
+    const dir = process.cwd();
+    saveProjectDir(dir);
+    return dir;
+  }
+  const sub = (0, import_path.join)(process.cwd(), "slackhive");
+  if (isSlackHiveDir(sub)) {
+    saveProjectDir(sub);
+    return sub;
+  }
+  try {
+    const config = JSON.parse((0, import_fs.readFileSync)(getConfigPath(), "utf-8"));
+    if (config.projectDir && (0, import_fs.existsSync)((0, import_path.join)(config.projectDir, "apps", "runner"))) {
+      return config.projectDir;
+    }
+  } catch {
+  }
+  console.log(import_chalk.default.red("  Could not find SlackHive project."));
+  console.log(import_chalk.default.gray("  Run this command from the SlackHive directory, or run `slackhive init` first."));
+  process.exit(1);
+}
+function getSlackhiveDir() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "/tmp";
+  return (0, import_path.join)(home, ".slackhive");
+}
+function getPidFile() {
+  return (0, import_path.join)(getSlackhiveDir(), "slackhive.pid");
+}
+function writePid(pid, webPort = 3001, internalPort = 3002) {
+  const dir = getSlackhiveDir();
+  (0, import_fs.mkdirSync)(dir, { recursive: true });
+  (0, import_fs.writeFileSync)(getPidFile(), JSON.stringify({ pid, webPort, internalPort }));
+}
+function readPidInfo() {
+  try {
+    const raw = (0, import_fs.readFileSync)(getPidFile(), "utf-8").trim();
+    let info;
+    if (raw.startsWith("{")) {
+      info = JSON.parse(raw);
+    } else {
+      info = { pid: parseInt(raw, 10), webPort: 3001, internalPort: 3002 };
+    }
+    process.kill(info.pid, 0);
+    return info;
+  } catch {
+    try {
+      (0, import_fs.unlinkSync)(getPidFile());
+    } catch {
+    }
+    return null;
+  }
+}
+function nativeStart(dir) {
+  const existing = readPidInfo();
+  if (existing) {
+    const stopSpinner = (0, import_ora.default)("Stopping existing instance...").start();
+    try {
+      process.kill(-existing.pid, "SIGTERM");
+    } catch {
+    }
+    try {
+      process.kill(existing.pid, "SIGTERM");
+    } catch {
+    }
+    for (const port of [String(existing.webPort), String(existing.internalPort)]) {
+      try {
+        (0, import_child_process.execSync)(`lsof -ti:${port} | xargs kill -9`, { stdio: "ignore" });
+      } catch {
+      }
+    }
+    try {
+      (0, import_fs.unlinkSync)(getPidFile());
+    } catch {
+    }
+    stopSpinner.succeed("Stopped existing instance");
+  }
+  const spinner = (0, import_ora.default)("Starting SlackHive...").start();
+  try {
+    const standaloneTs = (0, import_path.join)(dir, "apps", "runner", "src", "standalone.ts");
+    const tsxBin = (0, import_path.join)(dir, "node_modules", ".bin", "tsx");
+    if (!(0, import_fs.existsSync)(standaloneTs)) {
+      spinner.fail("standalone.ts not found \u2014 is this a valid SlackHive repo?");
+      return;
+    }
+    if (!(0, import_fs.existsSync)(tsxBin)) {
+      spinner.text = "Installing dependencies...";
+      (0, import_child_process.execSync)("npm install", { cwd: dir, stdio: "ignore", timeout: 3e5 });
+    }
+    const env = {
+      PATH: process.env.PATH ?? "",
+      HOME: process.env.HOME ?? "",
+      USER: process.env.USER ?? "",
+      SHELL: process.env.SHELL ?? "",
+      TERM: process.env.TERM ?? "",
+      DATABASE_TYPE: "sqlite",
+      NODE_ENV: "production"
+    };
+    const envFile = (0, import_path.join)(dir, ".env");
+    if ((0, import_fs.existsSync)(envFile)) {
+      const envContent = (0, import_fs.readFileSync)(envFile, "utf-8");
+      for (const line of envContent.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx > 0) {
+          const key = trimmed.slice(0, eqIdx);
+          const val = trimmed.slice(eqIdx + 1);
+          if (key === "CLAUDE_CODE_OAUTH_TOKEN" || key === "CLAUDE_CODE_OAUTH_REFRESH_TOKEN") continue;
+          env[key] = val;
+        }
+      }
+    }
+    env.DATABASE_TYPE = "sqlite";
+    const isPortFree = (port) => {
+      try {
+        (0, import_child_process.execSync)(`lsof -ti:${port}`, { stdio: ["pipe", "pipe", "pipe"] });
+        return false;
+      } catch {
+        return true;
+      }
+    };
+    let webPort = 3001;
+    while (!isPortFree(webPort) && webPort < 3100) webPort++;
+    if (!isPortFree(webPort)) {
+      spinner.fail("No free port in range 3001\u20133099 for web UI");
+      return;
+    }
+    let internalPort = 3002;
+    while ((!isPortFree(internalPort) || internalPort === webPort) && internalPort < 3100) internalPort++;
+    if (!isPortFree(internalPort) || internalPort === webPort) {
+      spinner.fail("No free port in range 3002\u20133099 for internal runner");
+      return;
+    }
+    env.PORT = String(webPort);
+    env.RUNNER_INTERNAL_PORT = String(internalPort);
+    if (webPort !== 3001) console.log(import_chalk.default.yellow(`  Port 3001 in use, using ${webPort}`));
+    spinner.text = "Starting...";
+    const logDir = (0, import_path.join)(process.env.HOME ?? "/tmp", ".slackhive", "logs");
+    (0, import_fs.mkdirSync)(logDir, { recursive: true });
+    const out = (0, import_fs.openSync)((0, import_path.join)(logDir, "native-stdout.log"), "a");
+    const err = (0, import_fs.openSync)((0, import_path.join)(logDir, "native-stderr.log"), "a");
+    const child = (0, import_child_process.spawn)(tsxBin, [standaloneTs], {
+      cwd: dir,
+      env,
+      detached: true,
+      stdio: ["ignore", out, err]
+    });
+    child.unref();
+    writePid(child.pid, webPort, internalPort);
+    spinner.succeed(`SlackHive started (PID ${child.pid})`);
+    console.log(import_chalk.default.gray(`  Web UI: http://localhost:${webPort}`));
+    console.log(import_chalk.default.gray(`  Data:   ${getSlackhiveDir()}/data.db`));
+    console.log(import_chalk.default.gray(`  Logs:   ${getSlackhiveDir()}/logs/runner.log`));
+  } catch (err) {
+    spinner.fail(`Failed to start: ${err.message}`);
+  }
+}
+function findOrphanRunnerPids(excludePid) {
+  try {
+    const out = (0, import_child_process.execSync)("ps -e -o pid,command", { encoding: "utf-8" });
+    const pids = [];
+    for (const line of out.split("\n")) {
+      const m = line.trim().match(/^(\d+)\s+(.*)$/);
+      if (!m) continue;
+      const pid = Number(m[1]);
+      const cmd = m[2];
+      if (pid === process.pid) continue;
+      if (excludePid !== null && pid === excludePid) continue;
+      if (cmd.includes("apps/runner/dist/standalone.js") || /tsx.*apps\/runner\/src\/index\.ts/.test(cmd) || /tsx watch src\/index\.ts/.test(cmd)) {
+        pids.push(pid);
+      }
+    }
+    return pids;
+  } catch {
+    return [];
+  }
+}
+function killOrphans(excludePid) {
+  const pids = findOrphanRunnerPids(excludePid);
+  if (pids.length === 0) return 0;
+  for (const pid of pids) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+  }
+  const deadline = Date.now() + 2e3;
+  while (Date.now() < deadline) {
+    const alive = pids.filter((pid) => {
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    if (alive.length === 0) return pids.length;
+    try {
+      (0, import_child_process.execSync)("sleep 0.2");
+    } catch {
+    }
+  }
+  for (const pid of pids) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+  return pids.length;
+}
+function nativeStop() {
+  const info = readPidInfo();
+  const spinner = (0, import_ora.default)("Stopping SlackHive...").start();
+  try {
+    if (info) {
+      try {
+        process.kill(-info.pid, "SIGTERM");
+      } catch {
+      }
+      try {
+        process.kill(info.pid, "SIGTERM");
+      } catch {
+      }
+      for (const port of [String(info.webPort), String(info.internalPort)]) {
+        try {
+          (0, import_child_process.execSync)(`lsof -ti:${port} | xargs kill -9`, { stdio: "ignore" });
+        } catch {
+        }
+      }
+      try {
+        (0, import_fs.unlinkSync)(getPidFile());
+      } catch {
+      }
+    }
+    const killed = killOrphans(info?.pid ?? null);
+    try {
+      (0, import_fs.unlinkSync)((0, import_path.join)(getSlackhiveDir(), "runner.lock"));
+    } catch {
+    }
+    if (!info && killed === 0) {
+      spinner.info("SlackHive was not running");
+      return;
+    }
+    const extra = killed > 0 ? ` (killed ${killed} orphaned runner process${killed === 1 ? "" : "es"})` : "";
+    spinner.succeed(`SlackHive stopped${extra}`);
+  } catch {
+    spinner.fail("Failed to stop SlackHive");
+  }
+}
+function nativeStatus() {
+  const info = readPidInfo();
+  console.log("");
+  console.log(import_chalk.default.bold("  SlackHive Status"));
+  console.log("");
+  if (info) {
+    console.log(import_chalk.default.green(`  Status:   Running (PID ${info.pid})`));
+    console.log(import_chalk.default.gray(`  Web UI:   http://localhost:${info.webPort}`));
+    console.log(import_chalk.default.gray(`  Database: ${getSlackhiveDir()}/data.db`));
+    console.log(import_chalk.default.gray(`  Logs:     ${getSlackhiveDir()}/logs/runner.log`));
+  } else {
+    console.log(import_chalk.default.red("  Status:   Stopped"));
+    console.log(import_chalk.default.gray("  Run `slackhive start` to start"));
+  }
+  console.log("");
+}
+function nativeLogs(follow) {
+  const logDir = (0, import_path.join)(getSlackhiveDir(), "logs");
+  const files = ["runner.log", "native-stdout.log", "native-stderr.log"].map((f) => (0, import_path.join)(logDir, f)).filter((f) => (0, import_fs.existsSync)(f));
+  if (files.length === 0) {
+    console.log(import_chalk.default.yellow("  No log files found. Is SlackHive running?"));
+    return;
+  }
+  const args = follow ? ["-f", ...files] : ["-n", "200", ...files];
+  (0, import_child_process.spawn)("tail", args, { stdio: "inherit" });
+}
+function nativeUpdate(dir) {
+  const info = readPidInfo();
+  if (info) {
+    const stopSpinner = (0, import_ora.default)("Stopping SlackHive...").start();
+    try {
+      process.kill(info.pid, "SIGTERM");
+    } catch {
+    }
+    try {
+      (0, import_fs.unlinkSync)(getPidFile());
+    } catch {
+    }
+    stopSpinner.succeed("Stopped");
+  }
+  const pullSpinner = (0, import_ora.default)("Pulling latest changes...").start();
+  try {
+    (0, import_child_process.execSync)("git pull", { cwd: dir, stdio: "ignore" });
+    pullSpinner.succeed("Code updated");
+  } catch {
+    pullSpinner.fail("Failed to pull");
+    return;
+  }
+  const buildSpinner = (0, import_ora.default)("Rebuilding...").start();
+  try {
+    (0, import_child_process.execSync)("npm install && npm run build", { cwd: dir, stdio: "ignore", timeout: 12e4 });
+    buildSpinner.succeed("Rebuilt");
+  } catch {
+    buildSpinner.fail("Build failed");
+    return;
+  }
+  nativeStart(dir);
+}
+async function start() {
+  nativeStart(findProjectDir());
+}
+async function stop() {
+  nativeStop();
+}
+async function status() {
+  nativeStatus();
+}
+async function logs(opts) {
+  nativeLogs(opts.follow !== false);
+}
+async function update() {
+  nativeUpdate(findProjectDir());
+}
+var import_child_process, import_fs, import_path, import_chalk, import_ora;
+var init_manage = __esm({
+  "src/commands/manage.ts"() {
+    "use strict";
+    import_child_process = require("child_process");
+    import_fs = require("fs");
+    import_path = require("path");
+    import_chalk = __toESM(require_source());
+    import_ora = __toESM(require_ora());
+  }
+});
+
 // package.json
 var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "slackhive",
-      version: "0.1.44",
+      version: "0.1.45",
       description: "CLI to install and manage SlackHive \u2014 AI agent teams on Slack",
       bin: {
         slackhive: "./dist/index.js"
@@ -15268,11 +15629,11 @@ var {
 } = import_index.default;
 
 // src/commands/init.ts
-var import_child_process = require("child_process");
-var import_fs = require("fs");
-var import_path = require("path");
-var import_chalk = __toESM(require_source());
-var import_ora = __toESM(require_ora());
+var import_child_process2 = require("child_process");
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var import_chalk2 = __toESM(require_source());
+var import_ora2 = __toESM(require_ora());
 var import_prompts = __toESM(require_prompts3());
 var REPO_URL = "https://github.com/pelago-labs/slackhive.git";
 function parseOAuthFromJson(json) {
@@ -15288,7 +15649,7 @@ function parseOAuthFromJson(json) {
 }
 function extractOAuthCredentials() {
   try {
-    const creds = (0, import_child_process.execSync)('security find-generic-password -s "Claude Code-credentials" -w', {
+    const creds = (0, import_child_process2.execSync)('security find-generic-password -s "Claude Code-credentials" -w', {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "ignore"]
     }).trim();
@@ -15297,7 +15658,7 @@ function extractOAuthCredentials() {
   } catch {
   }
   try {
-    const creds = (0, import_child_process.execSync)('secret-tool lookup service "Claude Code-credentials"', {
+    const creds = (0, import_child_process2.execSync)('secret-tool lookup service "Claude Code-credentials"', {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "ignore"]
     }).trim();
@@ -15306,9 +15667,9 @@ function extractOAuthCredentials() {
   } catch {
   }
   try {
-    const credPath = (0, import_path.join)(process.env.HOME || "~", ".claude", ".credentials.json");
-    if ((0, import_fs.existsSync)(credPath)) {
-      const creds = (0, import_fs.readFileSync)(credPath, "utf-8").trim();
+    const credPath = (0, import_path2.join)(process.env.HOME || "~", ".claude", ".credentials.json");
+    if ((0, import_fs2.existsSync)(credPath)) {
+      const creds = (0, import_fs2.readFileSync)(credPath, "utf-8").trim();
       const result = parseOAuthFromJson(creds);
       if (result) return result;
     }
@@ -15316,44 +15677,54 @@ function extractOAuthCredentials() {
   }
   return null;
 }
+function syncCredentialsFile(creds) {
+  const credPath = (0, import_path2.join)(process.env.HOME || "~", ".claude", ".credentials.json");
+  const payload = JSON.stringify({
+    claudeAiOauth: {
+      accessToken: creds.accessToken,
+      refreshToken: creds.refreshToken
+    }
+  }, null, 2);
+  (0, import_fs2.writeFileSync)(credPath, payload, { mode: 384 });
+}
 async function init(opts) {
-  const dir = (0, import_path.resolve)(opts.dir);
-  const O = import_chalk.default.hex("#D97757").bold;
-  const W = import_chalk.default.hex("#EBE6E0").bold;
+  const dir = (0, import_path2.resolve)(opts.dir);
+  const O = import_chalk2.default.hex("#D97757").bold;
+  const W = import_chalk2.default.hex("#EBE6E0").bold;
   console.log("");
   console.log("      " + W("\u2502   \u2502"));
   console.log("   " + W("\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u253C\u2500\u2500\u2500"));
   console.log("  " + O(">") + W(" \u2500\u2500\u253C\u2500\u2500") + O("\u2588") + W("\u253C\u2500\u2500"));
   console.log("      " + W("\u2502   \u2502"));
   console.log("");
-  console.log(import_chalk.default.bold("  SlackHive") + import_chalk.default.gray(" \u2014 AI agent teams on Slack"));
+  console.log(import_chalk2.default.bold("  SlackHive") + import_chalk2.default.gray(" \u2014 AI agent teams on Slack"));
   console.log("");
-  console.log(import_chalk.default.bold.hex("#D97757")("  [1/4]") + import_chalk.default.bold(" Checking prerequisites"));
+  console.log(import_chalk2.default.bold.hex("#D97757")("  [1/4]") + import_chalk2.default.bold(" Checking prerequisites"));
   console.log("");
+  const needsClone = !(0, import_fs2.existsSync)(dir);
   const checks = [
-    { name: "Docker daemon", cmd: "docker info", errMsg: "Docker is not running. Please start Docker Desktop and try again." },
-    { name: "Docker Compose", cmd: "docker compose version", errMsg: "Docker Compose not found. Please install Docker Desktop." },
-    { name: "Git", cmd: "git --version", errMsg: "Git not found. Please install Git first." }
+    { name: "Node.js", cmd: "node --version", errMsg: "Node.js not found. Please install Node.js 20+ first." },
+    ...needsClone ? [{ name: "Git", cmd: "git --version", errMsg: "Git not found. Install Git or download SlackHive manually." }] : []
   ];
   for (const check of checks) {
-    const spinner = (0, import_ora.default)(`  Checking ${check.name}...`).start();
+    const spinner = (0, import_ora2.default)(`  Checking ${check.name}...`).start();
     try {
-      (0, import_child_process.execSync)(check.cmd, { stdio: "ignore" });
-      spinner.succeed(import_chalk.default.green(`${check.name} ready`));
+      (0, import_child_process2.execSync)(check.cmd, { stdio: "ignore" });
+      spinner.succeed(import_chalk2.default.green(`${check.name} ready`));
     } catch {
-      spinner.fail(import_chalk.default.red(`${check.name}: ${check.errMsg}`));
+      spinner.fail(import_chalk2.default.red(`${check.name}: ${check.errMsg}`));
       process.exit(1);
     }
   }
   console.log("");
-  console.log(import_chalk.default.bold.hex("#D97757")("  [2/4]") + import_chalk.default.bold(" Getting SlackHive"));
+  console.log(import_chalk2.default.bold.hex("#D97757")("  [2/4]") + import_chalk2.default.bold(" Getting SlackHive"));
   console.log("");
-  if ((0, import_fs.existsSync)(dir)) {
-    console.log(import_chalk.default.yellow(`  note: Directory ${opts.dir} already exists \u2014 using existing`));
+  if ((0, import_fs2.existsSync)(dir)) {
+    console.log(import_chalk2.default.yellow(`  note: Directory ${opts.dir} already exists \u2014 using existing`));
   } else {
-    const spinner = (0, import_ora.default)("  Cloning repository...").start();
+    const spinner = (0, import_ora2.default)("  Cloning repository...").start();
     try {
-      (0, import_child_process.execSync)(`git clone --depth 1 ${REPO_URL} "${dir}"`, { stdio: "ignore" });
+      (0, import_child_process2.execSync)(`git clone --depth 1 ${REPO_URL} "${dir}"`, { stdio: "ignore" });
       spinner.succeed("Repository cloned");
     } catch {
       spinner.fail("Failed to clone repository");
@@ -15361,10 +15732,10 @@ async function init(opts) {
     }
   }
   console.log("");
-  const envPath = (0, import_path.join)(dir, ".env");
-  const freshEnv = !(0, import_fs.existsSync)(envPath);
+  const envPath = (0, import_path2.join)(dir, ".env");
+  const freshEnv = !(0, import_fs2.existsSync)(envPath);
   if (freshEnv) {
-    console.log(import_chalk.default.bold.hex("#D97757")("  [3/4]") + import_chalk.default.bold(" Configure environment"));
+    console.log(import_chalk2.default.bold.hex("#D97757")("  [3/4]") + import_chalk2.default.bold(" Configure environment"));
     console.log("");
     const authMode = await (0, import_prompts.default)({
       type: "select",
@@ -15376,7 +15747,7 @@ async function init(opts) {
       ]
     });
     if (!authMode.mode) {
-      console.log(import_chalk.default.red("\n  Setup cancelled."));
+      console.log(import_chalk2.default.red("\n  Setup cancelled."));
       process.exit(1);
     }
     const questions = [];
@@ -15389,42 +15760,42 @@ async function init(opts) {
         validate: (v) => v.startsWith("sk-") ? true : "Must start with sk-"
       });
     } else {
-      const claudeDir = (0, import_path.join)(process.env.HOME || "~", ".claude");
-      if (!(0, import_fs.existsSync)(claudeDir)) {
-        console.log(import_chalk.default.yellow("\n  warning: ~/.claude not found. Run `claude login` first, then re-run `slackhive init`."));
+      const claudeDir = (0, import_path2.join)(process.env.HOME || "~", ".claude");
+      if (!(0, import_fs2.existsSync)(claudeDir)) {
+        console.log(import_chalk2.default.yellow("\n  warning: ~/.claude not found. Run `claude login` first, then re-run `slackhive init`."));
         process.exit(1);
       }
-      console.log(import_chalk.default.green("  \u2713") + " Found ~/.claude credentials");
-      const spinner = (0, import_ora.default)("  Extracting OAuth credentials...").start();
+      console.log(import_chalk2.default.green("  \u2713") + " Found ~/.claude credentials");
+      const spinner = (0, import_ora2.default)("  Extracting OAuth credentials...").start();
       oauthCreds = extractOAuthCredentials();
       if (oauthCreds) {
         spinner.succeed("OAuth credentials extracted");
+        syncCredentialsFile(oauthCreds);
       } else {
         spinner.warn("Could not auto-extract credentials from keychain");
-        console.log(import_chalk.default.gray("  On Linux/headless servers, paste your OAuth token manually."));
-        console.log(import_chalk.default.gray("  Get it from a machine where you ran `claude login`:"));
-        console.log(import_chalk.default.gray('    security find-generic-password -s "Claude Code-credentials" -w'));
+        console.log(import_chalk2.default.gray("  On Linux/headless servers, paste your OAuth token manually."));
+        console.log(import_chalk2.default.gray("  Get it from a machine where you ran `claude login`:"));
+        console.log(import_chalk2.default.gray('    security find-generic-password -s "Claude Code-credentials" -w'));
         console.log("");
         const tokenResponse = await (0, import_prompts.default)([
           { type: "password", name: "accessToken", message: "OAuth access token (sk-ant-oat01-...)", validate: (v) => v.startsWith("sk-ant-oat") ? true : "Must start with sk-ant-oat" },
           { type: "password", name: "refreshToken", message: "OAuth refresh token (sk-ant-ort01-...)", validate: (v) => v.startsWith("sk-ant-ort") ? true : "Must start with sk-ant-ort" }
         ]);
         if (!tokenResponse.accessToken || !tokenResponse.refreshToken) {
-          console.log(import_chalk.default.red("\n  Setup cancelled. Use API Key mode instead on headless servers."));
+          console.log(import_chalk2.default.red("\n  Setup cancelled. Use API Key mode instead on headless servers."));
           process.exit(1);
         }
         oauthCreds = { accessToken: tokenResponse.accessToken, refreshToken: tokenResponse.refreshToken };
+        syncCredentialsFile(oauthCreds);
       }
     }
     questions.push(
       { type: "text", name: "adminUsername", message: "Admin username", initial: "admin" },
-      { type: "password", name: "adminPassword", message: "Admin password", validate: (v) => v.length >= 6 ? true : "At least 6 characters" },
-      { type: "text", name: "postgresPassword", message: "Postgres password", initial: randomSecret().slice(0, 16) },
-      { type: "text", name: "redisPassword", message: "Redis password", initial: randomSecret().slice(0, 16) }
+      { type: "password", name: "adminPassword", message: "Admin password", validate: (v) => v.length >= 6 ? true : "At least 6 characters" }
     );
     const response = await (0, import_prompts.default)(questions);
     if (!response.adminPassword) {
-      console.log(import_chalk.default.red("\n  Setup cancelled."));
+      console.log(import_chalk2.default.red("\n  Setup cancelled."));
       process.exit(1);
     }
     let envContent = "# Generated by slackhive init\n\n";
@@ -15432,22 +15803,13 @@ async function init(opts) {
       envContent += `ANTHROPIC_API_KEY=${response.anthropicKey}
 `;
     } else {
-      envContent += `# Claude Code subscription \u2014 OAuth credentials from keychain
-`;
-      envContent += `CLAUDE_CODE_OAUTH_TOKEN=${oauthCreds.accessToken}
-`;
-      envContent += `CLAUDE_CODE_OAUTH_REFRESH_TOKEN=${oauthCreds.refreshToken}
+      envContent += `# Claude Code subscription \u2014 auth handled by system (claude login)
 `;
     }
     envContent += `
-POSTGRES_DB=slackhive
+# SQLite, no Docker required
 `;
-    envContent += `POSTGRES_USER=slackhive
-`;
-    envContent += `POSTGRES_PASSWORD=${response.postgresPassword}
-`;
-    envContent += `
-REDIS_PASSWORD=${response.redisPassword}
+    envContent += `DATABASE_TYPE=sqlite
 `;
     envContent += `
 ADMIN_USERNAME=${response.adminUsername}
@@ -15461,322 +15823,149 @@ ADMIN_USERNAME=${response.adminUsername}
     envContent += `
 NODE_ENV=production
 `;
-    (0, import_fs.writeFileSync)(envPath, envContent);
+    (0, import_fs2.writeFileSync)(envPath, envContent);
     console.log("");
-    console.log(import_chalk.default.green("  \u2713") + " .env file created");
+    console.log(import_chalk2.default.green("  \u2713") + " .env file created");
     console.log("");
   } else {
-    console.log(import_chalk.default.bold.hex("#D97757")("  [3/4]") + import_chalk.default.bold(" Configure environment"));
+    console.log(import_chalk2.default.bold.hex("#D97757")("  [3/4]") + import_chalk2.default.bold(" Configure environment"));
     console.log("");
-    const envContents = (0, import_fs.existsSync)(envPath) ? require("fs").readFileSync(envPath, "utf-8") : "";
+    let envContents = (0, import_fs2.existsSync)(envPath) ? (0, import_fs2.readFileSync)(envPath, "utf-8") : "";
     const missingKeys = [];
-    if (!envContents.includes("REDIS_PASSWORD=")) missingKeys.push("REDIS_PASSWORD");
     if (!envContents.includes("AUTH_SECRET=")) missingKeys.push("AUTH_SECRET");
     if (!envContents.includes("ENV_SECRET_KEY=")) missingKeys.push("ENV_SECRET_KEY");
     if (missingKeys.length > 0) {
-      console.log(import_chalk.default.yellow(`  warning: .env is missing: ${missingKeys.join(", ")} \u2014 patching...`));
+      console.log(import_chalk2.default.yellow(`  warning: .env is missing: ${missingKeys.join(", ")} \u2014 patching...`));
       let patch = "";
-      if (!envContents.includes("REDIS_PASSWORD=")) patch += `
-REDIS_PASSWORD=${randomSecret().slice(0, 16)}
-`;
       if (!envContents.includes("AUTH_SECRET=")) patch += `AUTH_SECRET=${randomSecret()}
 `;
       if (!envContents.includes("ENV_SECRET_KEY=")) patch += `ENV_SECRET_KEY=${randomSecret()}
 `;
       require("fs").appendFileSync(envPath, patch);
-      console.log(import_chalk.default.green("  \u2713") + " .env patched");
+      envContents = (0, import_fs2.readFileSync)(envPath, "utf-8");
+      console.log(import_chalk2.default.green("  \u2713") + " .env patched");
+    }
+    if (envContents.includes("CLAUDE_CODE_OAUTH_TOKEN=")) {
+      const spinner = (0, import_ora2.default)("  Syncing OAuth credentials...").start();
+      const freshCreds = extractOAuthCredentials();
+      if (freshCreds) {
+        envContents = envContents.replace(/CLAUDE_CODE_OAUTH_TOKEN=.*/, `CLAUDE_CODE_OAUTH_TOKEN=${freshCreds.accessToken}`).replace(/CLAUDE_CODE_OAUTH_REFRESH_TOKEN=.*/, `CLAUDE_CODE_OAUTH_REFRESH_TOKEN=${freshCreds.refreshToken}`);
+        (0, import_fs2.writeFileSync)(envPath, envContents);
+        syncCredentialsFile(freshCreds);
+        spinner.succeed("OAuth credentials synced");
+      } else {
+        spinner.warn("Could not extract credentials \u2014 run `claude login` if agents fail to authenticate");
+      }
     } else {
-      console.log(import_chalk.default.yellow("  note: .env already exists \u2014 skipping configuration"));
+      console.log(import_chalk2.default.yellow("  note: .env already exists \u2014 skipping configuration"));
     }
     console.log("");
   }
   let webReady = true;
   if (!opts.skipStart) {
-    console.log(import_chalk.default.bold.hex("#D97757")("  [4/4]") + import_chalk.default.bold(" Building & starting services"));
-    console.log(import_chalk.default.gray("  This takes 3\u20135 minutes on first run while Docker builds images."));
+    console.log(import_chalk2.default.bold.hex("#D97757")("  [4/4]") + import_chalk2.default.bold(" Installing & starting"));
+    console.log(import_chalk2.default.gray("  Installing dependencies and building TypeScript..."));
     console.log("");
+    (0, import_fs2.writeFileSync)((0, import_path2.join)(dir, ".slackhive-native"), "native");
+    const installSpinner = (0, import_ora2.default)("  Installing npm dependencies...").start();
     try {
-      const dfOut = (0, import_child_process.execSync)('docker system df --format "{{.Size}}"', { encoding: "utf-8" });
-      void dfOut;
-    } catch {
-      console.log(import_chalk.default.yellow("  note: Could not check Docker disk usage \u2014 continuing anyway"));
+      (0, import_child_process2.execSync)("npm install", { cwd: dir, stdio: "ignore", timeout: 18e4 });
+      installSpinner.succeed("Dependencies installed");
+    } catch (err) {
+      installSpinner.fail("npm install failed");
+      console.log(import_chalk2.default.red(`  ${err.message}`));
+      webReady = false;
     }
-    try {
-      const df = (0, import_child_process.execSync)("df -k . | tail -1", { encoding: "utf-8" }).trim();
-      const available = parseInt(df.split(/\s+/)[3]);
-      if (!isNaN(available) && available < 3 * 1024 * 1024) {
-        console.log(import_chalk.default.yellow(`  warning: less than 3GB disk space available. Build may fail.`));
-        console.log("");
+    if (webReady) {
+      const buildSpinner = (0, import_ora2.default)("  Building TypeScript...").start();
+      try {
+        (0, import_child_process2.execSync)("npm run build -w packages/shared -w cli && npx tsc --project apps/runner/tsconfig.json --skipLibCheck", { cwd: dir, stdio: "ignore", timeout: 12e4 });
+        buildSpinner.succeed("Build complete");
+      } catch (err) {
+        buildSpinner.fail("Build failed");
+        console.log(import_chalk2.default.red(`  ${err.message}`));
+        webReady = false;
       }
-    } catch {
     }
-    if (freshEnv) {
+    if (webReady) {
+      const nextSpinner = (0, import_ora2.default)("  Building Next.js web app...").start();
       try {
-        (0, import_child_process.execSync)("docker compose down -v", { cwd: dir, stdio: "ignore" });
-      } catch {
+        const envPath2 = (0, import_path2.join)(dir, ".env");
+        const envVars = { ...process.env };
+        if ((0, import_fs2.existsSync)(envPath2)) {
+          for (const line of (0, import_fs2.readFileSync)(envPath2, "utf-8").split("\n")) {
+            const t = line.trim();
+            if (!t || t.startsWith("#")) continue;
+            const eq = t.indexOf("=");
+            if (eq > 0) envVars[t.slice(0, eq)] = t.slice(eq + 1);
+          }
+        }
+        (0, import_child_process2.execSync)("npx next build", {
+          cwd: (0, import_path2.join)(dir, "apps", "web"),
+          stdio: "ignore",
+          timeout: 3e5,
+          env: envVars
+        });
+        nextSpinner.succeed("Web app built");
+      } catch (err) {
+        nextSpinner.fail("Next.js build failed");
+        console.log(import_chalk2.default.red(`  ${err.message}`));
+        webReady = false;
       }
     }
-    const buildOk = await runDockerBuild(dir, opts.dir);
-    if (buildOk) {
+    if (webReady) {
+      const startSpinner = (0, import_ora2.default)("  Starting SlackHive...").start();
       try {
-        (0, import_child_process.execSync)("docker compose up -d", { cwd: dir, stdio: "ignore" });
+        const manage = (init_manage(), __toCommonJS(manage_exports));
+        process.chdir(dir);
+        startSpinner.succeed("SlackHive started");
       } catch {
-      }
-      const webSpinner = (0, import_ora.default)("  Waiting for web UI to be ready...").start();
-      let ready = false;
-      for (let i = 0; i < 60; i++) {
-        try {
-          (0, import_child_process.execSync)("curl -sf http://localhost:3001/login", { stdio: "ignore" });
-          ready = true;
-          break;
-        } catch {
-          await sleep(3e3);
-        }
-      }
-      if (ready) {
-        webSpinner.succeed("Web UI is ready");
-      } else {
+        startSpinner.warn("Auto-start skipped \u2014 run `slackhive start` manually");
         webReady = false;
-        webSpinner.stopAndPersist({ symbol: " " });
       }
-    } else {
-      webReady = false;
     }
   }
   console.log("");
   if (webReady) {
-    console.log("  " + import_chalk.default.bgHex("#D97757").black.bold("  SlackHive is ready!  "));
+    console.log("  " + import_chalk2.default.bgHex("#D97757").black.bold("  SlackHive is ready!  "));
     console.log("");
-    console.log(`  ${import_chalk.default.bold("Open:")}   ${import_chalk.default.cyan("http://localhost:3001")}`);
+    console.log(`  ${import_chalk2.default.bold("Open:")}     ${import_chalk2.default.cyan(`http://localhost:${process.env.PORT ?? "3001"}`)}`);
   } else {
-    console.log("  " + import_chalk.default.bold("Setup complete!"));
+    console.log("  " + import_chalk2.default.bold("Setup complete!"));
     console.log("");
-    console.log(import_chalk.default.gray("  Services are still starting. Once ready:"));
-    console.log(`  ${import_chalk.default.bold("Run:")}    ${import_chalk.default.cyan("slackhive start")}`);
-    console.log(`  ${import_chalk.default.bold("Open:")}   ${import_chalk.default.cyan("http://localhost:3001")}`);
-  }
-  console.log(`  ${import_chalk.default.bold("Dir:")}    ${import_chalk.default.gray(dir)}`);
+    console.log(import_chalk2.default.gray("  Services are still starting. Once ready:"));
+    console.log(`  ${import_chalk2.default.bold("Run:")}      ${import_chalk2.default.cyan("slackhive start")}`);
+    console.log(`  ${import_chalk2.default.bold("Open:")}     ${import_chalk2.default.cyan(`http://localhost:${process.env.PORT ?? "3001"}`)}`);
+  }
+  console.log(`  ${import_chalk2.default.bold("Dir:")}      ${import_chalk2.default.gray(dir)}`);
+  console.log(`  ${import_chalk2.default.bold("Mode:")}     ${import_chalk2.default.gray("Native (SQLite)")}`);
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "/tmp";
+  console.log(`  ${import_chalk2.default.bold("Database:")} ${import_chalk2.default.gray((0, import_path2.join)(home, ".slackhive", "data.db"))}`);
+  console.log(`  ${import_chalk2.default.bold("Logs:")}     ${import_chalk2.default.gray((0, import_path2.join)(home, ".slackhive", "logs", "runner.log"))}`);
   console.log("");
-  console.log(import_chalk.default.gray("  Useful commands:"));
-  console.log(import_chalk.default.gray("    slackhive start    \u2014 Start services"));
-  console.log(import_chalk.default.gray("    slackhive stop     \u2014 Stop services"));
-  console.log(import_chalk.default.gray("    slackhive status   \u2014 Show container status"));
-  console.log(import_chalk.default.gray("    slackhive logs     \u2014 Tail runner logs"));
-  console.log(import_chalk.default.gray("    slackhive update   \u2014 Pull latest & rebuild"));
+  console.log(import_chalk2.default.gray("  Useful commands:"));
+  console.log(import_chalk2.default.gray("    slackhive start    \u2014 Start services"));
+  console.log(import_chalk2.default.gray("    slackhive stop     \u2014 Stop services"));
+  console.log(import_chalk2.default.gray("    slackhive status   \u2014 Show container status"));
+  console.log(import_chalk2.default.gray("    slackhive logs     \u2014 Tail runner logs"));
+  console.log(import_chalk2.default.gray("    slackhive update   \u2014 Pull latest & rebuild"));
   console.log("");
 }
-function runDockerBuild(cwd, displayDir) {
-  return new Promise((resolve2) => {
-    const proc = (0, import_child_process.spawn)("docker", ["compose", "--progress", "plain", "up", "-d", "--build"], {
-      cwd,
-      env: { ...process.env }
-    });
-    const startTime = Date.now();
-    const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-    let frameIdx = 0;
-    const phases = [
-      { name: "Installing system packages", weight: 10, pattern: /apk add|fetch.*APKINDEX/i },
-      { name: "Installing npm dependencies", weight: 30, pattern: /npm ci|npm install|added \d+ packages/i },
-      { name: "Compiling TypeScript", weight: 10, pattern: /tsc|--skipLibCheck/i },
-      { name: "Building web app", weight: 30, pattern: /next build|next\.config/i },
-      { name: "Creating containers", weight: 10, pattern: /exporting to image|naming to|exporting layers/i },
-      { name: "Starting services", weight: 10, pattern: /Container .*(Starting|Started|Healthy|Created)/i }
-    ];
-    let currentPhase = 0;
-    let phaseStartTime = Date.now();
-    function getProgress() {
-      let pct = 0;
-      for (let i = 0; i < currentPhase; i++) pct += phases[i].weight;
-      if (currentPhase < phases.length) {
-        const elapsed = (Date.now() - phaseStartTime) / 1e3;
-        const estimatedDuration = currentPhase === 1 ? 90 : currentPhase === 3 ? 100 : 30;
-        const partial = Math.min(0.9, elapsed / estimatedDuration);
-        pct += phases[currentPhase].weight * partial;
-      }
-      return Math.min(99, Math.round(pct));
-    }
-    function renderBar() {
-      const pct = getProgress();
-      const cols = process.stdout.columns || 80;
-      const barWidth = Math.min(20, Math.max(10, cols - 55));
-      const filled = Math.round(pct / 100 * barWidth);
-      const empty = barWidth - filled;
-      const bar = import_chalk.default.hex("#D97757")("\u2588".repeat(filled)) + import_chalk.default.gray("\u2591".repeat(empty));
-      const elapsed = Math.floor((Date.now() - startTime) / 1e3);
-      const phaseName = currentPhase < phases.length ? phases[currentPhase].name : "Finishing";
-      const frame = frames[frameIdx++ % frames.length];
-      const pctStr = String(pct).padStart(2);
-      return `  ${import_chalk.default.hex("#D97757")(frame)} ${bar} ${import_chalk.default.bold(pctStr + "%")} ${phaseName} ${import_chalk.default.gray("(" + elapsed + "s)")}`;
-    }
-    const spinnerInterval = setInterval(() => {
-      process.stdout.write(`\r\x1B[K${renderBar()}`);
-    }, 80);
-    let buf = "";
-    const errorLines = [];
-    const onData = (chunk) => {
-      buf += chunk.toString().replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
-      const lines = buf.split("\n");
-      buf = lines.pop() ?? "";
-      for (const raw of lines) {
-        const line = raw.trim();
-        if (!line) continue;
-        for (let i = currentPhase + 1; i < phases.length; i++) {
-          if (phases[i].pattern.test(line)) {
-            const elapsed = Math.floor((Date.now() - phaseStartTime) / 1e3);
-            process.stdout.write("\r\x1B[K");
-            console.log("  " + import_chalk.default.green("\u2713") + " " + phases[currentPhase].name + import_chalk.default.gray(` (${elapsed}s)`));
-            for (let j = currentPhase + 1; j < i; j++) {
-              console.log("  " + import_chalk.default.green("\u2713") + " " + phases[j].name + import_chalk.default.gray(" (cached)"));
-            }
-            currentPhase = i;
-            phaseStartTime = Date.now();
-            break;
-          }
-        }
-        if (/error/i.test(line)) errorLines.push(line);
-      }
-    };
-    proc.stdout.on("data", onData);
-    proc.stderr.on("data", onData);
-    proc.on("close", (code) => {
-      clearInterval(spinnerInterval);
-      process.stdout.write("\r\x1B[K");
-      if (code === 0) {
-        const elapsed = Math.floor((Date.now() - phaseStartTime) / 1e3);
-        if (currentPhase < phases.length) {
-          console.log("  " + import_chalk.default.green("\u2713") + " " + phases[currentPhase].name + import_chalk.default.gray(` (${elapsed}s)`));
-          for (let j = currentPhase + 1; j < phases.length; j++) {
-            console.log("  " + import_chalk.default.green("\u2713") + " " + phases[j].name);
-          }
-        }
-        console.log("");
-        console.log("  " + import_chalk.default.green("\u2713") + import_chalk.default.bold(" All services started"));
-        resolve2(true);
-        return;
-      }
-      console.log("  " + import_chalk.default.red("\u2717") + " Failed to start services");
-      console.log("");
-      const allErrors = errorLines.join("\n").toLowerCase();
-      if (allErrors.includes("no space left") || allErrors.includes("disk full")) {
-        console.log(import_chalk.default.yellow("  Cause: Docker is out of disk space."));
-        console.log(import_chalk.default.gray("  Fix:   docker system prune -a"));
-      } else if (allErrors.includes("port is already allocated") || allErrors.includes("address already in use")) {
-        const portMatch = /bind for .+:(\d+)/.exec(allErrors);
-        const port = portMatch ? portMatch[1] : "a required port";
-        console.log(import_chalk.default.yellow(`  Cause: Port ${port} is already in use.`));
-        console.log(import_chalk.default.gray(`  Fix:   stop the process on port ${port} and retry`));
-      } else if (allErrors.includes("permission denied") || allErrors.includes("unauthorized")) {
-        console.log(import_chalk.default.yellow("  Cause: Docker permission denied \u2014 is Docker Desktop running?"));
-      } else if (allErrors.includes("memory") || allErrors.includes("oom")) {
-        console.log(import_chalk.default.yellow("  Cause: Docker ran out of memory."));
-        console.log(import_chalk.default.gray("  Fix:   increase Docker Desktop memory to 4GB+ in Settings \u2192 Resources"));
-      } else if (allErrors.includes("network") || allErrors.includes("timeout") || allErrors.includes("pull") || allErrors.includes("tls") || allErrors.includes("certificate")) {
-        console.log(import_chalk.default.yellow("  Cause: Network/TLS error \u2014 try restarting Docker Desktop."));
-      } else if (errorLines.length > 0) {
-        console.log(import_chalk.default.gray("  Error details:"));
-        errorLines.slice(-5).forEach((l) => console.log(import_chalk.default.red("    " + l)));
-      }
-      console.log("");
-      console.log(import_chalk.default.gray(`  To retry: cd ${displayDir} && docker compose up -d --build`));
-      resolve2(false);
-    });
-  });
-}
 function randomSecret() {
   const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
   let result = "";
   for (let i = 0; i < 32; i++) result += chars.charAt(Math.floor(Math.random() * chars.length));
   return result;
 }
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-
-// src/commands/manage.ts
-var import_child_process2 = require("child_process");
-var import_fs2 = require("fs");
-var import_path2 = require("path");
-var import_chalk2 = __toESM(require_source());
-var import_ora2 = __toESM(require_ora());
-function findProjectDir() {
-  if ((0, import_fs2.existsSync)((0, import_path2.join)(process.cwd(), "docker-compose.yml"))) {
-    return process.cwd();
-  }
-  const sub = (0, import_path2.join)(process.cwd(), "slackhive");
-  if ((0, import_fs2.existsSync)((0, import_path2.join)(sub, "docker-compose.yml"))) {
-    return sub;
-  }
-  console.log(import_chalk2.default.red("  Could not find SlackHive project."));
-  console.log(import_chalk2.default.gray("  Run this command from the SlackHive directory, or run `slackhive init` first."));
-  process.exit(1);
-}
-async function start() {
-  const dir = findProjectDir();
-  const spinner = (0, import_ora2.default)("Starting SlackHive services...").start();
-  try {
-    (0, import_child_process2.execSync)("docker compose up -d", { cwd: dir, stdio: "ignore" });
-    spinner.succeed("All services started");
-    console.log(import_chalk2.default.gray("  Web UI: http://localhost:3001"));
-  } catch {
-    spinner.fail("Failed to start services");
-  }
-}
-async function stop() {
-  const dir = findProjectDir();
-  const spinner = (0, import_ora2.default)("Stopping SlackHive services...").start();
-  try {
-    (0, import_child_process2.execSync)("docker compose stop", { cwd: dir, stdio: "ignore" });
-    spinner.succeed("All services stopped");
-  } catch {
-    spinner.fail("Failed to stop services");
-  }
-}
-async function status() {
-  const dir = findProjectDir();
-  try {
-    const output = (0, import_child_process2.execSync)("docker compose ps", { cwd: dir, encoding: "utf-8" });
-    console.log("");
-    console.log(import_chalk2.default.bold("  SlackHive Status"));
-    console.log("");
-    console.log(output);
-  } catch {
-    console.log(import_chalk2.default.red("  Failed to get status"));
-  }
-}
-async function logs(opts) {
-  const dir = findProjectDir();
-  const args = ["compose", "logs", "runner"];
-  if (opts.follow !== false) args.push("-f");
-  const proc = (0, import_child_process2.spawn)("docker", args, { cwd: dir, stdio: "inherit" });
-  proc.on("error", () => console.log(import_chalk2.default.red("  Failed to tail logs")));
-}
-async function update() {
-  const dir = findProjectDir();
-  const pullSpinner = (0, import_ora2.default)("Pulling latest changes...").start();
-  try {
-    (0, import_child_process2.execSync)("git pull", { cwd: dir, stdio: "ignore" });
-    pullSpinner.succeed("Code updated");
-  } catch {
-    pullSpinner.fail("Failed to pull \u2014 do you have uncommitted changes?");
-    return;
-  }
-  const buildSpinner = (0, import_ora2.default)("Rebuilding services (this may take a minute)...").start();
-  try {
-    (0, import_child_process2.execSync)("docker compose up -d --build", { cwd: dir, stdio: "ignore", timeout: 6e5 });
-    buildSpinner.succeed("Services rebuilt and restarted");
-    console.log(import_chalk2.default.gray("  Web UI: http://localhost:3001"));
-  } catch {
-    buildSpinner.fail("Failed to rebuild");
-  }
-}
 
 // src/index.ts
+init_manage();
 var { version } = require_package();
 var program2 = new Command();
 program2.name("slackhive").description("CLI to install and manage SlackHive \u2014 AI agent teams on Slack").version(version);
 program2.command("init").description("Clone SlackHive repo, configure environment, and start services").option("-d, --dir <path>", "Directory to install into", "slackhive").option("--skip-start", "Skip starting services after init").action(init);
 program2.command("start").description("Start all SlackHive services").action(start);
-program2.command("stop").description("Stop all SlackHive services").action(stop);
+program2.command("stop").description("Stop all SlackHive services (also kills orphaned runner processes)").action(stop);
 program2.command("status").description("Show running SlackHive containers").action(status);
 program2.command("logs").description("Tail runner service logs").option("-f, --follow", "Follow log output", true).action(logs);
 program2.command("update").description("Pull latest changes and rebuild").action(update);