flyspace-cli 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+declare function startServer(): Promise<void>;
+
+export { startServer };

package/dist/index.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import {
+  startServer
+} from "./chunk-DCCECKHH.js";
+import "./chunk-QZIN7MWV.js";
+export {
+  startServer
+};

package/dist/threads-EQGJZF44.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+import {
+  listChannels,
+  moveThread
+} from "./chunk-X7SJ653V.js";
+import {
+  getSupabaseClient,
+  postToDashboardChannel
+} from "./chunk-QZIN7MWV.js";
+
+// src/mcp/servers/threads.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+var DEFAULT_SEARCH_LIMIT = 10;
+var MAX_SEARCH_LIMIT = 30;
+var SNIPPET_MAX = 300;
+var MAX_REPLIES = 100;
+function truncate(text, max) {
+  const flat = text.replaceAll(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max)}\u2026` : flat;
+}
+function formatHits(hits, query) {
+  if (!hits.length) return `No threads matching "${query}".`;
+  return [
+    `${hits.length} thread${hits.length === 1 ? "" : "s"} matching "${query}":`,
+    "",
+    ...hits.map((hit) => {
+      const when = hit.createdAt.slice(0, 10);
+      const title = hit.title?.trim() || "(untitled)";
+      const snippet = truncate(hit.snippet, SNIPPET_MAX);
+      const body = snippet && snippet !== truncate(title, SNIPPET_MAX) ? `
+  ${snippet}` : "";
+      return `- **${title}** \u2014 ${hit.author}, ${when}${body}
+  id: \`${hit.id}\``;
+    })
+  ].join("\n");
+}
+function clampLimit(raw) {
+  if (typeof raw !== "number" || !Number.isFinite(raw)) return DEFAULT_SEARCH_LIMIT;
+  return Math.min(Math.max(Math.trunc(raw), 1), MAX_SEARCH_LIMIT);
+}
+function rowsToHits(rows, channelId) {
+  return rows.filter((row) => !channelId || row.channel_id === channelId).map((row) => ({
+    id: row.id,
+    channelId: row.channel_id,
+    title: row.title,
+    snippet: row.snippet ?? "",
+    author: row.author ?? "unknown",
+    createdAt: row.created_at
+  }));
+}
+async function searchThreads(query, limit, channelId) {
+  const matchLimit = channelId ? Math.min(limit * 5, 100) : limit;
+  const { data, error } = await getSupabaseClient().rpc("search_threads", {
+    q: query,
+    match_limit: matchLimit
+  });
+  if (error) throw new Error(`search failed: ${error.message}`);
+  return formatHits(rowsToHits(data ?? [], channelId).slice(0, limit), query);
+}
+function formatThread(thread, replies) {
+  const lines = [
+    `# ${thread.title?.trim() || "(untitled)"}`,
+    "",
+    `**${thread.author ?? "unknown"}** \xB7 ${thread.created_at.slice(0, 16).replace("T", " ")}`,
+    "",
+    thread.body?.trim() || "(no body)"
+  ];
+  if (replies.length) {
+    lines.push("", `## ${replies.length} repl${replies.length === 1 ? "y" : "ies"}`, "");
+    for (const reply of replies) {
+      lines.push(
+        `**${reply.author ?? "unknown"}** \xB7 ${reply.created_at.slice(0, 16).replace("T", " ")}`,
+        "",
+        reply.body?.trim() || "(empty)",
+        ""
+      );
+    }
+  }
+  return lines.join("\n");
+}
+async function readThread(threadId) {
+  const supabase = getSupabaseClient();
+  const { data: thread, error } = await supabase.from("threads").select("title, author, body, created_at").eq("id", threadId).maybeSingle();
+  if (error) throw new Error(`read failed: ${error.message}`);
+  if (!thread) return `No thread with id ${threadId}.`;
+  const { data: replies, error: repliesError } = await supabase.from("thread_replies").select("author, body, created_at").eq("thread_id", threadId).order("created_at", { ascending: true }).limit(MAX_REPLIES);
+  if (repliesError) throw new Error(`read failed: ${repliesError.message}`);
+  return formatThread(
+    thread,
+    replies ?? []
+  );
+}
+var TOOLS = [
+  {
+    name: "search_threads",
+    description: "Full-text search across this workspace's chat threads and replies. Use it to recall earlier decisions and discussions that are not in the current thread. Returns thread titles with a matching snippet and an id for read_thread.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Words to search for." },
+        channel_id: {
+          type: "string",
+          description: "Optional: restrict results to one channel id."
+        },
+        limit: {
+          type: "number",
+          description: `Maximum results (default ${DEFAULT_SEARCH_LIMIT}, max ${MAX_SEARCH_LIMIT}).`
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "read_thread",
+    description: "Read one thread in full: the opening message and its replies in order. Takes an id from search_threads.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        thread_id: { type: "string", description: "The thread id." }
+      },
+      required: ["thread_id"]
+    }
+  },
+  {
+    name: "list_channels",
+    description: "List this workspace's dashboard channels (id, name, working directory). Use it to find a channel id for create_thread or move_thread when you only have a name.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "create_thread",
+    description: "Start a new thread in a dashboard channel. Works in any channel, whether or not it has a Slack binding \u2014 use this instead of posting to Slack when you just need a Workspace thread. Returns the new thread id.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        channel_id: { type: "string", description: "Target channel id (see list_channels)." },
+        text: { type: "string", description: "The thread's opening message." },
+        title: {
+          type: "string",
+          description: "Optional thread title. Without one, the title is derived from `text`."
+        }
+      },
+      required: ["channel_id", "text"]
+    }
+  },
+  {
+    name: "post_reply",
+    description: "Reply to an existing thread. Takes an id from search_threads or create_thread.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        thread_id: { type: "string", description: "The thread id to reply in." },
+        text: { type: "string", description: "The reply body." }
+      },
+      required: ["thread_id", "text"]
+    }
+  },
+  {
+    name: "move_thread",
+    description: "Move a thread to a different channel.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        thread_id: { type: "string", description: "The thread to move." },
+        to_channel_id: { type: "string", description: "Destination channel id." }
+      },
+      required: ["thread_id", "to_channel_id"]
+    }
+  }
+];
+async function startThreadsServer() {
+  const server = new Server(
+    { name: "flyspace-threads", version: "1.0.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const args = request.params.arguments ?? {};
+    try {
+      if (request.params.name === "search_threads") {
+        const query = typeof args["query"] === "string" ? args["query"].trim() : "";
+        if (!query) throw new Error("query is required");
+        const channelId = typeof args["channel_id"] === "string" ? args["channel_id"] : void 0;
+        const text = await searchThreads(query, clampLimit(args["limit"]), channelId);
+        return { content: [{ type: "text", text }] };
+      }
+      if (request.params.name === "read_thread") {
+        const threadId = typeof args["thread_id"] === "string" ? args["thread_id"].trim() : "";
+        if (!threadId) throw new Error("thread_id is required");
+        return { content: [{ type: "text", text: await readThread(threadId) }] };
+      }
+      if (request.params.name === "list_channels") {
+        const channels = await listChannels();
+        const text = channels.length ? channels.map((c) => `- **${c.name}** (${c.profile}) id: \`${c.id}\``).join("\n") : "No channels found.";
+        return { content: [{ type: "text", text }] };
+      }
+      if (request.params.name === "create_thread") {
+        const channelId = typeof args["channel_id"] === "string" ? args["channel_id"].trim() : "";
+        const text = typeof args["text"] === "string" ? args["text"] : "";
+        if (!channelId || !text) throw new Error("channel_id and text are required");
+        const title = typeof args["title"] === "string" ? args["title"] : void 0;
+        const threadId = await postToDashboardChannel({ channelId, text, title });
+        return { content: [{ type: "text", text: `Created thread ${threadId}.` }] };
+      }
+      if (request.params.name === "post_reply") {
+        const threadId = typeof args["thread_id"] === "string" ? args["thread_id"].trim() : "";
+        const text = typeof args["text"] === "string" ? args["text"] : "";
+        if (!threadId || !text) throw new Error("thread_id and text are required");
+        await postToDashboardChannel({ threadId, text });
+        return { content: [{ type: "text", text: `Replied in thread ${threadId}.` }] };
+      }
+      if (request.params.name === "move_thread") {
+        const threadId = typeof args["thread_id"] === "string" ? args["thread_id"].trim() : "";
+        const toChannelId = typeof args["to_channel_id"] === "string" ? args["to_channel_id"].trim() : "";
+        if (!threadId || !toChannelId) throw new Error("thread_id and to_channel_id are required");
+        await moveThread(threadId, toChannelId);
+        return { content: [{ type: "text", text: `Moved thread ${threadId} to ${toChannelId}.` }] };
+      }
+      throw new Error(`unknown tool: ${request.params.name}`);
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: `Error: ${err.message}` }],
+        isError: true
+      };
+    }
+  });
+  await server.connect(new StdioServerTransport());
+  console.error("[flyspace-threads] ready on stdio");
+}
+export {
+  clampLimit,
+  formatHits,
+  formatThread,
+  rowsToHits,
+  startThreadsServer
+};

package/hooks/bash-guard.mjs

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+// PreToolUse(Bash) guard for Custie. Three jobs, all aimed at the same class of
+// failure: a single Bash tool call that kills the turn before it can answer.
+//
+//   0. BLOCK a synchronous restart/stop of the service HOSTING this run. The
+//      agent lives inside `ai.flyspace.dashboard` (or `ai.flyspace*`), so a
+//      `launchctl kickstart -k <own label>` is suicide: the process dies
+//      mid-tool-call and the reply is never written. Seen in the wild on
+//      2026-08-09 — a `pnpm build && launchctl kickstart -k … && curl …` chain
+//      ate a four-minute run without a trace in the thread.
+//   1. BLOCK foreground-forever commands (`pnpm dev`, `tail -f`, a watcher, an
+//      undetached `docker run`). These never exit by design — tell the model to
+//      background them instead.
+//   2. WRAP everything else in `timeout` so a command that is SUPPOSED to exit
+//      but unexpectedly hangs (a browser-automation / CDP / network script like
+//      `node scripts/cia-query.mjs`) gets killed after a bounded time instead of
+//      eating the turn. Only simple commands are wrapped — see below.
+//
+// Wired in via `agent.ts` (`--settings` with a PreToolUse hook). Applies ONLY to
+// Custie's CLI invocations, never to the user's own Claude Code.
+//
+// Protocol: read the hook payload as JSON on stdin.
+//   - exit 0 (no output)            -> allow unchanged
+//   - exit 2 (+ stderr)             -> block; stderr is the reason shown to the model
+//   - exit 0 + JSON updatedInput    -> allow, but run the rewritten command
+
+import { readFileSync, existsSync } from 'node:fs';
+
+function allow() {
+  process.exit(0);
+}
+
+function readStdin() {
+  try {
+    return readFileSync(0, 'utf-8');
+  } catch {
+    return '';
+  }
+}
+
+let toolInput = {};
+let command = '';
+try {
+  const payload = JSON.parse(readStdin() || '{}');
+  toolInput = payload?.tool_input ?? {};
+  command = String(toolInput.command ?? '');
+} catch {
+  // Unparseable payload: fail open so we never wedge a turn over a guard bug.
+  allow();
+}
+
+if (!command.trim()) allow();
+
+// --- 0. Self-restart guard: never synchronously stop the service hosting us ---
+// Runs BEFORE the already-safe check below, because `timeout 60 launchctl
+// kickstart -k <self>` is exactly as fatal as the unwrapped version.
+//
+// The owning label comes from `FLYSPACE_SELF_SERVICE_LABEL`, injected by
+// agent.ts from launchd's `XPC_SERVICE_NAME` (which launchd exports into every
+// process a job starts). `XPC_SERVICE_NAME` is read as a fallback for a
+// hand-run CLI. launchd sets it to `0` for processes it did not start, and a
+// dev run from a terminal has neither — both mean "nothing to protect".
+const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+const selfLabel = (
+  process.env.FLYSPACE_SELF_SERVICE_LABEL ||
+  process.env.XPC_SERVICE_NAME ||
+  ''
+).trim();
+
+/**
+ * The one accepted escape hatch: hand the restart to `restart-when-idle.sh`,
+ * detached.
+ *
+ * A detached-but-fixed-delay restart (`nohup bash -c 'sleep 20; launchctl …'`)
+ * is NOT accepted, though it was at first. It protects the run that scheduled
+ * it and nothing else: on 2026-08-09 one such restart killed a run that started
+ * in a *different* thread 5 seconds after it was scheduled. The restarter polls
+ * `/api/busy` instead, so it waits on every conversation, not just its own.
+ *
+ * Detachment is still required — attached, the caller's own run keeps the
+ * in-flight count above zero, and the script would wait out its whole timeout.
+ */
+// Matches the script being RUN, not merely named: at the start of a line or a
+// command, or as an argument to a shell. Without that anchoring, a heredoc or
+// comment that mentions the script (writing a test for it, say) reads as an
+// invocation and gets caught by the attached-restarter branch below.
+const INVOKES_RESTARTER = /(?:^|[;&|]\s*|\b(?:bash|sh|zsh)\s+)(?:\S*\/)?restart-when-idle\.sh\b/m;
+
+function usesIdleRestarter(cmd) {
+  if (!INVOKES_RESTARTER.test(cmd)) return false;
+  return /\bnohup\b/.test(cmd) && (/\bdisown\b/.test(cmd) || /(^|[^&|>])&\s*$/.test(cmd));
+}
+
+if (selfLabel && selfLabel !== '0' && !usesIdleRestarter(command)) {
+  // The restarter itself, run attached: it would poll for an idle workspace
+  // that cannot arrive, because the run waiting on it is the one keeping the
+  // count above zero. Worth its own message — the generic one below would send
+  // the model straight back to the command it just wrote.
+  if (INVOKES_RESTARTER.test(command)) {
+    process.stderr.write(
+      `Blocked: \`restart-when-idle.sh\` has to be detached, and this invocation is not.\n\n` +
+        `It waits for zero in-flight agent runs before restarting. Your own run counts, ` +
+        `so run attached it can never see zero — it would just block this turn until it ` +
+        `times out.\n\n` +
+        `  nohup bash scripts/restart-when-idle.sh > /dev/null 2>&1 & disown\n\n` +
+        `Then finish your turn. Progress is logged to /tmp/flyspace-restart.log.`,
+    );
+    process.exit(2);
+  }
+
+  const label = escapeRegex(selfLabel);
+  // The label also appears inside the plist path (`~/Library/LaunchAgents/
+  // ai.flyspace.dashboard.plist`), so a plain substring match covers
+  // `launchctl unload <plist>` as well as the `gui/<uid>/<label>` forms.
+  const SELF_LIFECYCLE = [
+    {
+      re: new RegExp(`\\blaunchctl\\s+(kickstart|bootout|unload|stop|kill|remove)\\b[^\\n]*${label}`),
+      hint: `launchctl on ${selfLabel}`,
+    },
+    {
+      re: new RegExp(`\\bsystemctl\\b[^\\n]*\\b(restart|stop|kill)\\b[^\\n]*${label}`),
+      hint: `systemctl on ${selfLabel}`,
+    },
+    {
+      re: new RegExp(`\\bsystemctl\\b[^\\n]*${label}[^\\n]*\\b(restart|stop|kill)\\b`),
+      hint: `systemctl on ${selfLabel}`,
+    },
+    // `pkill -f flyspace` / `killall node` sweep up this very process too.
+    { re: /\b(pkill|killall)\b[^\n]*\b(flyspace|custie)\b/, hint: 'pkill/killall matching this process' },
+    { re: /\b(pkill|killall)\s+(-\S+\s+)*node\b/, hint: 'killall node (this process is node)' },
+  ];
+
+  const selfKill = SELF_LIFECYCLE.find(({ re }) => re.test(command));
+  if (selfKill) {
+    process.stderr.write(
+      `Blocked: this would stop the service that is RUNNING YOU (${selfKill.hint}).\n\n` +
+        `You are executing inside \`${selfLabel}\`, and so is every other agent run ` +
+        `happening right now. Restarting it SIGKILLs all of them mid-tool-call: the ` +
+        `rest of your chain is skipped, no reply is written, and other people's ` +
+        `threads go silent too. A fixed \`sleep N\` does not fix this — it only covers ` +
+        `your own run, and a message landing in another thread inside that window ` +
+        `still dies.\n\n` +
+        `Use the idle-aware restarter, which waits for zero in-flight runs:\n` +
+        `  nohup bash scripts/restart-when-idle.sh > /dev/null 2>&1 & disown\n` +
+        `It must be detached (attached, your own run never ends and it waits forever). ` +
+        `Pass a follow-up command as an argument to verify after the restart. Then ` +
+        `finish your turn and tell the user the UI will blink and to refresh.\n\n` +
+        `If the restart was only to VERIFY a change, do not touch the live service at ` +
+        `all — build, then run a throwaway instance on a spare port ` +
+        `(e.g. \`PORT=4848 node dist/index.js dashboard --no-open\` backgrounded) and ` +
+        `curl that.`,
+    );
+    process.exit(2);
+  }
+}
+
+// --- 1. Already safe: backgrounded, detached, or already bounded by timeout ---
+// `&&`/`||`/`&>`/`2>&1` are NOT backgrounding, so match a real trailing `&`.
+const ALREADY_SAFE = [
+  /\bnohup\b/,
+  /\bdisown\b/,
+  /(^|[^&|>])&\s*$/, // trailing single & (job control), not &&/&>/2>&1
+  /\btimeout\s+/, // already wrapped (incl. our own rewrite)
+  /\bgtimeout\s+/,
+];
+if (ALREADY_SAFE.some((re) => re.test(command))) allow();
+
+// --- 2. Foreground-forever runners: block with guidance ---
+const LONG_RUNNING = [
+  { re: /\btail\s+-[a-zA-Z]*f/, hint: 'tail -f follows forever' },
+  { re: /\b(pnpm|npm|yarn|bun)\s+(run\s+)?(dev|start|serve|watch|preview)\b/, hint: 'package dev/start/serve/watch script' },
+  { re: /\bnext\s+dev\b/, hint: 'next dev server' },
+  { re: /\bvite\b(?!\s+build)/, hint: 'vite dev server (without build)' },
+  { re: /\bnodemon\b/, hint: 'nodemon watcher' },
+  { re: /\btsx\s+watch\b/, hint: 'tsx watch' },
+  { re: /\b(jest|vitest|playwright)\b.*--watch\b/, hint: 'test watcher' },
+  { re: /\bvitest\b(?!\s+run)/, hint: 'vitest (defaults to watch mode; use `vitest run`)' },
+  { re: /\b--watch(=true)?\b/, hint: 'a --watch flag' },
+  { re: /\bdocker\s+run\b(?![^\n]*\s-d\b)(?![^\n]*--detach\b)/, hint: 'docker run without -d/--detach' },
+  { re: /\bdocker[\s-]+compose\s+up\b(?![^\n]*\s-d\b)(?![^\n]*--detach\b)/, hint: 'docker compose up without -d' },
+  { re: /\bpython\d?\s+-m\s+http\.server\b/, hint: 'python http.server' },
+  { re: /\bserve\b(?!\s)/, hint: 'static `serve`' },
+  { re: /\binotifywait\b.*\s-m\b/, hint: 'inotifywait -m (monitor mode)' },
+];
+
+const blocked = LONG_RUNNING.find(({ re }) => re.test(command));
+if (blocked) {
+  process.stderr.write(
+    `Blocked: this looks like a long-running foreground process (${blocked.hint}). ` +
+      `In Custie this would hang the whole turn until it is force-killed, which also ` +
+      `drops the conversation session. Do NOT run it in the foreground.\n\n` +
+      `If you need it running, background it and return the PID:\n` +
+      `  nohup <cmd> > /tmp/<name>.log 2>&1 & disown; echo $!\n` +
+      `then poll the log / port to confirm it started.\n\n` +
+      `If you only need a bounded run (build, one-shot check), wrap it: ` +
+      `\`timeout 120 <cmd>\`.`,
+  );
+  process.exit(2);
+}
+
+// --- 3. Wrap simple commands in `timeout` (the should-exit-but-might-hang case) ---
+
+// Locate a real `timeout` binary. launchd's PATH may omit homebrew, so probe
+// absolute paths and fall open (no wrap) if none is found.
+function findTimeoutBin() {
+  const candidates = [
+    '/opt/homebrew/bin/timeout',
+    '/opt/homebrew/bin/gtimeout',
+    '/usr/local/bin/timeout',
+    '/usr/local/bin/gtimeout',
+    '/usr/bin/timeout',
+  ];
+  return candidates.find((p) => existsSync(p)) ?? null;
+}
+
+// Skip wrapping anything that isn't a single simple command — prefixing
+// `timeout N` only governs the FIRST simple command, so pipes/chains/subshells
+// and shell builtins (cd must run in the tool's own shell) would break or be
+// only partially covered. Leave those to the wall-clock backstop.
+function isSimpleCommand(cmd) {
+  const c = cmd.trim();
+  if (/[\n;`]|\|\||&&|(^|[^>&])\|[^|]|\$\(|<\(|>\(/.test(c)) return false; // chains/pipes/subshells
+  if (/(^|[^&|>])&(\s|$)/.test(c)) return false; // backgrounding
+  if (/^\w+=/.test(c)) return false; // leading VAR=... assignment
+  const first = c.split(/\s+/)[0];
+  const BUILTINS = new Set([
+    'cd', 'export', 'source', '.', 'eval', 'exec', ':', 'set', 'unset',
+    'alias', 'pushd', 'popd', 'pwd', 'echo', 'true', 'false', 'wait', 'kill',
+  ]);
+  return !BUILTINS.has(first);
+}
+
+// Known legitimately-long single commands: don't false-kill these at the default
+// cap. The wall-clock still backstops them.
+const SKIP_WRAP = [
+  /\b(npm|pnpm|yarn|bun)\s+(install|ci|add|i|up|update|upgrade|dedupe)\b/,
+  /\bgit\s+(clone|fetch|pull|push)\b/,
+  /\b(docker|podman)\s+(build|pull|push)\b/,
+  /\bbrew\s+(install|upgrade|update|reinstall)\b/,
+  /\bpip3?\s+install\b/,
+];
+
+function timeoutSeconds() {
+  const raw = process.env.CUSTIE_BASH_TIMEOUT_SECONDS;
+  const n = raw ? Number.parseInt(raw, 10) : NaN;
+  return Number.isFinite(n) && n > 0 ? n : 300;
+}
+
+const timeoutBin = findTimeoutBin();
+if (!timeoutBin || !isSimpleCommand(command) || SKIP_WRAP.some((re) => re.test(command))) {
+  allow();
+}
+
+const secs = timeoutSeconds();
+// -v: print a clear "timeout: sending signal..." line to stderr so the model
+//     knows WHY the command died (vs. a mysterious exit 124).
+// -k 5: SIGKILL 5s after SIGTERM if the command ignores TERM.
+const wrapped = `${timeoutBin} -v -k 5 ${secs} ${command}`;
+process.stdout.write(
+  JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'allow',
+      updatedInput: { ...toolInput, command: wrapped },
+    },
+  }),
+);
+process.exit(0);

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "flyspace-cli",
+  "version": "0.1.0",
+  "description": "AI-native headless community OS",
+  "license": "SEE LICENSE IN LICENSE",
+  "private": false,
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "flyspace": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "hooks",
+    "system.default.md",
+    "system.capabilities.md",
+    "slack-app-manifest.yml"
+  ],
+  "scripts": {
+    "dev": "tsx watch --clear-screen=false src/cli.ts dashboard --mode all --port 4848 --no-open",
+    "dev:slack": "tsx src/cli.ts start",
+    "dev:slack:debug": "DEBUG=true tsx src/cli.ts start",
+    "dev:data": "tsx src/dashboard/data-server.ts",
+    "dev:host": "tsx src/dashboard/host-server.ts",
+    "generate-host-key": "tsx scripts/generate-host-key.ts",
+    "import:channels": "tsx scripts/import-channels-to-supabase.ts",
+    "seed:test-user": "tsx scripts/seed-test-user.ts",
+    "build": "tsup && pnpm run build:web",
+    "build:web": "cd web && pnpm run build",
+    "build:cli": "FLYSPACE_PUBLIC_BUILD=1 tsup",
+    "start": "node dist/cli.js start",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "reload": "pnpm run build && launchctl kickstart -k \"gui/$(id -u)/ai.flyspace\"",
+    "reload:all": "pnpm run build && launchctl kickstart -k \"gui/$(id -u)/ai.flyspace\" && launchctl kickstart -k \"gui/$(id -u)/ai.flyspace.flycoder\"",
+    "lint": "oxlint src/",
+    "format": "prettier --write src/",
+    "format:check": "prettier --check src/",
+    "prepublishOnly": "pnpm run build:cli",
+    "release": "pnpm version patch && npm publish && git push --follow-tags"
+  },
+  "dependencies": {
+    "@anthropic-ai/sandbox-runtime": "0.0.77",
+    "@aws-sdk/client-s3": "^3.1085.0",
+    "@aws-sdk/s3-request-presigner": "^3.1085.0",
+    "@hono/node-server": "^2.0.6",
+    "@inquirer/prompts": "^8.3.2",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@slack/bolt": "^4.6.0",
+    "@slack/web-api": "^7.15.0",
+    "@supabase/ssr": "^0.12.1",
+    "@supabase/supabase-js": "^2.110.1",
+    "better-sqlite3": "^12.6.2",
+    "cron-parser": "^5.5.0",
+    "dotenv": "^17.2.4",
+    "gemoji": "^8.1.0",
+    "hono": "^4.12.27",
+    "js-yaml": "^4.1.1",
+    "marked": "^18.0.2",
+    "msedge-tts": "^2.0.7",
+    "node-cron": "^4.2.1",
+    "sharp": "^0.35.3",
+    "stripe": "^22.6.2",
+    "web-push": "^3.6.7",
+    "ws": "^8.21.3"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^25.2.3",
+    "@types/web-push": "^3.6.4",
+    "@types/ws": "^8.18.1",
+    "@vitest/coverage-v8": "^3.2.6",
+    "jsdom": "^30.0.0",
+    "oxlint": "^1.46.0",
+    "playwright": "^1.58.2",
+    "prettier": "^3.8.1",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.6"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "better-sqlite3",
+      "esbuild"
+    ]
+  },
+  "packageManager": "pnpm@10.24.0+sha512.01ff8ae71b4419903b65c60fb2dc9d34cf8bb6e06d03bde112ef38f7a34d6904c424ba66bea5cdcf12890230bf39f9580473140ed9c946fef328b6e5238a345a",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/slack-app-manifest.yml

@@ -0,0 +1,50 @@
+display_information:
+  name: Custie
+  description: Claude Code powered Slack bot
+  background_color: "#1e293b"
+
+features:
+  app_home:
+    home_tab_enabled: false
+    messages_tab_enabled: true
+    messages_tab_read_only_enabled: false
+  bot_user:
+    display_name: Custie
+    always_online: true
+  slash_commands:
+    - command: /custie
+      description: Browse skills and what Custie can do
+      usage_hint: skills | help
+      should_escape: false
+
+oauth_config:
+  scopes:
+    bot:
+      - app_mentions:read
+      - channels:history
+      - channels:read
+      - chat:write
+      - commands
+      - files:read
+      - groups:history
+      - groups:read
+      - im:history
+      - im:read
+      - im:write
+      - mpim:read
+      - reactions:write
+      - users:read
+      - usergroups:read
+
+settings:
+  event_subscriptions:
+    bot_events:
+      - app_mention
+      - message.channels
+      - message.groups
+      - message.im
+  interactivity:
+    is_enabled: true
+  org_deploy_enabled: false
+  socket_mode_enabled: true
+  token_rotation_enabled: false