harborloop 0.3.0 → 0.4.1

package/dist/memories.js

@@ -1,74 +0,0 @@
-import { promises as fsp } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { writeFileAtomic } from './lock.js';
-import { slugify } from './slugify.js';
-export function encodeProjectPath(projectPath) {
-    return projectPath.replaceAll('/', '-');
-}
-async function ensureDir(path) {
-    await fsp.mkdir(path, { recursive: true, mode: 0o700 });
-    if (process.platform !== 'win32') {
-        try {
-            await fsp.chmod(path, 0o700);
-        }
-        catch {
-        }
-    }
-}
-function isTeamMemoryFile(name) {
-    return name.startsWith('team--') && name.endsWith('.md');
-}
-export async function syncMemoryFilesToHome(opts) {
-    if (opts.projectPath.length === 0) {
-        throw new Error('projectPath is required');
-    }
-    const home = opts.home ?? homedir();
-    const encoded = encodeProjectPath(opts.projectPath);
-    const memoryDir = join(home, '.claude', 'projects', encoded, 'memory');
-    await ensureDir(memoryDir);
-    const expected = new Set();
-    const results = [];
-    for (const mem of opts.memories) {
-        const slug = slugify(mem.name);
-        if (slug.length === 0) {
-            throw new Error(`Memory name '${mem.name}' produced an empty slug — provide a name with at least one alphanumeric character`);
-        }
-        const filename = `team--${slug}.md`;
-        expected.add(filename);
-        const target = join(memoryDir, filename);
-        const current = await fsp.readFile(target, 'utf8').catch(() => null);
-        if (current !== mem.content) {
-            await writeFileAtomic(target, mem.content);
-        }
-        results.push({ id: mem.id, file: filename, status: 'synced' });
-    }
-    const entries = await fsp.readdir(memoryDir).catch(() => []);
-    for (const name of entries) {
-        if (!isTeamMemoryFile(name))
-            continue;
-        if (expected.has(name))
-            continue;
-        await fsp.unlink(join(memoryDir, name)).catch(() => undefined);
-        results.push({ file: name, status: 'removed' });
-    }
-    return { dir: memoryDir, results };
-}
-export async function removeProjectMemoryFiles(opts) {
-    if (opts.projectPath.length === 0) {
-        throw new Error('projectPath is required');
-    }
-    const home = opts.home ?? homedir();
-    const memoryDir = join(home, '.claude', 'projects', encodeProjectPath(opts.projectPath), 'memory');
-    const entries = await fsp.readdir(memoryDir).catch(() => null);
-    if (entries === null)
-        return { dir: memoryDir, results: [], status: 'no_dir' };
-    const results = [];
-    for (const name of entries) {
-        if (!isTeamMemoryFile(name))
-            continue;
-        await fsp.unlink(join(memoryDir, name)).catch(() => undefined);
-        results.push({ file: name, status: 'removed' });
-    }
-    return { dir: memoryDir, results, status: 'cleaned' };
-}

package/dist/origin.d.ts

@@ -1,4 +0,0 @@
-export declare function normalizeOriginUrl(raw: string | null | undefined): string;
-export declare function gitOrigin(cwd: string): string | null;
-export declare function repoOrigin(cwd: string): string;
-export declare function gitRoot(cwd: string): string | null;

package/dist/origin.js

@@ -1,59 +0,0 @@
-import { execFileSync } from 'node:child_process';
-export function normalizeOriginUrl(raw) {
-    let url = (raw ?? '').trim();
-    if (url === '')
-        return '';
-    const scpMatch = url.match(/^[^@/]+@([^:/]+):(.+)$/);
-    if (scpMatch) {
-        url = `https://${scpMatch[1]}/${scpMatch[2]}`;
-    }
-    else if (/^ssh:\/\//i.test(url)) {
-        url = url.replace(/^ssh:\/\//i, 'https://');
-    }
-    else if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(url)) {
-        url = `https://${url}`;
-    }
-    url = url.replace(/\.git$/i, '');
-    try {
-        const parsed = new URL(url);
-        parsed.username = '';
-        parsed.password = '';
-        parsed.hostname = parsed.hostname.toLowerCase().replace(/^www\./, '');
-        parsed.pathname = parsed.pathname.toLowerCase();
-        return parsed.toString().replace(/\/$/, '');
-    }
-    catch {
-        return url.toLowerCase().replace(/\/+$/, '');
-    }
-}
-export function gitOrigin(cwd) {
-    try {
-        const out = execFileSync('git', ['-C', cwd, 'remote', 'get-url', 'origin'], {
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-            timeout: 2000,
-        });
-        const trimmed = out.trim();
-        return trimmed === '' ? null : trimmed;
-    }
-    catch {
-        return null;
-    }
-}
-export function repoOrigin(cwd) {
-    return normalizeOriginUrl(gitOrigin(cwd));
-}
-export function gitRoot(cwd) {
-    try {
-        const out = execFileSync('git', ['-C', cwd, 'rev-parse', '--show-toplevel'], {
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-            timeout: 2000,
-        });
-        const trimmed = out.trim();
-        return trimmed === '' ? null : trimmed;
-    }
-    catch {
-        return null;
-    }
-}

package/dist/paths.d.ts

@@ -1,12 +0,0 @@
-export declare function harborDir(): string;
-export declare function legacyDirs(): readonly string[];
-export declare function syncedOriginsFile(): string;
-export declare function authFile(): string;
-export declare function cliSessionsDir(): string;
-export declare function captureDir(): string;
-export declare function hooksBinDir(): string;
-export declare function locksDir(): string;
-export declare function recallOutcomesFile(): string;
-export declare function machineFile(): string;
-export declare function cliReleaseFile(): string;
-export declare function upgradeNoticeStampFile(): string;

package/dist/paths.js

@@ -1,45 +0,0 @@
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-function harborHomeOverride() {
-    const raw = (process.env['HARBOR_HOME'] ?? process.env['ALEF0_HOME'])?.trim();
-    return raw !== undefined && raw.length > 0 ? resolve(raw) : null;
-}
-export function harborDir() {
-    return harborHomeOverride() ?? join(homedir(), '.harbor');
-}
-export function legacyDirs() {
-    const override = process.env['HARBOR_LEGACY_HOME']?.trim();
-    if (override && override.length > 0)
-        return [override];
-    return [join(homedir(), '.alef0'), join(homedir(), '.milestone')];
-}
-export function syncedOriginsFile() {
-    return join(harborDir(), 'synced-origins.json');
-}
-export function authFile() {
-    return join(harborDir(), 'auth.json');
-}
-export function cliSessionsDir() {
-    return join(harborDir(), 'cli-sessions');
-}
-export function captureDir() {
-    return join(harborDir(), 'capture');
-}
-export function hooksBinDir() {
-    return join(harborDir(), 'bin');
-}
-export function locksDir() {
-    return join(harborDir(), 'locks');
-}
-export function recallOutcomesFile() {
-    return join(harborDir(), 'recall-outcomes.jsonl');
-}
-export function machineFile() {
-    return join(harborDir(), 'machine.json');
-}
-export function cliReleaseFile() {
-    return join(harborDir(), 'cli-release.json');
-}
-export function upgradeNoticeStampFile() {
-    return join(harborDir(), 'upgrade-notified-at');
-}

package/dist/providers/claude.d.ts

@@ -1,65 +0,0 @@
-export declare const MCP_KEY = "harbor";
-export declare const LEGACY_MCP_KEYS: readonly string[];
-export declare const HOOK_CONTEXT_BASENAME = "session-context.mjs";
-export declare const HOOK_REPORT_BASENAME = "session-report.mjs";
-export declare const HOOK_CAPTURE_BASENAME = "session-capture.mjs";
-export declare const HOOK_TOOLCONTEXT_BASENAME = "session-toolcontext.mjs";
-export declare const HOOK_COMPACT_BASENAME = "session-compact.mjs";
-export declare const MANAGED_HOOK_EVENTS: readonly ["UserPromptSubmit", "SessionEnd", "Stop", "PostToolUse", "PreToolUse", "SessionStart"];
-export interface ClaudePaths {
-    readonly claudeDir: string;
-    readonly settingsPath: string;
-    readonly mcpConfigPath: string;
-}
-export declare function resolveClaudePaths(home?: string): ClaudePaths;
-export interface McpServerEntry {
-    readonly type: 'http';
-    readonly url: string;
-    readonly headers: Readonly<Record<string, string>>;
-}
-export declare const ORIGIN_HEADER = "x-harbor-origin";
-export declare function buildMcpServerEntry(mcpUrl: string, token: string, originUrl?: string): McpServerEntry;
-export declare function hasOurMcpEntry(existing: string): boolean;
-export declare function mergeMcpServer(existing: string, mcpUrl: string, token: string): string;
-export declare function mergeProjectMcpServer(existing: string, opts: {
-    readonly repoPath: string;
-    readonly mcpUrl: string;
-    readonly token: string;
-    readonly originUrl: string;
-}): string;
-export declare function removeMcpServer(existing: string, label?: string): string;
-export declare function readInstalledToken(existing: string): string | null;
-export declare function readInstalledMcpUrl(existing: string): string | null;
-export declare function isOurHookCommand(command: unknown): boolean;
-export interface HookPaths {
-    readonly contextHookPath: string;
-    readonly reportHookPath: string;
-    readonly captureHookPath: string;
-    readonly toolContextHookPath: string;
-    readonly compactHookPath: string;
-}
-export declare function mergeHooks(existing: string, paths: HookPaths): string;
-export declare function removeHooks(existing: string): string;
-export interface InstalledHooks {
-    readonly installed: boolean;
-    readonly commands: readonly string[];
-    readonly events: readonly string[];
-}
-export declare function readInstalledHooks(existing: string): InstalledHooks;
-export declare function readClaudeSettings(home?: string): Promise<string>;
-export declare function readClaudeMcpConfig(home?: string): Promise<string>;
-export declare function installMcpServer(opts: {
-    readonly mcpUrl: string;
-    readonly token: string;
-    readonly home?: string;
-    readonly repoPath?: string;
-    readonly originUrl?: string;
-}): Promise<string>;
-export declare function installProjectOrigin(opts: {
-    readonly repoPath: string;
-    readonly originUrl: string;
-    readonly home?: string;
-}): Promise<string | null>;
-export declare function installHooks(paths: HookPaths, home?: string): Promise<string>;
-export declare function uninstallHooks(home?: string): Promise<string>;
-export declare function uninstallMcpServer(home?: string): Promise<string>;

package/dist/providers/claude.js

@@ -1,412 +0,0 @@
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { ensureConfigDir, readIfExists, updateFileLocked } from '../lock.js';
-import { isUnrunnableCommandEntry } from './hook-entry.js';
-export const MCP_KEY = 'harbor';
-export const LEGACY_MCP_KEYS = ['alef0', 'milestone'];
-function deleteAllOurKeys(servers) {
-    delete servers[MCP_KEY];
-    for (const legacy of LEGACY_MCP_KEYS)
-        delete servers[legacy];
-}
-export const HOOK_CONTEXT_BASENAME = 'session-context.mjs';
-export const HOOK_REPORT_BASENAME = 'session-report.mjs';
-export const HOOK_CAPTURE_BASENAME = 'session-capture.mjs';
-export const HOOK_TOOLCONTEXT_BASENAME = 'session-toolcontext.mjs';
-export const HOOK_COMPACT_BASENAME = 'session-compact.mjs';
-const HOOK_CONTEXT_TIMEOUT_S = 8;
-const HOOK_REPORT_TIMEOUT_S = 5;
-const HOOK_CAPTURE_TIMEOUT_S = 10;
-const HOOK_TOOLCONTEXT_TIMEOUT_S = 5;
-const HOOK_COMPACT_TIMEOUT_S = 2;
-export const MANAGED_HOOK_EVENTS = [
-    'UserPromptSubmit',
-    'SessionEnd',
-    'Stop',
-    'PostToolUse',
-    'PreToolUse',
-    'SessionStart',
-];
-const HOOK_EVENTS = MANAGED_HOOK_EVENTS;
-const TOOLCONTEXT_EDIT_MATCHER = 'Write|Edit';
-const TOOLCONTEXT_BASH_MATCHER = 'Bash';
-export function resolveClaudePaths(home = homedir()) {
-    const claudeDir = join(home, '.claude');
-    return {
-        claudeDir,
-        settingsPath: join(claudeDir, 'settings.json'),
-        mcpConfigPath: join(home, '.claude.json'),
-    };
-}
-function parseRoot(existing, allowEmpty, label = 'settings.json') {
-    if (existing.trim().length === 0) {
-        if (allowEmpty)
-            return {};
-        throw new Error('Config is empty');
-    }
-    let root;
-    try {
-        root = JSON.parse(existing);
-    }
-    catch (err) {
-        throw new Error(`Failed to parse ${label}: ${err.message}`);
-    }
-    if (root === null || typeof root !== 'object' || Array.isArray(root)) {
-        throw new Error(`${label} root is not an object`);
-    }
-    return root;
-}
-const serialise = (root) => `${JSON.stringify(root, null, 2)}\n`;
-export const ORIGIN_HEADER = 'x-harbor-origin';
-export function buildMcpServerEntry(mcpUrl, token, originUrl) {
-    const headers = { Authorization: `Bearer ${token}` };
-    if (originUrl !== undefined && originUrl !== '')
-        headers[ORIGIN_HEADER] = originUrl;
-    return { type: 'http', url: mcpUrl, headers };
-}
-function originOfEntry(entry) {
-    if (entry === null || typeof entry !== 'object')
-        return undefined;
-    const headers = entry.headers;
-    if (headers === null || typeof headers !== 'object')
-        return undefined;
-    const origin = headers[ORIGIN_HEADER];
-    return typeof origin === 'string' && origin !== '' ? origin : undefined;
-}
-function ourProjectEntries(root) {
-    const projects = root.projects;
-    if (projects === null || typeof projects !== 'object' || Array.isArray(projects)) {
-        return [];
-    }
-    const found = [];
-    for (const [path, project] of Object.entries(projects)) {
-        if (project === null || typeof project !== 'object' || Array.isArray(project))
-            continue;
-        const servers = project.mcpServers;
-        if (servers === null || typeof servers !== 'object' || Array.isArray(servers))
-            continue;
-        const bag = servers;
-        if (MCP_KEY in bag || LEGACY_MCP_KEYS.some((legacy) => legacy in bag)) {
-            found.push({ path, servers: bag });
-        }
-    }
-    return found;
-}
-export function hasOurMcpEntry(existing) {
-    if (existing.trim() === '')
-        return false;
-    let root;
-    try {
-        root = JSON.parse(existing);
-    }
-    catch {
-        return false;
-    }
-    const servers = root?.mcpServers;
-    if (servers === null || typeof servers !== 'object' || Array.isArray(servers))
-        return false;
-    const keys = servers;
-    return MCP_KEY in keys || LEGACY_MCP_KEYS.some((legacy) => legacy in keys);
-}
-export function mergeMcpServer(existing, mcpUrl, token) {
-    const root = parseRoot(existing, true, '.claude.json');
-    let servers = root.mcpServers;
-    if (servers === undefined) {
-        servers = {};
-        root.mcpServers = servers;
-    }
-    if (servers === null || typeof servers !== 'object' || Array.isArray(servers)) {
-        throw new Error('mcpServers is not an object');
-    }
-    deleteAllOurKeys(servers);
-    servers[MCP_KEY] = buildMcpServerEntry(mcpUrl, token);
-    for (const { servers: bag } of ourProjectEntries(root)) {
-        const origin = originOfEntry(bag[MCP_KEY]);
-        deleteAllOurKeys(bag);
-        bag[MCP_KEY] = buildMcpServerEntry(mcpUrl, token, origin);
-    }
-    return serialise(root);
-}
-export function mergeProjectMcpServer(existing, opts) {
-    const root = parseRoot(existing, true, '.claude.json');
-    let projects = root.projects;
-    if (projects === undefined) {
-        projects = {};
-        root.projects = projects;
-    }
-    if (projects === null || typeof projects !== 'object' || Array.isArray(projects)) {
-        throw new Error('projects is not an object');
-    }
-    const bag = projects;
-    let project = bag[opts.repoPath];
-    if (project === undefined || project === null || typeof project !== 'object' || Array.isArray(project)) {
-        project = {};
-        bag[opts.repoPath] = project;
-    }
-    const entry = project;
-    let servers = entry.mcpServers;
-    if (servers === undefined || servers === null || typeof servers !== 'object' || Array.isArray(servers)) {
-        servers = {};
-        entry.mcpServers = servers;
-    }
-    const bagServers = servers;
-    deleteAllOurKeys(bagServers);
-    bagServers[MCP_KEY] = buildMcpServerEntry(opts.mcpUrl, opts.token, opts.originUrl);
-    return serialise(root);
-}
-export function removeMcpServer(existing, label = '.claude.json') {
-    if (existing.trim() === '')
-        return existing;
-    const root = parseRoot(existing, false, label);
-    const servers = root.mcpServers;
-    if (servers !== null && typeof servers === 'object' && !Array.isArray(servers)) {
-        deleteAllOurKeys(servers);
-    }
-    for (const { servers: bag } of ourProjectEntries(root))
-        deleteAllOurKeys(bag);
-    return serialise(root);
-}
-export function readInstalledToken(existing) {
-    if (existing.trim() === '')
-        return null;
-    let root;
-    try {
-        root = JSON.parse(existing);
-    }
-    catch {
-        return null;
-    }
-    const servers = root?.mcpServers;
-    if (servers === null || typeof servers !== 'object')
-        return null;
-    const entry = servers[MCP_KEY];
-    if (entry === null || typeof entry !== 'object')
-        return null;
-    const headers = entry.headers;
-    if (headers === null || typeof headers !== 'object')
-        return null;
-    const auth = headers.Authorization;
-    if (typeof auth !== 'string' || auth.trim() === '')
-        return null;
-    return auth.startsWith('Bearer ') ? auth.slice('Bearer '.length) : auth;
-}
-export function readInstalledMcpUrl(existing) {
-    if (existing.trim() === '')
-        return null;
-    try {
-        const root = JSON.parse(existing);
-        const servers = root.mcpServers;
-        const entry = servers?.[MCP_KEY];
-        return typeof entry?.url === 'string' ? entry.url : null;
-    }
-    catch {
-        return null;
-    }
-}
-export function isOurHookCommand(command) {
-    if (typeof command !== 'string')
-        return false;
-    const base = command.trim().split(/[\\/]/).pop();
-    return (base === HOOK_CONTEXT_BASENAME ||
-        base === HOOK_REPORT_BASENAME ||
-        base === HOOK_CAPTURE_BASENAME ||
-        base === HOOK_COMPACT_BASENAME ||
-        base === HOOK_TOOLCONTEXT_BASENAME);
-}
-function stripOurHooks(event) {
-    if (!Array.isArray(event))
-        return [];
-    const out = [];
-    for (const group of event) {
-        if (group === null || typeof group !== 'object' || Array.isArray(group)) {
-            out.push(group);
-            continue;
-        }
-        const g = group;
-        if (!Array.isArray(g.hooks)) {
-            out.push(group);
-            continue;
-        }
-        const kept = g.hooks.filter((h) => {
-            if (h === null || typeof h !== 'object' || Array.isArray(h))
-                return true;
-            if (isUnrunnableCommandEntry(h))
-                return false;
-            return !isOurHookCommand(h.command);
-        });
-        if (kept.length === 0)
-            continue;
-        out.push({ ...g, hooks: kept });
-    }
-    return out;
-}
-const commandHookGroup = (command, timeout) => ({
-    hooks: [{ type: 'command', command, timeout }],
-});
-const matchedHookGroup = (matcher, command, timeout) => ({
-    matcher,
-    hooks: [{ type: 'command', command, timeout }],
-});
-export function mergeHooks(existing, paths) {
-    const root = parseRoot(existing, true);
-    let hooks = root.hooks;
-    if (hooks === undefined) {
-        hooks = {};
-        root.hooks = hooks;
-    }
-    if (hooks === null || typeof hooks !== 'object' || Array.isArray(hooks)) {
-        throw new Error('hooks is not an object');
-    }
-    const h = hooks;
-    h.UserPromptSubmit = [
-        ...stripOurHooks(h.UserPromptSubmit),
-        commandHookGroup(paths.contextHookPath, HOOK_CONTEXT_TIMEOUT_S),
-    ];
-    h.SessionEnd = [
-        ...stripOurHooks(h.SessionEnd),
-        commandHookGroup(paths.reportHookPath, HOOK_REPORT_TIMEOUT_S),
-    ];
-    h.Stop = [
-        ...stripOurHooks(h.Stop),
-        commandHookGroup(paths.captureHookPath, HOOK_CAPTURE_TIMEOUT_S),
-    ];
-    h.PostToolUse = [
-        ...stripOurHooks(h.PostToolUse),
-        matchedHookGroup(TOOLCONTEXT_EDIT_MATCHER, paths.toolContextHookPath, HOOK_TOOLCONTEXT_TIMEOUT_S),
-    ];
-    h.PreToolUse = [
-        ...stripOurHooks(h.PreToolUse),
-        matchedHookGroup(TOOLCONTEXT_BASH_MATCHER, paths.toolContextHookPath, HOOK_TOOLCONTEXT_TIMEOUT_S),
-    ];
-    h.SessionStart = [
-        ...stripOurHooks(h.SessionStart),
-        commandHookGroup(paths.compactHookPath, HOOK_COMPACT_TIMEOUT_S),
-    ];
-    return serialise(root);
-}
-export function removeHooks(existing) {
-    if (existing.trim() === '')
-        return existing;
-    const root = parseRoot(existing, false);
-    const hooks = root.hooks;
-    if (hooks !== null && typeof hooks === 'object' && !Array.isArray(hooks)) {
-        const h = hooks;
-        for (const event of HOOK_EVENTS) {
-            if (!(event in h))
-                continue;
-            const stripped = stripOurHooks(h[event]);
-            if (stripped.length === 0)
-                delete h[event];
-            else
-                h[event] = stripped;
-        }
-        if (Object.keys(h).length === 0)
-            delete root.hooks;
-    }
-    return serialise(root);
-}
-export function readInstalledHooks(existing) {
-    const commands = [];
-    const events = [];
-    const empty = { installed: false, commands, events };
-    if (existing.trim() === '')
-        return empty;
-    let root;
-    try {
-        root = JSON.parse(existing);
-    }
-    catch {
-        return empty;
-    }
-    const hooks = root?.hooks;
-    if (hooks === null || typeof hooks !== 'object' || Array.isArray(hooks)) {
-        return empty;
-    }
-    for (const event of HOOK_EVENTS) {
-        const groups = hooks[event];
-        if (!Array.isArray(groups))
-            continue;
-        const before = commands.length;
-        for (const group of groups) {
-            if (group === null || typeof group !== 'object')
-                continue;
-            const inner = group.hooks;
-            if (!Array.isArray(inner))
-                continue;
-            for (const h of inner) {
-                if (h === null || typeof h !== 'object')
-                    continue;
-                const command = h.command;
-                if (isOurHookCommand(command))
-                    commands.push(String(command));
-            }
-        }
-        if (commands.length > before)
-            events.push(event);
-    }
-    return { installed: commands.length > 0, commands, events };
-}
-const ensureClaudeDir = ensureConfigDir;
-export async function readClaudeSettings(home) {
-    return readIfExists(resolveClaudePaths(home).settingsPath);
-}
-export async function readClaudeMcpConfig(home) {
-    return readIfExists(resolveClaudePaths(home).mcpConfigPath);
-}
-export async function installMcpServer(opts) {
-    const paths = resolveClaudePaths(opts.home);
-    await ensureClaudeDir(paths.claudeDir);
-    await updateFileLocked(paths.mcpConfigPath, (existing) => mergeMcpServer(existing, opts.mcpUrl, opts.token));
-    if (opts.repoPath && opts.originUrl) {
-        await updateFileLocked(paths.mcpConfigPath, (existing) => mergeProjectMcpServer(existing, {
-            repoPath: opts.repoPath,
-            mcpUrl: opts.mcpUrl,
-            token: opts.token,
-            originUrl: opts.originUrl,
-        }));
-    }
-    await stripLegacyMcpEntry(paths.settingsPath);
-    return paths.mcpConfigPath;
-}
-export async function installProjectOrigin(opts) {
-    if (opts.originUrl === '')
-        return null;
-    const paths = resolveClaudePaths(opts.home);
-    const existing = await readIfExists(paths.mcpConfigPath);
-    const token = readInstalledToken(existing);
-    const mcpUrl = readInstalledMcpUrl(existing);
-    if (!token || !mcpUrl)
-        return null;
-    await updateFileLocked(paths.mcpConfigPath, (current) => mergeProjectMcpServer(current, {
-        repoPath: opts.repoPath,
-        mcpUrl,
-        token,
-        originUrl: opts.originUrl,
-    }));
-    return paths.mcpConfigPath;
-}
-async function stripLegacyMcpEntry(settingsPath) {
-    const existing = await readIfExists(settingsPath);
-    if (!hasOurMcpEntry(existing))
-        return;
-    await updateFileLocked(settingsPath, (current) => removeMcpServer(current, 'settings.json'));
-}
-export async function installHooks(paths, home) {
-    const claude = resolveClaudePaths(home);
-    await ensureClaudeDir(claude.claudeDir);
-    await updateFileLocked(claude.settingsPath, (existing) => mergeHooks(existing, paths));
-    return claude.settingsPath;
-}
-export async function uninstallHooks(home) {
-    const claude = resolveClaudePaths(home);
-    await updateFileLocked(claude.settingsPath, (existing) => removeHooks(existing));
-    return claude.settingsPath;
-}
-export async function uninstallMcpServer(home) {
-    const claude = resolveClaudePaths(home);
-    if (hasOurMcpEntry(await readIfExists(claude.mcpConfigPath))) {
-        await updateFileLocked(claude.mcpConfigPath, (existing) => removeMcpServer(existing));
-    }
-    await stripLegacyMcpEntry(claude.settingsPath);
-    return claude.mcpConfigPath;
-}