musecode 0.1.0

package/sessions.mjs

@@ -0,0 +1,102 @@
+// Read-only access to the user's existing Claude Code / Claude Desktop sessions in ~/.claude/projects.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const PROJECTS = path.join(os.homedir(), ".claude", "projects");
+// Internal sessions from tools like claude-mem, not conversations the user had.
+const SKIP_DIRS = [/claude-mem-observer/i];
+// A session file written to this recently is probably open in Desktop right now.
+const ACTIVE_MS = 3 * 60_000;
+
+const cache = new Map(); // file -> { mtimeMs, info }
+
+function parseLines(file) {
+  return fs.readFileSync(file, "utf8").split("\n").flatMap((l) => {
+    if (!l) return [];
+    try { return [JSON.parse(l)]; } catch { return []; }
+  });
+}
+
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+}
+
+function summarize(file, stat) {
+  let cwd = null, customTitle = null, aiTitle = null, firstPrompt = null, lastPrompt = null, messages = 0, permissionMode = null;
+  for (const e of parseLines(file)) {
+    if (!cwd && e.cwd) cwd = e.cwd;
+    // Ignore modes recorded by the bridge's own headless runs (sdk-cli); we want the mode the session really runs in.
+    if (e.permissionMode && e.entrypoint !== "sdk-cli") permissionMode = e.permissionMode;
+    if (e.type === "custom-title") customTitle = e.customTitle;
+    else if (e.type === "ai-title") aiTitle = e.aiTitle;
+    else if (e.type === "last-prompt") lastPrompt = e.lastPrompt;
+    else if ((e.type === "user" || e.type === "assistant") && !e.isSidechain) {
+      const text = textOf(e.message?.content);
+      if (!text) continue;
+      messages++;
+      if (!firstPrompt && e.type === "user") firstPrompt = text;
+    }
+  }
+  if (!cwd || !messages) return null;
+  const clip = (s) => (s ? s.replace(/\s+/g, " ").trim().slice(0, 140) : null);
+  return {
+    session_id: path.basename(file, ".jsonl"),
+    desktop_title: customTitle || aiTitle || null,
+    title: clip(customTitle || aiTitle || firstPrompt),
+    project_folder: cwd,
+    last_prompt: clip(lastPrompt),
+    permission_mode: permissionMode,
+    messages,
+    last_active: new Date(stat.mtimeMs).toISOString(),
+  };
+}
+
+function sessionFiles() {
+  if (!fs.existsSync(PROJECTS)) return [];
+  return fs.readdirSync(PROJECTS, { withFileTypes: true })
+    .filter((d) => d.isDirectory() && !SKIP_DIRS.some((re) => re.test(d.name)))
+    .flatMap((d) => fs.readdirSync(path.join(PROJECTS, d.name))
+      .filter((f) => f.endsWith(".jsonl"))
+      .map((f) => path.join(PROJECTS, d.name, f)));
+}
+
+function infoFor(file) {
+  const stat = fs.statSync(file);
+  const hit = cache.get(file);
+  if (!hit || hit.mtimeMs !== stat.mtimeMs) cache.set(file, { mtimeMs: stat.mtimeMs, info: summarize(file, stat) });
+  const info = cache.get(file).info;
+  return info && { ...info, open_now: Date.now() - stat.mtimeMs < ACTIVE_MS };
+}
+
+export function listSessions({ query, limit = 20, hide = new Set() } = {}) {
+  const q = query?.toLowerCase();
+  return sessionFiles().map(infoFor).filter((s) => s && !hide.has(s.session_id))
+    .filter((s) => !q || [s.title, s.project_folder, s.last_prompt].some((v) => v?.toLowerCase().includes(q)))
+    .sort((a, b) => b.last_active.localeCompare(a.last_active))
+    .slice(0, Math.min(limit, 100));
+}
+
+export function fileFor(sessionId) {
+  if (!/^[0-9a-f-]{36}$/i.test(sessionId || "")) return null;
+  return sessionFiles().find((f) => path.basename(f, ".jsonl") === sessionId) || null;
+}
+
+export function getSession(sessionId) {
+  const file = fileFor(sessionId);
+  return file ? infoFor(file) : null;
+}
+
+// Recent user/assistant text turns (tool calls and tool output left out).
+export function readSession(sessionId, last = 20) {
+  const file = fileFor(sessionId);
+  if (!file) return null;
+  const turns = parseLines(file)
+    .filter((e) => (e.type === "user" || e.type === "assistant") && !e.isSidechain)
+    .map((e) => ({ role: e.type, at: e.timestamp, text: textOf(e.message?.content).trim() }))
+    .filter((t) => t.text && !t.text.startsWith("<"))
+    .map((t) => ({ ...t, text: t.text.length > 3000 ? t.text.slice(0, 3000) + " …[truncated]" : t.text }));
+  return { ...infoFor(file), turns: turns.slice(-Math.min(Math.max(last, 1), 100)) };
+}

package/start.ps1

@@ -0,0 +1,45 @@
+# Starts a Cloudflare quick tunnel, then the bridge pinned to that tunnel's URL.
+# Ctrl+C stops both. The URL changes every run, so update the remote client after restarting.
+$ErrorActionPreference = "Stop"
+Set-Location $PSScriptRoot
+New-Item -ItemType Directory -Force data | Out-Null
+
+$cloudflared = (Get-Command cloudflared -ErrorAction SilentlyContinue).Source
+if (-not $cloudflared) { $cloudflared = "C:\Program Files (x86)\cloudflared\cloudflared.exe" }
+if (-not (Test-Path $cloudflared)) { Write-Host "cloudflared not found. Install: winget install --id Cloudflare.cloudflared"; exit 1 }
+
+$port = node --input-type=module -e "import('./lib.mjs').then(m => process.stdout.write(String(m.loadConfig().port)))"
+if (-not $port) { Write-Host "Could not load the bridge port from .env, config.json, or defaults." -ForegroundColor Red; exit 1 }
+
+$tunnelLog = "data\tunnel.log"
+Remove-Item $tunnelLog -ErrorAction SilentlyContinue
+$tunnel = Start-Process $cloudflared -ArgumentList "tunnel --no-autoupdate --url http://127.0.0.1:$port" `
+    -WindowStyle Hidden -PassThru -RedirectStandardError $tunnelLog -RedirectStandardOutput "data\tunnel.out.log"
+
+$url = $null
+for ($i = 0; $i -lt 45 -and -not $url; $i++) {
+    Start-Sleep -Seconds 1
+    $m = Select-String -Path $tunnelLog -Pattern "https://[a-z0-9-]+\.trycloudflare\.com" -ErrorAction SilentlyContinue | Select-Object -First 1
+    if ($m) { $url = $m.Matches[0].Value }
+}
+if (-not $url) {
+    Write-Host "Tunnel did not come up; see $tunnelLog" -ForegroundColor Red
+    Stop-Process -Id $tunnel.Id -ErrorAction SilentlyContinue
+    exit 1
+}
+
+Write-Host ""
+Write-Host "Tunnel is up." -ForegroundColor Green
+Write-Host "  MCP URL (give to Muse):  $url/mcp"
+Write-Host "  OpenAPI fallback:        $url/openapi.json"
+Write-Host "  Bearer token:            BRIDGE_TOKEN from .env (paste into the client's credential prompt, not a chat)"
+Write-Host "  Approvals:               ntfy app, topic BRIDGE_NTFY_TOPIC from .env"
+Write-Host ""
+
+$env:BRIDGE_PUBLIC_URL = $url
+try {
+    node server.mjs
+} finally {
+    Stop-Process -Id $tunnel.Id -ErrorAction SilentlyContinue
+    Write-Host "Tunnel stopped."
+}

package/threads.mjs

@@ -0,0 +1,59 @@
+// Side threads: an agent-to-agent channel per PC session, kept apart from the user's own conversation.
+// Each message carries an explicit role so it's never ambiguous who said what:
+//   muse            Meta Muse (via the bridge)
+//   side-claude     the side agent answering Muse (a read-only fork of the session)
+//   desktop-claude  the main session's Claude, posting via the muse-inbox MCP tools
+//   desktop-codex   the main Codex session, posting via the muse-inbox MCP tools
+//   user            the user, posting from the local viewer
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { DATA } from "./lib.mjs";
+
+const DIR = path.join(DATA, "threads");
+fs.mkdirSync(DIR, { recursive: true });
+
+export const ROLES = ["muse", "side-claude", "desktop-claude", "desktop-codex", "user"];
+const validId = (id) => /^[0-9a-f-]{36}$/i.test(id || "");
+const logFile = (id) => path.join(DIR, `${id}.jsonl`);
+const metaFile = (id) => path.join(DIR, `${id}.meta.json`);
+
+export function appendMessage(sessionId, role, text, extra = {}) {
+  if (!validId(sessionId)) throw new Error("Invalid session_id");
+  if (!ROLES.includes(role)) throw new Error(`Invalid role ${role}`);
+  const msg = { id: crypto.randomUUID(), at: new Date().toISOString(), role, text, ...extra };
+  fs.appendFileSync(logFile(sessionId), JSON.stringify(msg) + "\n");
+  return msg;
+}
+
+export function readThread(sessionId, { since } = {}) {
+  if (!validId(sessionId) || !fs.existsSync(logFile(sessionId))) return [];
+  const all = fs.readFileSync(logFile(sessionId), "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
+  if (!since) return all;
+  const i = all.findIndex((m) => m.id === since);
+  return i >= 0 ? all.slice(i + 1) : all.filter((m) => m.at > since);
+}
+
+export function getMeta(sessionId) {
+  if (!validId(sessionId) || !fs.existsSync(metaFile(sessionId))) return {};
+  return JSON.parse(fs.readFileSync(metaFile(sessionId), "utf8"));
+}
+
+export function setMeta(sessionId, meta) {
+  fs.writeFileSync(metaFile(sessionId), JSON.stringify({ ...getMeta(sessionId), ...meta }, null, 2));
+}
+
+export function listThreads() {
+  return fs.readdirSync(DIR).filter((f) => f.endsWith(".jsonl")).map((f) => {
+    const sessionId = f.replace(/\.jsonl$/, "");
+    const msgs = readThread(sessionId);
+    const last = msgs[msgs.length - 1];
+    return { session_id: sessionId, title: getMeta(sessionId).title || null, messages: msgs.length, last_at: last?.at, last_role: last?.role };
+  }).sort((a, b) => (b.last_at || "").localeCompare(a.last_at || ""));
+}
+
+// Fork sessions created for side agents, so they can be hidden from list_sessions.
+export function sideForkIds() {
+  return new Set(fs.readdirSync(DIR).filter((f) => f.endsWith(".meta.json"))
+    .map((f) => JSON.parse(fs.readFileSync(path.join(DIR, f), "utf8")).forkSessionId).filter(Boolean));
+}