flyspace-cli 0.1.13 → 0.1.15

package/dist/{chunk-VKTJBYA3.js → chunk-KFT2YP5W.js}

@@ -163,9 +163,9 @@ async function refreshAutomationRegistry() {
     return;
   }
   const next = data ?? [];
-  const snapshot = JSON.stringify(next, (key, value) => key === "updated_at" ? void 0 : value);
-  if (snapshot === lastSnapshot) return;
-  lastSnapshot = snapshot;
+  const snapshot2 = JSON.stringify(next, (key, value) => key === "updated_at" ? void 0 : value);
+  if (snapshot2 === lastSnapshot) return;
+  lastSnapshot = snapshot2;
   rows = next;
   for (const cb of changeListeners) {
     try {
@@ -364,12 +364,12 @@ async function refreshChannelRegistry() {
     return;
   }
   const rows2 = data ?? [];
-  const snapshot = JSON.stringify(
+  const snapshot2 = JSON.stringify(
     rows2,
     (key, value) => key === "updated_at" || key === "created_at" ? void 0 : value
   );
-  if (snapshot === lastSnapshot2) return;
-  lastSnapshot2 = snapshot;
+  if (snapshot2 === lastSnapshot2) return;
+  lastSnapshot2 = snapshot2;
   indexRegistry(rows2.map(rowToChannel));
   for (const cb of changeListeners2) {
     try {
@@ -2086,6 +2086,340 @@ Fix the channel's working directory in its settings (or recreate the directory),
   }
 }
 
+// src/feature-flags.ts
+var featureFlags = {
+  "ai-cost": {
+    title: "AI cost",
+    description: "Shows admins what the agent has spent: a Cost section in a channel's AI overview and a per-thread cost in the thread menu. Estimated at API list rates, so on a Claude subscription it will not match your bill.",
+    stage: "beta"
+  },
+  "read-aloud": {
+    title: "Read aloud",
+    description: "Listen to messages, threads and docs as audio. Still rough in places, and each playback uses text-to-speech.",
+    stage: "beta"
+  },
+  excalidraw: {
+    title: "Excalidraw",
+    description: "Create and edit whiteboard drawings (.excalidraw files) in the Docs pane. Existing drawings stay viewable with this off.",
+    stage: "beta"
+  },
+  sandbox: {
+    title: "Sandbox runtime",
+    description: "Run a channel agent in an isolated sandbox without Docker. Channels already on Sandbox keep working with this off.",
+    stage: "beta"
+  },
+  dictation: {
+    title: "Dictation",
+    description: "A mic button in the message composer that turns speech into text as you talk. Each phrase uses speech-to-text.",
+    stage: "dev"
+  },
+  "agent-memory": {
+    title: "Agent memory",
+    description: "Channel memory the agent reads every turn, saved by the agent and picked up from idle threads, with a Memory tab and an undo chip. While on, Claude's built-in auto memory is switched off so the two can be compared; turning this off keeps every memory.",
+    stage: "beta"
+  }
+};
+var featureFlagIds = Object.keys(featureFlags);
+function isFeatureFlagId(id) {
+  return Object.hasOwn(featureFlags, id);
+}
+function isFeatureVisible(stage, devHost) {
+  return stage === "beta" || stage === "dev" && devHost;
+}
+function resolveFeatureFlags(enabledIds, devHost) {
+  const enabled = new Set(enabledIds);
+  const out = {};
+  for (const id of featureFlagIds) {
+    const stage = featureFlags[id].stage;
+    out[id] = stage === "ga" || isFeatureVisible(stage, devHost) && enabled.has(id);
+  }
+  return out;
+}
+
+// src/store/feature-flag-store.ts
+async function listEnabledFeatureFlags(workspaceId) {
+  const { data, error } = await getSupabaseClient().from("feature_flags").select("flag_id").eq("workspace_id", workspaceId);
+  if (error) throw new Error(`listEnabledFeatureFlags(${workspaceId}): ${error.message}`);
+  return (data ?? []).map((r) => r.flag_id);
+}
+async function listEnabledFeatureFlagsBySlug(slug) {
+  const { data, error } = await getSupabaseClient().from("workspaces").select("id").eq("slug", slug).maybeSingle();
+  if (error) throw new Error(`listEnabledFeatureFlagsBySlug(${slug}): ${error.message}`);
+  return data ? listEnabledFeatureFlags(data.id) : [];
+}
+async function enableFeatureFlag(workspaceId, flagId, userId) {
+  const { error } = await getSupabaseClient().from("feature_flags").upsert(
+    { workspace_id: workspaceId, flag_id: flagId, enabled_by: userId },
+    { onConflict: "workspace_id,flag_id" }
+  );
+  if (error) throw new Error(`enableFeatureFlag(${workspaceId}, ${flagId}): ${error.message}`);
+}
+async function disableFeatureFlag(workspaceId, flagId) {
+  const { error } = await getSupabaseClient().from("feature_flags").delete().eq("workspace_id", workspaceId).eq("flag_id", flagId);
+  if (error) throw new Error(`disableFeatureFlag(${workspaceId}, ${flagId}): ${error.message}`);
+}
+
+// src/store/memory-store.ts
+var MEMORY_TYPES = ["preference", "decision", "fact", "reference"];
+var NAME_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var DESCRIPTION_MAX = 200;
+var BODY_MAX = 16e3;
+var MEMORY_INDEX_MAX_CHARS = 8e3;
+function isMemoryType(value) {
+  return MEMORY_TYPES.includes(value);
+}
+function validateMemoryInput(input) {
+  if (!NAME_RE.test(input.name))
+    throw new Error("name must be a kebab-case slug, e.g. deploy-flow");
+  if (!isMemoryType(input.type)) throw new Error(`type must be one of ${MEMORY_TYPES.join(", ")}`);
+  const description = input.description.trim();
+  if (!description || description.includes("\n") || description.length > DESCRIPTION_MAX) {
+    throw new Error(`description must be one line of at most ${DESCRIPTION_MAX} characters`);
+  }
+  const body = input.body.trim();
+  if (!body || body.length > BODY_MAX) {
+    throw new Error(`body must be 1 to ${BODY_MAX} characters`);
+  }
+}
+function rowToMemory(row) {
+  return {
+    id: row["id"],
+    channelId: row["channel_id"],
+    name: row["name"],
+    description: row["description"],
+    type: row["type"],
+    body: row["body"],
+    sourceThreadId: row["source_thread_id"] ?? null,
+    createdBy: row["created_by"],
+    createdAt: row["created_at"],
+    updatedAt: row["updated_at"]
+  };
+}
+async function listChannelMemories(channelId) {
+  const { data, error } = await getSupabaseClient().from("memories").select("*").eq("scope", "channel").eq("channel_id", channelId).order("updated_at", { ascending: false });
+  if (error) throw new Error(`listChannelMemories(${channelId}): ${error.message}`);
+  return (data ?? []).map(rowToMemory);
+}
+async function getChannelMemory(channelId, name) {
+  const { data, error } = await getSupabaseClient().from("memories").select("*").eq("scope", "channel").eq("channel_id", channelId).eq("name", name).maybeSingle();
+  if (error) throw new Error(`getChannelMemory(${channelId}, ${name}): ${error.message}`);
+  return data ? rowToMemory(data) : null;
+}
+async function saveChannelMemory(input, actor) {
+  validateMemoryInput(input);
+  const supabase = getSupabaseClient();
+  const existing = await getChannelMemory(input.channelId, input.name);
+  const fields = {
+    description: input.description.trim(),
+    type: input.type,
+    body: input.body.trim(),
+    source_thread_id: input.sourceThreadId ?? existing?.sourceThreadId ?? null,
+    created_by: input.createdBy
+  };
+  if (existing && sameContent(existing, fields)) {
+    return { memory: existing, created: false, changed: false };
+  }
+  const { data, error } = existing ? await supabase.from("memories").update({ ...fields, updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", existing.id).select("*").single() : await supabase.from("memories").insert({ ...fields, scope: "channel", channel_id: input.channelId, name: input.name }).select("*").single();
+  if (error)
+    throw new Error(`saveChannelMemory(${input.channelId}, ${input.name}): ${error.message}`);
+  const memory = rowToMemory(data);
+  await logMemoryEvent({
+    memory,
+    action: existing ? "update" : "create",
+    before: existing ? snapshot(existing) : null,
+    after: snapshot(memory),
+    actor,
+    threadId: input.sourceThreadId ?? null
+  });
+  return { memory, created: !existing, changed: true };
+}
+async function updateChannelMemory(channelId, memoryId, patch, actor) {
+  const existing = (await listChannelMemories(channelId)).find((m) => m.id === memoryId);
+  if (!existing) return null;
+  const { memory } = await saveChannelMemory(
+    {
+      channelId,
+      name: existing.name,
+      description: patch.description ?? existing.description,
+      type: patch.type ?? existing.type,
+      body: patch.body ?? existing.body,
+      createdBy: existing.createdBy
+    },
+    actor
+  );
+  return memory;
+}
+async function searchChannelMemories(channelId, query) {
+  const words = query.replaceAll(/[,()*%\\]/g, " ").split(/\s+/).filter(Boolean);
+  if (!words.length) return [];
+  let request = getSupabaseClient().from("memories").select("*").eq("scope", "channel").eq("channel_id", channelId);
+  for (const word of words) {
+    request = request.or(`name.ilike.*${word}*,description.ilike.*${word}*,body.ilike.*${word}*`);
+  }
+  const { data, error } = await request.order("updated_at", { ascending: false }).limit(20);
+  if (error) throw new Error(`searchChannelMemories(${channelId}): ${error.message}`);
+  return (data ?? []).map(rowToMemory);
+}
+async function deleteChannelMemory(channelId, idOrName, actor, threadId) {
+  const { data, error } = await getSupabaseClient().from("memories").delete().eq("scope", "channel").eq("channel_id", channelId).eq(isUuid(idOrName) ? "id" : "name", idOrName).select("*");
+  if (error) throw new Error(`deleteChannelMemory(${channelId}, ${idOrName}): ${error.message}`);
+  const deleted = (data ?? []).map(rowToMemory);
+  for (const memory of deleted) {
+    await logMemoryEvent({
+      memory,
+      action: "delete",
+      before: snapshot(memory),
+      after: null,
+      actor,
+      threadId: threadId ?? null
+    });
+  }
+  return deleted.length > 0;
+}
+function unchangedSince(current, after) {
+  return current && after ? sameContent(current, after) : !current && !after;
+}
+function snapshot(m) {
+  return {
+    description: m.description,
+    type: m.type,
+    body: m.body,
+    sourceThreadId: m.sourceThreadId,
+    createdBy: m.createdBy
+  };
+}
+function sameContent(m, other) {
+  return m.description === other.description && m.type === other.type && m.body === other.body;
+}
+async function logMemoryEvent(e) {
+  const { error } = await getSupabaseClient().from("memory_events").insert({
+    channel_id: e.memory.channelId,
+    memory_id: e.action === "delete" ? null : e.memory.id,
+    thread_id: e.threadId,
+    name: e.memory.name,
+    action: e.action,
+    before: e.before,
+    after: e.after,
+    actor: e.actor
+  });
+  if (error) console.error(`[memory] event log failed for ${e.memory.name}:`, error.message);
+}
+function rowToEvent(row) {
+  return {
+    id: row["id"],
+    channelId: row["channel_id"],
+    memoryId: row["memory_id"] ?? null,
+    threadId: row["thread_id"] ?? null,
+    name: row["name"],
+    action: row["action"],
+    before: row["before"] ?? null,
+    after: row["after"] ?? null,
+    actor: row["actor"],
+    createdAt: row["created_at"],
+    undoneAt: row["undone_at"] ?? null
+  };
+}
+async function listThreadMemoryEvents(channelId, threadId) {
+  const supabase = getSupabaseClient();
+  const { data, error } = await supabase.from("memory_events").select("*").eq("channel_id", channelId).eq("thread_id", threadId).order("created_at", { ascending: false }).limit(50);
+  if (error) throw new Error(`listThreadMemoryEvents(${threadId}): ${error.message}`);
+  const events = (data ?? []).map(rowToEvent);
+  if (!events.length) return [];
+  const names = [...new Set(events.map((e) => e.name))];
+  const live = await supabase.from("memories").select("*").eq("scope", "channel").eq("channel_id", channelId).in("name", names);
+  if (live.error) throw new Error(`listThreadMemoryEvents(${threadId}): ${live.error.message}`);
+  const byName = new Map(
+    (live.data ?? []).map((r) => [
+      r["name"],
+      rowToMemory(r)
+    ])
+  );
+  return events.map((e) => {
+    const current = byName.get(e.name) ?? null;
+    const unchanged = unchangedSince(current, e.after);
+    return {
+      ...e,
+      currentState: unchanged ? "current" : current ? "changed" : "deleted",
+      undoable: !e.undoneAt && unchanged
+    };
+  });
+}
+async function undoMemoryEvent(channelId, eventId) {
+  const supabase = getSupabaseClient();
+  const { data, error } = await supabase.from("memory_events").select("*").eq("id", eventId).eq("channel_id", channelId).maybeSingle();
+  if (error) throw new Error(`undoMemoryEvent(${eventId}): ${error.message}`);
+  if (!data) return "not-found";
+  const event = rowToEvent(data);
+  if (event.undoneAt) return "already-undone";
+  const current = await getChannelMemory(channelId, event.name);
+  if (!unchangedSince(current, event.after)) return "conflict";
+  const claimed = await supabase.from("memory_events").update({ undone_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", eventId).is("undone_at", null).select("id");
+  if (claimed.error) throw new Error(`undoMemoryEvent(${eventId}): ${claimed.error.message}`);
+  if (!(claimed.data ?? []).length) return "already-undone";
+  const before = event.before;
+  const restore = before ? {
+    description: before.description,
+    type: before.type,
+    body: before.body,
+    source_thread_id: before.sourceThreadId,
+    created_by: before.createdBy
+  } : null;
+  const { error: writeError } = !restore ? await supabase.from("memories").delete().eq("id", current.id) : current ? await supabase.from("memories").update({ ...restore, updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", current.id) : await supabase.from("memories").insert({ ...restore, scope: "channel", channel_id: channelId, name: event.name });
+  if (writeError) {
+    await supabase.from("memory_events").update({ undone_at: null }).eq("id", eventId);
+    throw new Error(`undoMemoryEvent(${eventId}): ${writeError.message}`);
+  }
+  return "undone";
+}
+function isUuid(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+function formatMemoryPrompt(channelId, memories) {
+  const lines = [];
+  let used = 0;
+  let omitted = 0;
+  for (const m of memories) {
+    const line = `- \`${m.name}\` (${m.type}): ${m.description}`;
+    if (used + line.length > MEMORY_INDEX_MAX_CHARS) {
+      omitted++;
+      continue;
+    }
+    lines.push(line);
+    used += line.length + 1;
+  }
+  const index = lines.length ? lines.join("\n") + (omitted ? `
+- (${omitted} older memories not listed; find them with \`memory search\`)` : "") : "(none yet)";
+  return [
+    `## Channel memory`,
+    ``,
+    `This channel has a persistent memory shared by every thread in it and by every agent runner. Use it instead of any built-in memory directory of your own CLI.`,
+    ``,
+    `- Read a memory: \`flyspace memory get --channel ${channelId} <name>\``,
+    `- Search: \`flyspace memory search --channel ${channelId} <words>\``,
+    `- Save or overwrite: \`flyspace memory save --channel ${channelId} --name <kebab-slug> --type <${MEMORY_TYPES.join("|")}> --description "<one line>" --body "<text>" [--thread <thread-id>]\``,
+    `- Delete one that turned out wrong: \`flyspace memory delete --channel ${channelId} <name> [--thread <thread-id>]\``,
+    ``,
+    `Save when someone asks you to remember something, corrects you, or a decision is made that later threads will need. Save what is not derivable from the code, git history or docs: decisions and why, preferences, corrections, where external things live. Do not save one-off details of this conversation. Check the index first and update an existing memory rather than adding a near-duplicate. Write memories in English. Pass \`--thread\` with the thread id from the \`[context: ...]\` header, so the thread shows what changed and it can be undone there.`,
+    ``,
+    `Index:`,
+    index
+  ].join("\n");
+}
+
+// src/store/memory-context.ts
+async function loadAgentMemory(profile, channelId, opts = {}) {
+  const enabled = await listEnabledFeatureFlagsBySlug(profile).then((ids) => resolveFeatureFlags(ids, false)["agent-memory"]).catch((err) => {
+    console.error("[memory] feature flag lookup failed:", err.message);
+    return false;
+  });
+  if (!enabled || opts.readable === false || !channelId || !isUuid(channelId)) return { enabled };
+  const memoryPrompt = await listChannelMemories(channelId).then((memories) => formatMemoryPrompt(channelId, memories)).catch((err) => {
+    console.error("[memory] memory lookup failed:", err.message);
+    return void 0;
+  });
+  return memoryPrompt ? { enabled, memoryPrompt } : { enabled };
+}
+
 // src/store/workspace-store.ts
 function rowToMembership(row) {
   return {
@@ -2163,6 +2497,7 @@ async function deleteWorkspace(workspace) {
 }
 async function setWorkspaceStripeSubscription(workspaceId, fields) {
   const { error } = await getSupabaseClient().from("workspaces").update({
+    plan: fields.plan,
     stripe_customer_id: fields.stripeCustomerId,
     stripe_subscription_id: fields.stripeSubscriptionId,
     plan_status: fields.planStatus
@@ -2175,6 +2510,14 @@ async function markWorkspaceAgentConnected(workspaceId) {
 async function markWorkspaceProjectsSetup(workspaceId) {
   await stampOnce(workspaceId, "projects_setup_at");
 }
+async function markWorkspaceGreeted(workspaceId) {
+  await stampOnce(workspaceId, "greeted_at");
+}
+async function getWorkspaceGreetedAt(workspaceId) {
+  const { data, error } = await getSupabaseClient().from("workspaces").select("greeted_at").eq("id", workspaceId).maybeSingle();
+  if (error) throw new Error(`getWorkspaceGreetedAt(${workspaceId}): ${error.message}`);
+  return data?.greeted_at ?? null;
+}
 async function stampOnce(workspaceId, column) {
   const { error } = await getSupabaseClient().from("workspaces").update({ [column]: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", workspaceId).is(column, null);
   if (error) throw new Error(`stampOnce(${workspaceId}, ${column}): ${error.message}`);
@@ -2190,11 +2533,12 @@ async function getWorkspaceByStripeCustomerId(stripeCustomerId) {
   return data;
 }
 async function getWorkspaceBilling(workspaceId) {
-  const { data, error } = await getSupabaseClient().from("workspaces").select("plan_status, stripe_customer_id, stripe_subscription_id").eq("id", workspaceId).maybeSingle();
+  const { data, error } = await getSupabaseClient().from("workspaces").select("plan, plan_status, stripe_customer_id, stripe_subscription_id").eq("id", workspaceId).maybeSingle();
   if (error) throw new Error(`getWorkspaceBilling(${workspaceId}): ${error.message}`);
   const row = data ?? {};
   return {
     planStatus: row["plan_status"] ?? null,
+    plan: row["plan"] ?? null,
     stripeCustomerId: row["stripe_customer_id"] ?? null,
     stripeSubscriptionId: row["stripe_subscription_id"] ?? null
   };
@@ -3731,17 +4075,21 @@ async function runAutomation(opts) {
 
 `;
   try {
+    const memory = await loadAgentMemory(getProfile(), channel && findChannel(channel)?.id);
     const useCodex = (explicitModel ? runnerForModel(explicitModel) === "codex" : runnerForModel(loadDashboardSettings().agent) === "codex") && !requiresClaudeAutomationRunner(prompt);
     const response = useCodex ? await askCodex(automationPrefix + prompt, cwd, {
       ...explicitModel && runnerForModel(explicitModel) === "codex" ? { model: explicitModel } : codexModel?.trim() ? { model: codexModel.trim() } : {},
       // Same reason as the interactive paths: no --append-system-prompt on
       // Codex, so the persona and channel instructions go in the prompt.
-      systemPrompt: buildSystemPrompt(
-        botName,
-        void 0,
-        resolveChannelPrompt(channel),
-        resolveSelectedOutputStyle(claudeConfigDir)?.body
-      ),
+      systemPrompt: [
+        buildSystemPrompt(
+          botName,
+          void 0,
+          resolveChannelPrompt(channel),
+          resolveSelectedOutputStyle(claudeConfigDir)?.body
+        ),
+        memory.memoryPrompt
+      ].filter(Boolean).join("\n\n"),
       // Same attribution as the Claude branch below — no userId, the
       // schedule's name is the label.
       usageContext: { source: "automation", channelId: channel, label: name }
@@ -3755,6 +4103,8 @@ async function runAutomation(opts) {
         model,
         maxBudgetUsd,
         channelPrompt: resolveChannelPrompt(channel),
+        ...memory.memoryPrompt ? { memoryPrompt: memory.memoryPrompt } : {},
+        ...memory.enabled ? { disableAutoMemory: true } : {},
         // No userId: nobody triggered this. The schedule's name is the
         // label, which is what makes "which automation is burning tokens"
         // answerable without joining anything.
@@ -8400,6 +8750,27 @@ export {
   docsAccessPromptNote,
   pinnedClaudeConfigDir,
   askClaude,
+  featureFlags,
+  featureFlagIds,
+  isFeatureFlagId,
+  isFeatureVisible,
+  resolveFeatureFlags,
+  listEnabledFeatureFlags,
+  enableFeatureFlag,
+  disableFeatureFlag,
+  MEMORY_TYPES,
+  isMemoryType,
+  validateMemoryInput,
+  listChannelMemories,
+  getChannelMemory,
+  saveChannelMemory,
+  updateChannelMemory,
+  searchChannelMemories,
+  deleteChannelMemory,
+  listThreadMemoryEvents,
+  undoMemoryEvent,
+  isUuid,
+  loadAgentMemory,
   getWorkspaceBySlug,
   getWorkspaceById,
   listWorkspaces,
@@ -8409,6 +8780,8 @@ export {
   setWorkspaceStripeSubscription,
   markWorkspaceAgentConnected,
   markWorkspaceProjectsSetup,
+  markWorkspaceGreeted,
+  getWorkspaceGreetedAt,
   getWorkspaceByStripeCustomerId,
   getWorkspaceBilling,
   updateWorkspacePlanStatus,