@jbarket/loomai 0.9.1 → 0.10.0

package/dist/household.js

@@ -0,0 +1,389 @@
+/**
+ * The household (docs/specs/household.md): one loom, many agents.
+ *
+ *   $LOOM_HOME/household.json   agents, the default agent, the owner
+ *   $LOOM_HOME/tokens.json      every token by its sha256: label, role, use
+ *   $LOOM_HOME/agents/<name>/   an agent's context dir, exactly as before
+ *
+ * A context dir with no household around it is a household of one and
+ * behaves exactly as it always has: nothing here is consulted for it.
+ *
+ * Tokens carry a role: `agent:<name>` (MCP and the CLI as that agent),
+ * `owner` (everything, and the page), or `peer:<name>` (knowledge only).
+ * The daemon resolves the role on every request; no tool takes an agent
+ * argument, so a body can only ever be the agent its token names.
+ */
+import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+export const AGENT_NAME = /^[a-z][a-z0-9-]{0,39}$/;
+const HOUSEHOLD_FILE = 'household.json';
+const TOKENS_FILE = 'tokens.json';
+/**
+ * When each token was last used, by sha256. Its own file so the daemon never
+ * rewrites tokens.json: a read-modify-write there could race a `loom token
+ * revoke` and quietly undo it.
+ */
+const USED_FILE = 'tokens.used.json';
+export class HouseholdError extends Error {
+}
+/** $LOOM_HOME, else ~/.config/loom. */
+export function householdHome(env = process.env) {
+    return resolve(env.LOOM_HOME || join(homedir(), '.config', 'loom'));
+}
+export function agentDir(h, agent) {
+    return join(h.home, 'agents', agent);
+}
+function readJson(path) {
+    return JSON.parse(readFileSync(path, 'utf-8'));
+}
+/** The household at `home`, or null when there's none. Throws on a malformed file. */
+export function loadHousehold(home) {
+    const path = join(home, HOUSEHOLD_FILE);
+    if (!existsSync(path))
+        return null;
+    const raw = readJson(path);
+    if (raw?.v !== 1)
+        throw new HouseholdError(`${path}: v must be 1`);
+    const agents = raw.agents;
+    if (!Array.isArray(agents) || agents.length === 0 || !agents.every((a) => typeof a === 'string' && AGENT_NAME.test(a))) {
+        throw new HouseholdError(`${path}: agents must be a non-empty list of agent names (lowercase letters, digits, dashes)`);
+    }
+    const def = typeof raw.default === 'string' ? raw.default : agents[0];
+    if (!agents.includes(def))
+        throw new HouseholdError(`${path}: default ${JSON.stringify(def)} is not one of the agents`);
+    return {
+        home: resolve(home),
+        agents: agents,
+        default: def,
+        owner: typeof raw.owner === 'string' ? raw.owner : undefined,
+    };
+}
+/**
+ * The household a context dir belongs to: one whose `agents/<name>` is this
+ * dir (after resolving symlinks, so an old `~/.config/loom/art` link still
+ * finds it). Null for a plain context dir.
+ */
+export function householdOf(contextDir) {
+    let real;
+    try {
+        real = realpathSync(contextDir);
+    }
+    catch {
+        return null;
+    }
+    const agentsDir = dirname(real);
+    if (basename(agentsDir) !== 'agents')
+        return null;
+    const h = loadHousehold(dirname(agentsDir));
+    const agent = basename(real);
+    if (!h || !h.agents.includes(agent))
+        return null;
+    return { household: h, agent };
+}
+export function parseRole(s) {
+    if (s === 'owner')
+        return { kind: 'owner' };
+    const m = /^(agent|peer):([a-z][a-z0-9-]{0,39})$/.exec(s);
+    if (!m)
+        return null;
+    return m[1] === 'agent' ? { kind: 'agent', agent: m[2] } : { kind: 'peer', name: m[2] };
+}
+export function roleString(r) {
+    return r.kind === 'owner' ? 'owner' : r.kind === 'agent' ? `agent:${r.agent}` : `peer:${r.name}`;
+}
+const sha = (s) => createHash('sha256').update(s).digest('hex');
+function writePrivate(path, body) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, body, { mode: 0o600 });
+    chmodSync(tmp, 0o600);
+    renameSync(tmp, path);
+}
+function loadUsed(home) {
+    try {
+        const raw = readJson(join(home, USED_FILE));
+        return Object.fromEntries(Object.entries(raw).filter((e) => typeof e[1] === 'string'));
+    }
+    catch {
+        return {};
+    }
+}
+/** Every token record, with when it was last used merged in. */
+const LOCK_FILE = '.household.lock';
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === 'EPERM';
+    }
+}
+/**
+ * Serialize every read-modify-write of household.json and tokens.json, so
+ * two `loom token` runs can't interleave and drop each other's change (a
+ * create racing a revoke must not bring the revoked token back). The lock
+ * holds its owner's pid. It is never broken automatically: every way of
+ * breaking a stale lock races another waiter doing the same, and these locks
+ * are only taken by the owner's own occasional commands, so a lock left by a
+ * dead process is reported with what to do instead.
+ */
+function withLock(home, f) {
+    mkdirSync(home, { recursive: true, mode: 0o700 });
+    const lock = join(home, LOCK_FILE);
+    const mine = String(process.pid);
+    const deadline = Date.now() + 5_000;
+    for (;;) {
+        try {
+            writeFileSync(lock, mine, { flag: 'wx', mode: 0o600 });
+            break;
+        }
+        catch (err) {
+            if (err.code !== 'EEXIST')
+                throw err;
+            let holder = NaN;
+            try {
+                holder = Number.parseInt(readFileSync(lock, 'utf-8'), 10);
+            }
+            catch {
+                continue; /* just released */
+            }
+            if (Number.isSafeInteger(holder) && holder > 0 && !alive(holder)) {
+                throw new HouseholdError(`${lock} was left by pid ${holder}, which isn't running; if no loom command is running, remove that file and try again`);
+            }
+            if (Date.now() > deadline)
+                throw new HouseholdError(`${lock} is held by another loom process (pid ${Number.isNaN(holder) ? '?' : holder}); try again`);
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+        }
+    }
+    try {
+        return f();
+    }
+    finally {
+        try {
+            if (readFileSync(lock, 'utf-8') === mine)
+                rmSync(lock, { force: true });
+        }
+        catch { /* already gone */ }
+    }
+}
+const SHA_HEX = /^[0-9a-f]{64}$/;
+function validRecord(t) {
+    if (typeof t !== 'object' || t === null)
+        return false;
+    const r = t;
+    return typeof r.label === 'string' && typeof r.role === 'string' && typeof r.sha256 === 'string' && SHA_HEX.test(r.sha256)
+        && typeof r.created === 'string' && (r.revoked === undefined || typeof r.revoked === 'string');
+}
+/**
+ * The token file has to be private: owned by this user, not writable by
+ * group or world, in a directory that isn't either. Anyone who can write it
+ * can mint themselves an owner token.
+ */
+function assertPrivate(path) {
+    if (typeof process.getuid !== 'function')
+        return;
+    const uid = process.getuid();
+    for (const p of [path, dirname(path)]) {
+        const st = statSync(p);
+        if (st.uid !== uid)
+            throw new HouseholdError(`${p} is owned by another user; refusing to trust it`);
+        if (st.mode & 0o022)
+            throw new HouseholdError(`${p} is writable by group or others; run chmod go-w on it`);
+    }
+}
+export function loadTokens(home) {
+    const path = join(home, TOKENS_FILE);
+    if (!existsSync(path))
+        return [];
+    assertPrivate(path);
+    const raw = readJson(path);
+    if (raw?.v !== 1 || !Array.isArray(raw.tokens))
+        throw new HouseholdError(`${path}: expected {"v": 1, "tokens": [...]}`);
+    if (!raw.tokens.every(validRecord))
+        throw new HouseholdError(`${path}: a token record is malformed (label, role, a 64-hex sha256 and created are required)`);
+    const used = loadUsed(home);
+    return raw.tokens.map((t) => {
+        const { last_used: _ignored, ...rest } = t;
+        return used[t.sha256] ? { ...rest, last_used: used[t.sha256] } : rest;
+    });
+}
+function saveTokens(home, tokens) {
+    const records = tokens.map(({ last_used: _l, ...t }) => t);
+    writePrivate(join(home, TOKENS_FILE), JSON.stringify({ v: 1, tokens: records }, null, 2) + '\n');
+}
+/** A role must name an agent this household has. */
+function checkRole(h, role) {
+    if (role.kind === 'agent' && !h.agents.includes(role.agent)) {
+        throw new HouseholdError(`no agent named ${role.agent} in this household (${h.agents.join(', ')})`);
+    }
+}
+/** Mint a token. Returns it once; only its sha256 is kept. */
+export function createToken(h, input, now = new Date()) {
+    checkRole(h, input.role);
+    const label = input.label.trim();
+    if (!label || label.length > 120 || /[\x00-\x1f\x7f]/.test(label))
+        throw new HouseholdError('a token needs a label (120 printable characters at most)');
+    return withLock(h.home, () => {
+        const tokens = loadTokens(h.home);
+        if (tokens.some((t) => t.label === label && !t.revoked))
+            throw new HouseholdError(`a live token is already labeled ${JSON.stringify(label)}`);
+        const token = `loom_${randomBytes(32).toString('base64url')}`;
+        const record = { label, role: roleString(input.role), sha256: sha(token), created: now.toISOString() };
+        saveTokens(h.home, [...tokens, record]);
+        return { token, record };
+    });
+}
+export function revokeToken(h, label, now = new Date()) {
+    return withLock(h.home, () => {
+        const tokens = loadTokens(h.home);
+        const t = tokens.find((x) => x.label === label && !x.revoked);
+        if (!t)
+            throw new HouseholdError(`no live token labeled ${JSON.stringify(label)}`);
+        t.revoked = now.toISOString();
+        saveTokens(h.home, tokens);
+        return t;
+    });
+}
+/**
+ * Resolves presented tokens to roles. Reads tokens.json when it changes (so
+ * a revoke takes effect on the next request), compares digests in constant
+ * time, and records when a token was last used, at most once a minute.
+ */
+export class TokenResolver {
+    h;
+    cache = null;
+    lastTouch = new Map();
+    constructor(h) {
+        this.h = h;
+    }
+    current() {
+        const path = join(this.h.home, TOKENS_FILE);
+        let key;
+        // Every write is a rename, so the inode changes even where mtimes are coarse.
+        try {
+            const st = statSync(path);
+            key = `${st.ino}:${st.size}:${st.mtimeMs}:${st.ctimeMs}:${st.mode}`;
+        }
+        catch {
+            return [];
+        }
+        if (!this.cache || this.cache.key !== key)
+            this.cache = { key, tokens: loadTokens(this.h.home) };
+        return this.cache.tokens;
+    }
+    /**
+     * The role for a presented token, or null. Revoked tokens and roles naming a
+     * missing agent resolve to null. Throws HouseholdError when tokens.json is
+     * unreadable or untrusted: the caller fails closed.
+     */
+    resolve(presented) {
+        const d = Buffer.from(sha(presented), 'hex');
+        const hit = this.current().find((t) => !t.revoked && t.sha256.length === 64 && timingSafeEqual(Buffer.from(t.sha256, 'hex'), d));
+        if (!hit)
+            return null;
+        const role = parseRole(hit.role);
+        if (!role || (role.kind === 'agent' && !this.h.agents.includes(role.agent)))
+            return null;
+        this.touch(hit.sha256);
+        return role;
+    }
+    /** Whether a live owner token has this sha256 (the page's sessions check this, so revoking ends them). */
+    ownerDigestLive(digestHex) {
+        return this.current().some((t) => !t.revoked && t.role === 'owner' && t.sha256 === digestHex);
+    }
+    touch(digest) {
+        const now = Date.now();
+        if (now - (this.lastTouch.get(digest) ?? 0) < 60_000)
+            return;
+        this.lastTouch.set(digest, now);
+        // Only tokens.used.json, never tokens.json: see USED_FILE.
+        try {
+            const used = loadUsed(this.h.home);
+            used[digest] = new Date(now).toISOString();
+            writePrivate(join(this.h.home, USED_FILE), JSON.stringify(used) + '\n');
+        }
+        catch { /* last-used is a nicety; never fail a request over it */ }
+    }
+}
+/**
+ * Turn a plain context dir into the first agent of a new household: move
+ * `<home>/<name>` to `<home>/agents/<name>`, leave a symlink at the old path
+ * so anything that still names it keeps working, and write household.json.
+ */
+export function initHousehold(home, agent, opts = {}) {
+    if (!AGENT_NAME.test(agent))
+        throw new HouseholdError(`${agent} isn't an agent name (lowercase letters, digits, dashes)`);
+    home = resolve(home);
+    if (existsSync(join(home, HOUSEHOLD_FILE)))
+        throw new HouseholdError(`${home} already has a household.json`);
+    const from = join(home, agent);
+    const to = join(home, 'agents', agent);
+    if (existsSync(to))
+        throw new HouseholdError(`${to} already exists`);
+    if (existsSync(from) && lstatSync(from).isSymbolicLink()) {
+        throw new HouseholdError(`${from} is a symlink; move the real directory to ${to} yourself, or point LOOM_HOME at where it lives`);
+    }
+    if (!existsSync(join(from, 'IDENTITY.md')) && !existsSync(join(from, 'memories.db'))) {
+        throw new HouseholdError(`${from} doesn't look like a context dir (no IDENTITY.md or memories.db)`);
+    }
+    mkdirSync(join(home, 'agents'), { recursive: true, mode: 0o700 });
+    renameSync(from, to);
+    symlinkSync(join('agents', agent), from);
+    const h = { home, agents: [agent], default: agent, owner: opts.owner };
+    withLock(home, () => writePrivate(join(home, HOUSEHOLD_FILE), JSON.stringify({ v: 1, agents: h.agents, default: h.default, ...(h.owner ? { owner: h.owner } : {}) }, null, 2) + '\n'));
+    return h;
+}
+/**
+ * An agent's directory must be a real directory, not a symlink: `agents/mark
+ * -> art` would make two agents share one stack.
+ */
+export function assertRealAgentDir(h, agent) {
+    const dir = agentDir(h, agent);
+    let st;
+    try {
+        st = lstatSync(dir);
+    }
+    catch {
+        throw new HouseholdError(`${dir} doesn't exist; bootstrap the agent first`);
+    }
+    if (st.isSymbolicLink() || !st.isDirectory())
+        throw new HouseholdError(`${dir} must be a real directory, not a symlink or a file`);
+}
+/** Add an agent to a household (its directory must already exist under agents/). */
+export function addAgent(h, agent) {
+    if (!AGENT_NAME.test(agent))
+        throw new HouseholdError(`${agent} isn't an agent name`);
+    if (h.agents.includes(agent))
+        return h;
+    assertRealAgentDir(h, agent);
+    return withLock(h.home, () => {
+        const current = loadHousehold(h.home) ?? h;
+        if (current.agents.includes(agent))
+            return current;
+        const next = { ...current, agents: [...current.agents, agent] };
+        writePrivate(join(h.home, HOUSEHOLD_FILE), JSON.stringify({ v: 1, agents: next.agents, default: next.default, ...(next.owner ? { owner: next.owner } : {}) }, null, 2) + '\n');
+        return next;
+    });
+}
+/**
+ * The context dir a household names when nothing else does: with LOOM_HOME
+ * set and a household.json there, `agents/<LOOM_AGENT or the default>`.
+ * Undefined otherwise. Only an explicit LOOM_HOME is consulted here, so a
+ * stray household.json never changes where an unconfigured process looks.
+ * (A daemon is different: one whose context dir already is
+ * `<home>/agents/<name>` serves that household; see householdOf.)
+ */
+export function contextFromHome(env = process.env) {
+    if (!env.LOOM_HOME)
+        return undefined;
+    const h = loadHousehold(householdHome(env));
+    if (!h)
+        return undefined;
+    const agent = env.LOOM_AGENT || h.default;
+    if (!h.agents.includes(agent))
+        throw new HouseholdError(`LOOM_AGENT=${agent} isn't in the household at ${h.home} (${h.agents.join(', ')})`);
+    return agentDir(h, agent);
+}

package/dist/injection/writer.js

@@ -12,6 +12,7 @@
  */
 import { readFile, writeFile, rename, mkdir, stat, chmod } from 'node:fs/promises';
 import { dirname } from 'node:path';
+import { randomBytes } from 'node:crypto';
 export class MalformedMarkersError extends Error {
     path;
     reason;
@@ -66,9 +67,11 @@ async function readIfExists(path) {
 }
 export async function atomicWrite(path, content, preserveModeFrom) {
     await mkdir(dirname(path), { recursive: true });
-    const tmp = `${path}.loom.tmp`;
+    // A fresh, random temp name opened exclusively ('wx'): a fixed name could be
+    // a symlink someone left there, and writing through it would land anywhere.
+    const tmp = `${path}.${randomBytes(6).toString('hex')}.loom.tmp`;
     const buf = Buffer.from(content, 'utf-8');
-    await writeFile(tmp, buf);
+    await writeFile(tmp, buf, { flag: 'wx' });
     if (preserveModeFrom) {
         try {
             const s = await stat(preserveModeFrom);

package/dist/path-safety.d.ts

@@ -1,7 +1,7 @@
 /**
  * Returns a human-readable error string when `value` cannot be used as a
  * single path segment, or null when it is safe. Rejects empty strings,
- * '.', '..', path separators (both / and \), and null bytes.
+ * '.', '..', path separators (both / and \), and control characters.
  */
 export declare function pathSegmentError(value: string, paramName: string): string | null;
 /**

package/dist/path-safety.js

@@ -18,7 +18,7 @@ import { atomicWrite } from './injection/writer.js';
 /**
  * Returns a human-readable error string when `value` cannot be used as a
  * single path segment, or null when it is safe. Rejects empty strings,
- * '.', '..', path separators (both / and \), and null bytes.
+ * '.', '..', path separators (both / and \), and control characters.
  */
 export function pathSegmentError(value, paramName) {
     if (value === '' ||
@@ -26,9 +26,11 @@ export function pathSegmentError(value, paramName) {
         value === '..' ||
         value.includes('/') ||
         value.includes('\\') ||
-        value.includes('\0')) {
+        // Control characters (NUL, newlines, …): a name that ends up inside a
+        // file must not be able to start a new line there.
+        /[\x00-\x1f\x7f]/.test(value)) {
         return (`Invalid ${paramName} ${JSON.stringify(value)}: ` +
-            'must be a non-empty name with no path separators.');
+            'must be a non-empty name with no path separators or control characters.');
     }
     return null;
 }

package/dist/server.d.ts

@@ -8,6 +8,13 @@ export interface LoomServerConfig {
      * signal channel. Set via LOOM_GAPS_DIR env var in production.
      */
     gapsDir?: string;
+    /**
+     * Served over the network (the HTTP daemon), not as a local stdio server.
+     * Tools that would touch the server's own filesystem outside the stack
+     * (harness_init's `target`) refuse then: the path would name a file on the
+     * daemon's machine, not the caller's.
+     */
+    remote?: boolean;
 }
 export interface LoomServerInstance {
     server: McpServer;

package/dist/server.js

@@ -38,7 +38,7 @@ import { memoryRevisionRestore } from './tools/memory-revision-restore.js';
 import { personWrite, personVerify, personArchive, personRestore, person, personList, personHistory, personRevisionRestore, } from './tools/person.js';
 // ─── Server Factory ───────────────────────────────────────────────────────────
 export function createLoomServer(config) {
-    const { contextDir, gapsDir } = config;
+    const { contextDir, gapsDir, remote = false } = config;
     // Refuse to boot against a stack this loom build doesn't understand.
     assertStackVersionCompatible(contextDir);
     // Refuse to serve a blank identity from the default fallback path.
@@ -474,7 +474,7 @@ export function createLoomServer(config) {
         },
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
     }, async ({ name, overwrite, target }) => {
-        const text = await harnessInit(contextDir, { name, overwrite, target });
+        const text = await harnessInit(contextDir, { name, overwrite, target }, { remote });
         return { content: [{ type: 'text', text }] };
     });
     server.registerTool('harness_describe', {

package/dist/tools/harness.d.ts

@@ -1,7 +1,24 @@
+/**
+ * Why `target` may not be written, or null. Over the network it never may:
+ * the path is on the daemon's machine, and a caller who could name it could
+ * write into another agent's stack or a shell rc file. Locally it must be an
+ * instruction file a harness reads, by name.
+ */
+export declare function harnessTargetError(target: string, opts: {
+    remote: boolean;
+}, real?: string): string | null;
+/**
+ * Where a target really is: through a symlink (a dotfiles repo's CLAUDE.md),
+ * so the rule above applies to the file actually written, and the write goes
+ * there instead of replacing the link.
+ */
+export declare function realTarget(target: string): string;
 export declare function harnessInit(contextDir: string, input: {
     name: string;
     overwrite?: boolean;
     target?: string;
+}, opts?: {
+    remote?: boolean;
 }): Promise<string>;
 /**
  * MCP tool handler for harness self-description.

package/dist/tools/harness.js

@@ -8,11 +8,54 @@
  * "no-change" when the block is already present and intact, "updated"
  * when it was missing or corrupted.
  */
+import { realpathSync } from 'node:fs';
 import { initHarness, describeHarness, resolvePeerToHarness, normalizePeer } from '../blocks/harness.js';
 import { renderBlock } from '../injection/render.js';
 import { writeManagedBlock } from '../injection/writer.js';
 import { HARNESSES, isHarnessKey } from '../injection/harnesses.js';
-export async function harnessInit(contextDir, input) {
+/** The instruction files a managed block may be written into: what harnesses read. */
+const INSTRUCTION_FILES = new Set(['CLAUDE.md', 'AGENTS.md', 'GEMINI.md', 'CODEX.md', 'QWEN.md', 'CLAUDE.local.md']);
+/**
+ * Why `target` may not be written, or null. Over the network it never may:
+ * the path is on the daemon's machine, and a caller who could name it could
+ * write into another agent's stack or a shell rc file. Locally it must be an
+ * instruction file a harness reads, by name.
+ */
+export function harnessTargetError(target, opts, real = realTarget(target)) {
+    if (opts.remote) {
+        return 'Error: harness_init can\'t write a target file over the network: the path would be on the loom server, not your machine. Run `loom inject --harness <name> --to <file>` on your own machine instead.';
+    }
+    if (/[\x00-\x1f\x7f]/.test(target))
+        return 'Error: target contains control characters.';
+    for (const p of [target, real]) {
+        const base = p.split(/[\\/]/).pop() ?? '';
+        if (!INSTRUCTION_FILES.has(base)) {
+            return `Error: target must be a harness instruction file (${[...INSTRUCTION_FILES].join(', ')}), not ${JSON.stringify(base)}.`;
+        }
+    }
+    return null;
+}
+/**
+ * Where a target really is: through a symlink (a dotfiles repo's CLAUDE.md),
+ * so the rule above applies to the file actually written, and the write goes
+ * there instead of replacing the link.
+ */
+export function realTarget(target) {
+    try {
+        return realpathSync(target);
+    }
+    catch {
+        return target;
+    }
+}
+export async function harnessInit(contextDir, input, opts = {}) {
+    // Resolve the target once; the path checked is the path written.
+    const real = input.target !== undefined ? realTarget(input.target) : undefined;
+    if (input.target !== undefined) {
+        const err = harnessTargetError(input.target, { remote: opts.remote ?? false }, real);
+        if (err)
+            return err;
+    }
     const manifestResult = await initHarness(contextDir, input.name, {
         overwrite: input.overwrite,
     });
@@ -22,7 +65,7 @@ export async function harnessInit(contextDir, input) {
             ? HARNESSES[input.name]
             : { key: input.name, display: input.name, defaultPath: input.target, toolPrefix: 'mcp__loom__' };
         const block = renderBlock(preset, contextDir);
-        const blockResult = await writeManagedBlock(input.target, block);
+        const blockResult = await writeManagedBlock(real, block);
         lines.push(`Managed block: ${blockResult.path} (${blockResult.action})`);
     }
     return lines.join('\n');

package/dist/transport/http-server.d.ts

@@ -1,4 +1,5 @@
 import type { McpServer } from '@modelcontextprotocol/server';
+import { type Household } from '../household.js';
 export interface HttpServeOptions {
     contextDir: string;
     host: string;
@@ -34,6 +35,12 @@ export interface HttpServeOptions {
     }) => {
         server: McpServer;
     };
+    /**
+     * Household mode: tokens resolve to roles from household.home/tokens.json
+     * (plus `token`, if set, as an owner token). Mutually exclusive with
+     * `tokens` and `createServer`; `contextDir` should be the default agent's.
+     */
+    household?: Household;
 }
 export interface HttpServeHandle {
     /** The actually-bound port (resolves a 0 request to the OS-assigned port). */