flyspace-cli 0.1.0

package/dist/chunk-QZIN7MWV.js

@@ -0,0 +1,431 @@
+#!/usr/bin/env node
+
+// src/profile.ts
+import { AsyncLocalStorage } from "async_hooks";
+var PROFILE_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+var DEFAULT_PROFILE = "default";
+var profileStore = new AsyncLocalStorage();
+function runWithProfile(profile, fn) {
+  return profileStore.run(validateProfile(profile), fn);
+}
+function validateProfile(raw) {
+  const name = raw?.trim();
+  if (!name || name === DEFAULT_PROFILE) return DEFAULT_PROFILE;
+  if (!PROFILE_PATTERN.test(name)) {
+    throw new Error(
+      `Invalid profile name: "${name}". Use lowercase letters, digits, and hyphens (must start with a letter or digit).`
+    );
+  }
+  return name;
+}
+function getProfile() {
+  const bound = profileStore.getStore();
+  if (bound) return bound;
+  return validateProfile(process.env["FLYSPACE_WORKSPACE"]);
+}
+
+// src/paths.ts
+import { existsSync, mkdirSync, readdirSync, rmSync, statSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+var home = homedir();
+var XDG_CONFIG_HOME = process.env["XDG_CONFIG_HOME"] || join(home, ".config");
+var XDG_DATA_HOME = process.env["XDG_DATA_HOME"] || join(home, ".local", "share");
+var paths = {
+  /** Profile-independent config root: `~/.config/flyspace`. */
+  get BASE_CONFIG_DIR() {
+    return join(XDG_CONFIG_HOME, "flyspace");
+  },
+  /** Profile-independent data root: `~/.local/share/flyspace`. */
+  get BASE_DATA_DIR() {
+    return join(XDG_DATA_HOME, "flyspace");
+  },
+  /** Where named profiles live: `~/.config/flyspace/profiles`. */
+  get PROFILES_DIR() {
+    return join(XDG_CONFIG_HOME, "flyspace", "profiles");
+  },
+  /** Config dir for the active profile. `default` uses the base dir. */
+  get CONFIG_DIR() {
+    const profile = getProfile();
+    return profile === "default" ? this.BASE_CONFIG_DIR : join(this.PROFILES_DIR, profile);
+  },
+  /** Data dir for the active profile. `default` uses the base dir. */
+  get DATA_DIR() {
+    const profile = getProfile();
+    return profile === "default" ? this.BASE_DATA_DIR : join(this.BASE_DATA_DIR, "profiles", profile);
+  },
+  get CONFIG_FILE() {
+    return join(this.CONFIG_DIR, "config.env");
+  },
+  get PROMPT_FILE() {
+    return join(this.CONFIG_DIR, "prompt.md");
+  },
+  get DB_FILE() {
+    return join(this.DATA_DIR, "flyspace.db");
+  },
+  get LOG_DIR() {
+    return join(this.DATA_DIR, "logs");
+  },
+  get UPLOADS_DIR() {
+    return join(this.DATA_DIR, "uploads");
+  },
+  /**
+   * Throwaway files the agent produces mid-turn (screenshots, rendered charts)
+   * so it has somewhere to write that isn't the shared system temp dir. Swept
+   * on startup by `sweepScratchDir()` — nothing here is expected to survive.
+   */
+  get SCRATCH_DIR() {
+    return join(this.DATA_DIR, "scratch");
+  },
+  /**
+   * Per-channel persistent HOME for `runtime: 'container'` channels — mounted
+   * into the container as the agent's home so `--resume` survives a container
+   * exiting (each turn is a fresh `--rm` container). Unlike SCRATCH_DIR this is
+   * never swept: the Claude session files under it are the resume state.
+   * One subdirectory per container channel; see `containerHomeFor()`.
+   */
+  get CONTAINER_HOMES_DIR() {
+    return join(this.DATA_DIR, "container-homes");
+  },
+  /**
+   * Per-channel persistent CLAUDE_CONFIG_DIR for `runtime: 'sandbox'` channels
+   * — a real host directory (sandbox-runtime confines the process to paths on
+   * disk, there is no separate container filesystem to mount into), kept out
+   * of the channel's own folder so it never shows up in the agent's Read/ls.
+   * One subdirectory per sandboxed channel; see `sandboxHomeFor()`.
+   */
+  get SANDBOX_HOMES_DIR() {
+    return join(this.DATA_DIR, "sandbox-homes");
+  },
+  /**
+   * Root for per-channel shadow git repos (bare, one per channel) that back
+   * the version-history feature. Kept outside the channel folder itself so a
+   * channel's own `cwd` never grows a `.git` — that would collide with a repo
+   * the user links in themselves. See `src/versions`.
+   */
+  get VERSIONS_DIR() {
+    return join(this.DATA_DIR, "versions");
+  },
+  get AUTOMATIONS_FILE() {
+    return join(this.CONFIG_DIR, "automations.yml");
+  },
+  get CHANNELS_FILE() {
+    return join(this.CONFIG_DIR, "channels.yml");
+  },
+  get DASHBOARD_SETTINGS_FILE() {
+    return join(this.CONFIG_DIR, "dashboard-settings.json");
+  },
+  PACKAGE_ROOT: resolve(import.meta.dirname, "..")
+};
+function ensureDirs() {
+  for (const dir of [
+    paths.CONFIG_DIR,
+    paths.DATA_DIR,
+    paths.LOG_DIR,
+    paths.UPLOADS_DIR,
+    paths.SCRATCH_DIR
+  ]) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+var SCRATCH_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+function sweepScratchDir(now = Date.now()) {
+  const dir = paths.SCRATCH_DIR;
+  if (!existsSync(dir)) return 0;
+  let removed = 0;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const path = join(dir, entry.name);
+    try {
+      if (now - statSync(path).mtimeMs < SCRATCH_MAX_AGE_MS) continue;
+      rmSync(path, { recursive: true, force: true });
+      removed++;
+    } catch {
+    }
+  }
+  return removed;
+}
+
+// src/store/supabase-client.ts
+import { createClient } from "@supabase/supabase-js";
+var client;
+function getSupabaseClient() {
+  if (client) return client;
+  const url = process.env["SUPABASE_URL"];
+  const key = process.env["SUPABASE_SECRET_KEY"];
+  if (!url || !key) {
+    throw new Error("SUPABASE_URL / SUPABASE_SECRET_KEY not set \u2014 check .env");
+  }
+  client = createClient(url, key, { auth: { persistSession: false } });
+  return client;
+}
+
+// src/store/authors.ts
+var AGENT_AUTHOR = "agent";
+var SYNCED_BOT_AUTHOR = "Bot";
+var LEGACY_BOT_AUTHOR = "Custie";
+var NON_HUMAN_AUTHORS = new Set(
+  [AGENT_AUTHOR, SYNCED_BOT_AUTHOR, LEGACY_BOT_AUTHOR].map((a) => a.toLowerCase())
+);
+function isHumanAuthor(author) {
+  return !NON_HUMAN_AUTHORS.has(author.toLowerCase());
+}
+
+// src/dashboard/attachment-uploader.ts
+import { randomUUID } from "crypto";
+import { readFile, stat } from "fs/promises";
+import { basename } from "path";
+import { PutObjectCommand } from "@aws-sdk/client-s3";
+
+// src/store/r2-client.ts
+import { ListObjectsV2Command, S3Client } from "@aws-sdk/client-s3";
+var client2;
+function getR2Client() {
+  if (client2) return client2;
+  const accountId = process.env["CLOUDFLARE_R2_ACCOUNT_ID"];
+  const accessKeyId = process.env["CLOUDFLARE_R2_ACCESS_KEY_ID"];
+  const secretAccessKey = process.env["CLOUDFLARE_R2_SECRET_ACCESS_KEY"];
+  if (!accountId || !accessKeyId || !secretAccessKey) {
+    throw new Error("CLOUDFLARE_R2_* env vars not set \u2014 check .env");
+  }
+  client2 = new S3Client({
+    region: "auto",
+    endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
+    credentials: { accessKeyId, secretAccessKey }
+  });
+  return client2;
+}
+function getR2Bucket() {
+  const bucket = process.env["CLOUDFLARE_R2_BUCKET_NAME"];
+  if (!bucket) throw new Error("CLOUDFLARE_R2_BUCKET_NAME not set \u2014 check .env");
+  return bucket;
+}
+async function sumR2PrefixBytes(prefix) {
+  let total = 0;
+  let token;
+  do {
+    const page = await getR2Client().send(
+      new ListObjectsV2Command({ Bucket: getR2Bucket(), Prefix: prefix, ContinuationToken: token })
+    );
+    for (const obj of page.Contents ?? []) total += obj.Size ?? 0;
+    token = page.IsTruncated ? page.NextContinuationToken : void 0;
+  } while (token);
+  return total;
+}
+
+// src/dashboard/attachment-uploader.ts
+var debug = process.env["DEBUG"] === "true";
+var LOCAL_IMAGE_LINK = /!\[([^\]]*)\]\((\/[^)\s]+)\)/g;
+var SCRATCH_VAR_IN_IMAGE_LINK = /(!\[[^\]]*\]\()\$\{?FLYSPACE_SCRATCH_DIR\}?(?=\/)/g;
+function expandScratchDirVar(body) {
+  return body.replace(SCRATCH_VAR_IN_IMAGE_LINK, (_, prefix) => prefix + paths.SCRATCH_DIR);
+}
+var MAX_FILE_BYTES = 10 * 1024 * 1024;
+var SCRATCH_PREFIX = "scratch";
+var MIMETYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif"
+};
+function mimetypeOf(path) {
+  const dot = path.lastIndexOf(".");
+  return dot === -1 ? void 0 : MIMETYPES[path.slice(dot).toLowerCase()];
+}
+function sanitizeFilename(name) {
+  const cleaned = name.replace(/[/\\]/g, "_").replace(/\s+/g, "-").replace(/[^\w.-]/g, "").trim();
+  return (cleaned || "file").slice(-100);
+}
+function encodeKeyForUrl(key) {
+  return key.split("/").map(encodeURIComponent).join("/");
+}
+function extractLocalImagePaths(body) {
+  const paths2 = [];
+  for (const match of body.matchAll(LOCAL_IMAGE_LINK)) {
+    const path = match[2];
+    if (path.startsWith("/api/")) continue;
+    if (!mimetypeOf(path)) continue;
+    if (!paths2.includes(path)) paths2.push(path);
+  }
+  return paths2;
+}
+async function uploadOne(path) {
+  const mimetype = mimetypeOf(path);
+  if (!mimetype) return null;
+  try {
+    const info = await stat(path);
+    if (!info.isFile()) return null;
+    if (info.size > MAX_FILE_BYTES) {
+      console.error(`[attachment-uploader] ${path} is ${info.size} bytes, over the ${MAX_FILE_BYTES} limit`);
+      return null;
+    }
+    const key = `${SCRATCH_PREFIX}/${getProfile()}/${randomUUID()}-${sanitizeFilename(basename(path))}`;
+    await getR2Client().send(
+      new PutObjectCommand({
+        Bucket: getR2Bucket(),
+        Key: key,
+        Body: await readFile(path),
+        ContentType: mimetype
+      })
+    );
+    if (debug) console.log(`[attachment-uploader] ${path} -> ${key} (${info.size} bytes)`);
+    return `/api/attachments/${encodeKeyForUrl(key)}`;
+  } catch (err) {
+    console.error(`[attachment-uploader] failed to upload ${path}:`, err.message);
+    return null;
+  }
+}
+async function uploadLocalImages(rawBody) {
+  const body = expandScratchDirVar(rawBody);
+  const localPaths = extractLocalImagePaths(body);
+  if (localPaths.length === 0) return body;
+  const urls = /* @__PURE__ */ new Map();
+  await Promise.all(
+    localPaths.map(async (path) => {
+      const url = await uploadOne(path);
+      if (url) urls.set(path, url);
+    })
+  );
+  if (urls.size === 0) return body;
+  return body.replace(LOCAL_IMAGE_LINK, (original, alt, path) => {
+    const url = urls.get(path);
+    return url ? `![${alt}](${url})` : original;
+  });
+}
+
+// src/store/dashboard-sync.ts
+var TITLE_MAX_LENGTH = 80;
+function deriveThreadTitle(text) {
+  const firstLine = text.split("\n").find((line) => line.trim().length > 0);
+  if (!firstLine) return null;
+  const cleaned = firstLine.replace(/^\s*(?::[a-z0-9_+-]+:\s*)+/i, "").replace(/^\s*\p{Extended_Pictographic}[️‍]*\s*/u, "").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/(^|\s)_([^_\n]+)_(?=\s|$|[.,:;，。、：])/g, "$1$2").replace(/`([^`]+)`/g, "$1").replace(/\s+/g, " ").trim();
+  if (!cleaned) return null;
+  return cleaned.length > TITLE_MAX_LENGTH ? `${cleaned.slice(0, TITLE_MAX_LENGTH).trim()}\u2026` : cleaned;
+}
+async function syncPostToDashboard(opts) {
+  const { channelId, ts, threadTs, text } = opts;
+  if (!process.env["SUPABASE_URL"] || !process.env["SUPABASE_SECRET_KEY"]) {
+    console.warn("[dashboard-sync] Supabase not configured \u2014 skipping dashboard sync");
+    return;
+  }
+  try {
+    const supabase = getSupabaseClient();
+    const dashboardChannelId = await resolveDashboardChannelId(supabase, channelId);
+    const threadId = threadTs ? await ensureThreadId(supabase, channelId, dashboardChannelId, threadTs) : await createOwnThread(supabase, channelId, dashboardChannelId, ts, text);
+    const { error } = await supabase.from("thread_replies").upsert(
+      {
+        thread_id: threadId,
+        // This mirror only ever runs for the bot's own posts (automation
+        // output, `flyspace slack post`), so the author is the agent itself —
+        // labelling it anything else makes the chat agent count it as a
+        // second human and stop replying without an explicit mention.
+        author: AGENT_AUTHOR,
+        body: await uploadLocalImages(text),
+        external_thread_replies_id: `${channelId}:${ts}`
+      },
+      { onConflict: "external_thread_replies_id" }
+    );
+    if (error) {
+      console.warn(`[dashboard-sync] failed to write reply: ${error.message}`);
+    }
+  } catch (err) {
+    console.warn(
+      `[dashboard-sync] sync failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+async function resolveDashboardChannelId(supabase, slackChannelId) {
+  const { data, error } = await supabase.from("channels").select("id").eq("external_channel_id", slackChannelId).maybeSingle();
+  if (error || !data) return slackChannelId;
+  return data["id"];
+}
+async function createOwnThread(supabase, externalChannelId, dashboardChannelId, ts, text) {
+  const { data, error } = await supabase.from("threads").upsert(
+    {
+      channel_id: dashboardChannelId,
+      title: deriveThreadTitle(text),
+      author: AGENT_AUTHOR,
+      external_thread_id: `${externalChannelId}:${ts}`
+    },
+    { onConflict: "external_thread_id" }
+  ).select("id").single();
+  if (error || !data) throw new Error(error?.message ?? "failed to create thread");
+  return data["id"];
+}
+async function ensureThreadId(supabase, externalChannelId, dashboardChannelId, parentTs) {
+  const key = `${externalChannelId}:${parentTs}`;
+  const { data: existing, error: selectError } = await supabase.from("threads").select("id").eq("external_thread_id", key).maybeSingle();
+  if (selectError) throw new Error(selectError.message);
+  if (existing) return existing["id"];
+  const { data: created, error: createError } = await supabase.from("threads").upsert(
+    // The unsynced parent could be anyone's message (often another bot's),
+    // so keep the generic non-human placeholder rather than claiming it.
+    {
+      channel_id: dashboardChannelId,
+      title: null,
+      author: SYNCED_BOT_AUTHOR,
+      external_thread_id: key
+    },
+    { onConflict: "external_thread_id" }
+  ).select("id").single();
+  if (createError || !created) {
+    throw new Error(createError?.message ?? "failed to create placeholder thread");
+  }
+  return created["id"];
+}
+
+// src/store/dashboard-post.ts
+async function postToDashboardChannel(opts) {
+  const { channelId, text, threadId, title } = opts;
+  const supabase = getSupabaseClient();
+  if (!threadId && !channelId) {
+    throw new Error("postToDashboardChannel: channelId is required to start a new thread");
+  }
+  const parentId = threadId ?? await createThread(supabase, channelId, text, title);
+  const body = await uploadLocalImages(text);
+  const { error } = await supabase.from("thread_replies").insert({
+    thread_id: parentId,
+    author: AGENT_AUTHOR,
+    body
+  });
+  if (error) throw new Error(`failed to write dashboard reply: ${error.message}`);
+  return parentId;
+}
+async function createThread(supabase, channelId, text, title) {
+  const { data, error } = await supabase.from("threads").insert({
+    channel_id: channelId,
+    // An untitled thread is effectively invisible in the sidebar, so give a
+    // daily report the same first-line-derived title a mirrored post gets,
+    // unless the caller named the thread itself.
+    title: title?.trim().replace(/\\([\\`*_{}[\]()#+\-.!~>|])/g, "$1") || deriveThreadTitle(text),
+    author: AGENT_AUTHOR
+  }).select("id").single();
+  if (error || !data) {
+    throw new Error(`failed to create dashboard thread: ${error?.message ?? "no row returned"}`);
+  }
+  return data["id"];
+}
+
+export {
+  DEFAULT_PROFILE,
+  runWithProfile,
+  getProfile,
+  paths,
+  ensureDirs,
+  sweepScratchDir,
+  getSupabaseClient,
+  AGENT_AUTHOR,
+  SYNCED_BOT_AUTHOR,
+  isHumanAuthor,
+  getR2Client,
+  getR2Bucket,
+  sumR2PrefixBytes,
+  SCRATCH_PREFIX,
+  uploadLocalImages,
+  syncPostToDashboard,
+  resolveDashboardChannelId,
+  postToDashboardChannel
+};

package/dist/chunk-X7SJ653V.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import {
+  getSupabaseClient
+} from "./chunk-QZIN7MWV.js";
+
+// src/store/chat-admin-store.ts
+async function listChannels(profile) {
+  let query = getSupabaseClient().from("channels").select("id, name, profile, cwd");
+  if (profile) query = query.eq("profile", profile);
+  const { data, error } = await query.order("name");
+  if (error) throw new Error(`listChannels: ${error.message}`);
+  return (data ?? []).map((row) => ({
+    id: row["id"],
+    name: row["name"],
+    profile: row["profile"],
+    cwd: row["cwd"]
+  }));
+}
+async function resolveChannel(nameOrId, profile) {
+  const channels = await listChannels(profile);
+  const byId = channels.find((c) => c.id === nameOrId);
+  if (byId) return byId;
+  const wanted = nameOrId.replace(/^#/, "").toLowerCase();
+  const matches = channels.filter((c) => c.name.toLowerCase() === wanted);
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) {
+    const detail = matches.map((c) => `${c.name} (${c.profile}) ${c.id}`).join("\n  ");
+    throw new Error(`"${nameOrId}" matches ${matches.length} channels \u2014 pass an id:
+  ${detail}`);
+  }
+  throw new Error(`No channel matching "${nameOrId}". Run "flyspace chat channels".`);
+}
+async function listThreads(channelId, limit = 20) {
+  const { data, error } = await getSupabaseClient().from("threads").select("id, channel_id, title, author, updated_at, thread_replies(count)").eq("channel_id", channelId).order("updated_at", { ascending: false }).limit(limit);
+  if (error) throw new Error(`listThreads(${channelId}): ${error.message}`);
+  return (data ?? []).map(rowToThread);
+}
+async function getThread(threadId) {
+  const { data, error } = await getSupabaseClient().from("threads").select("id, channel_id, title, author, updated_at, thread_replies(count)").eq("id", threadId).maybeSingle();
+  if (error) throw new Error(`getThread(${threadId}): ${error.message}`);
+  return data ? rowToThread(data) : void 0;
+}
+async function firstReplyBody(threadId) {
+  const { data, error } = await getSupabaseClient().from("thread_replies").select("body").eq("thread_id", threadId).order("created_at").limit(1).maybeSingle();
+  if (error) throw new Error(`firstReplyBody(${threadId}): ${error.message}`);
+  return data?.body;
+}
+async function moveThread(threadId, toChannelId) {
+  const supabase = getSupabaseClient();
+  const { error } = await supabase.from("threads").update({ channel_id: toChannelId }).eq("id", threadId);
+  if (error) throw new Error(`moveThread(${threadId}): ${error.message}`);
+  const { error: notifyError } = await supabase.from("notifications").update({ channel_id: toChannelId }).eq("thread_id", threadId);
+  if (notifyError) throw new Error(`moveThread(${threadId}) notifications: ${notifyError.message}`);
+}
+function rowToThread(row) {
+  const counts = row["thread_replies"];
+  return {
+    id: row["id"],
+    channelId: row["channel_id"],
+    title: row["title"] ?? null,
+    author: row["author"],
+    replies: counts?.[0]?.count ?? 0,
+    updatedAt: row["updated_at"]
+  };
+}
+
+export {
+  listChannels,
+  resolveChannel,
+  listThreads,
+  getThread,
+  firstReplyBody,
+  moveThread
+};

package/dist/cli.d.ts

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