brane 0.1.1 → 0.3.1

package/dist/absorb/sources.js

@@ -0,0 +1,168 @@
+/** The inventory behind a bare `brane absorb`: every session store brane
+ *  knows how to look for, whether it is on this machine, and what an import
+ *  would do with it. Reads no message content — the survey is a promise a
+ *  new user can be given ("it tells you what it found; nothing leaves the
+ *  machine, nothing is imported until you say") and it is kept by
+ *  construction: `LocalSource.survey` is a stat and a head read, and the
+ *  probes below are `existsSync`.
+ */
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { claudeCodeSource } from "./claude-code.js";
+import { toPortablePath } from "../db/schema.js";
+import { deriveBraneId } from "./brane-id.js";
+/** Local sources with an extractor, in the order the survey lists them. */
+export const LOCAL_SOURCES = [claudeCodeSource];
+export function getLocalSource(name) {
+    return LOCAL_SOURCES.find((s) => s.name === name);
+}
+/** Stores brane recognises but cannot read yet. Listed so the survey says
+ *  "found, no extractor" rather than nothing — the operator learns what is
+ *  on the machine either way, and which line to ask for next. Today the
+ *  list is the agents brane can spawn (see `AGENTS` in src/agents.ts) plus
+ *  the other Claude product with a local transcript, because those are the
+ *  formats someone here has looked at. Nothing ties an entry — or a
+ *  `LocalSource` — to spawn support: an importer for a tool brane cannot
+ *  run is welcome (claude-xiy9e8wq:17); the list just isn't speculative. */
+const PROBES = [
+    { name: "codex", label: "Codex CLI rollouts", under: (h) => join(h, ".codex", "sessions") },
+    { name: "goose", label: "goose sessions", under: (h) => join(h, ".local", "share", "goose", "sessions") },
+    { name: "copilot", label: "GitHub Copilot CLI session store", under: (h) => join(h, ".copilot", "session-store.db") },
+    { name: "gemini", label: "Gemini CLI", under: (h) => join(h, ".gemini", "tmp") },
+    { name: "cline", label: "Cline tasks", under: (h) => join(h, ".cline", "data", "tasks") },
+    { name: "amp", label: "Amp", under: (h) => join(h, ".amp") },
+    {
+        name: "claude-desktop",
+        label: "Claude Desktop agent-mode sessions",
+        under: (h) => join(h, "Library", "Application Support", "Claude", "local-agent-mode-sessions"),
+    },
+];
+/** Classify every candidate against the database in one pass: managed by a
+ *  live narrative (any brane), absorbed before into `braneId` (and whether
+ *  the file has changed since), or new to that brane. Shared by the survey
+ *  and the import so they cannot disagree. */
+export function classifySessions(db, source, candidates, braneId) {
+    const out = new Map();
+    if (candidates.length === 0)
+        return out;
+    // Live narratives of this agent type: the session ids they have bound.
+    const managed = new Map();
+    const rows = db
+        .prepare(`SELECT id, agent_session_id, session_ids FROM narratives
+        WHERE agent_type = ? AND role != 'absorbed'
+          AND (agent_session_id IS NOT NULL OR session_ids IS NOT NULL)`)
+        .all(source.name);
+    for (const r of rows) {
+        if (r.agent_session_id)
+            managed.set(r.agent_session_id, r.id);
+        if (r.session_ids) {
+            try {
+                const ids = JSON.parse(r.session_ids);
+                if (Array.isArray(ids))
+                    for (const id of ids)
+                        if (typeof id === "string")
+                            managed.set(id, r.id);
+            }
+            catch {
+                // malformed column value; agent_session_id above still counts
+            }
+        }
+    }
+    const absorbed = db.prepare(`SELECT id FROM narratives
+      WHERE agent_type = ? AND role = 'absorbed' AND agent_session_id = ? AND brane_id = ?`);
+    const fileRow = db.prepare("SELECT bytes, mtime, parser_version FROM absorb_files WHERE brane_id = ? AND provider = ? AND external_id = ?");
+    for (const c of candidates) {
+        const managedBy = managed.get(c.externalId) ?? null;
+        const abs = absorbed.get(source.name, c.externalId, braneId);
+        const f = fileRow.get(braneId, source.name, c.externalId);
+        // Unchanged means nothing new could come of reading it: the same
+        // bytes, read last time by a parser that knew what this one knows.
+        const sameFile = !!f && f.bytes === c.bytes && f.mtime === c.updatedAt;
+        const current = !!f && f.parser_version >= source.parserVersion;
+        out.set(c.externalId, {
+            managedBy,
+            absorbedBy: abs?.id ?? null,
+            unchanged: sameFile && current,
+            reparse: sameFile && !current,
+        });
+    }
+    return out;
+}
+export function surveyAbsorbSources(db, home) {
+    const sources = [];
+    for (const src of LOCAL_SOURCES) {
+        const root = src.locate(home);
+        const report = {
+            name: src.name,
+            label: labelFor(src.name),
+            path: toPortablePath(root ?? defaultPathFor(src.name, home)),
+            found: root !== null,
+            supported: true,
+        };
+        if (root) {
+            const candidates = src.survey(root);
+            // The survey answers for the brane a plain `brane absorb <source>`
+            // would target — the one derived from the account — since that is
+            // the import it is previewing.
+            const status = classifySessions(db, src, candidates, deriveBraneId(src.name, src.identity(home).id));
+            const s = { total: 0, new: 0, changed: 0, unchanged: 0, reparse: 0, managed: 0, bytes: 0, folds: 0, oldest: null, newest: null };
+            const folds = new Set();
+            for (const c of candidates) {
+                s.total++;
+                s.bytes += c.bytes;
+                if (c.cwd)
+                    folds.add(c.cwd);
+                if (c.startedAt !== null && (s.oldest === null || c.startedAt < s.oldest))
+                    s.oldest = c.startedAt;
+                if (s.newest === null || c.updatedAt > s.newest)
+                    s.newest = c.updatedAt;
+                const st = status.get(c.externalId);
+                if (st.managedBy)
+                    s.managed++;
+                else if (st.absorbedBy)
+                    (st.unchanged ? s.unchanged++ : st.reparse ? s.reparse++ : s.changed++);
+                else
+                    s.new++;
+            }
+            s.folds = folds.size;
+            report.sessions = s;
+        }
+        sources.push(report);
+    }
+    for (const probe of PROBES) {
+        const path = probe.under(home);
+        sources.push({
+            name: probe.name,
+            label: probe.label,
+            path: toPortablePath(path),
+            found: existsSync(path) && !isEmptyDir(path),
+            supported: false,
+        });
+    }
+    return { home, sources };
+}
+function isEmptyDir(path) {
+    try {
+        return statSync(path).isDirectory() && readdirSync(path).length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function labelFor(name) {
+    switch (name) {
+        case "claude":
+            return "Claude Code sessions";
+        default:
+            return name;
+    }
+}
+function defaultPathFor(name, home) {
+    switch (name) {
+        case "claude":
+            return join(home, ".claude", "projects");
+        default:
+            return home;
+    }
+}
+//# sourceMappingURL=sources.js.map

package/dist/absorb/types.js

@@ -0,0 +1,3 @@
+/** Shared types for the absorb (import) system */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/agent-env.js

@@ -0,0 +1,45 @@
+/**
+ * The environment variables that identify one agent session, which nothing
+ * the daemon starts may inherit.
+ *
+ * A daemon restarted from an agent's shell (as /rrr does) inherits that
+ * agent's environment, and so does every tmux server and session it then
+ * starts. Brane's own pair would let another session act as that agent
+ * (claude-jrjh1e8w:10). The harness's session variables do damage too: the
+ * MCP bridge forwards `CLAUDE_CODE_SESSION_ID` as its author's session, so a
+ * crush agent spawned by such a daemon stamped every narration with the
+ * restarting Claude session's id (claude-eiuzl79r:33), and carried a copy of
+ * that session's `CLAUDE_CODE_MESSAGING_TOKEN`. Claude overrides these for
+ * its own children; other harnesses do not.
+ *
+ * Only session-scoped names belong here. User configuration that happens to
+ * share a prefix (`CLAUDE_CODE_USE_BEDROCK`, `CLAUDE_CODE_MAX_OUTPUT_TOKENS`)
+ * is the operator's and passes through.
+ */
+export const INHERITED_AGENT_ENV = [
+    "BRANE_NARRATIVE_ID",
+    "BRANE_NARRATIVE_SECRET",
+    "CLAUDECODE",
+    "CLAUDE_CODE_SESSION_ID",
+    "CLAUDE_CODE_CHILD_SESSION",
+    "CLAUDE_CODE_ENTRYPOINT",
+    "CLAUDE_CODE_EXECPATH",
+    "CLAUDE_CODE_MESSAGING_SOCKET",
+    "CLAUDE_CODE_MESSAGING_TOKEN",
+    "CLAUDE_CODE_SESSION_ATTENDED",
+    "CLAUDE_CODE_SSE_PORT",
+    "CLAUDE_PID",
+];
+/** `env` without any inherited agent-session variable. */
+export function withoutAgentEnv(env) {
+    const out = { ...env };
+    for (const name of INHERITED_AGENT_ENV)
+        delete out[name];
+    return out;
+}
+/** A shell prefix that runs a command with every inherited agent-session
+ *  variable unset, for commands tmux starts from its global env. */
+export function unsetAgentEnvPrefix() {
+    return `env ${INHERITED_AGENT_ENV.map((name) => `-u ${name}`).join(" ")}`;
+}
+//# sourceMappingURL=agent-env.js.map