@genspark/opencode-conversation-archiver 0.1.0

package/dist/core.js

@@ -0,0 +1,833 @@
+import { appendFile, chmod, mkdir, readFile, readdir, rename, rm, stat, writeFile, } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { homedir, hostname } from 'node:os';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { execFile, spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+const MAX_SLUG = 60;
+const ARCHIVE_LOCK_WAIT_MS = 15 * 60_000;
+const ARCHIVE_LOCK_STALE_MS = 20 * 60_000;
+const PUSH_LOCK_WAIT_MS = 15 * 60_000;
+const PUSH_LOCK_STALE_MS = 20 * 60_000;
+const URL_CREDENTIAL = /(https?:\/\/)[^/@\s]+(?::[^@\s]*)?@/g;
+const execFileAsync = promisify(execFile);
+export function defaultPaths(home = homedir()) {
+    const app = join(home, '.config', 'opencode', 'conversation-archiver');
+    return {
+        app,
+        config: join(app, 'config.json'),
+        state: join(app, 'state'),
+        index: join(app, 'state', '_index.json'),
+        log: join(app, 'archive.log'),
+        pushLog: join(app, 'push.log'),
+        credentials: join(app, 'git-credentials'),
+    };
+}
+export function expandHome(path, home = homedir()) {
+    return path === '~'
+        ? home
+        : path.startsWith('~/')
+            ? join(home, path.slice(2))
+            : path;
+}
+export function maskUrl(text) {
+    return text.replace(URL_CREDENTIAL, '$1***@');
+}
+export function slugify(value) {
+    const slug = value
+        .trim()
+        .replace(/\s+/gu, '-')
+        .replace(/[^\p{L}\p{N}_-]/gu, '')
+        .replace(/-{2,}/gu, '-')
+        .replace(/^[-_]+|[-_]+$/gu, '')
+        .slice(0, MAX_SLUG)
+        .replace(/[-_]+$/gu, '');
+    return slug || 'untitled';
+}
+function visibleText(parts) {
+    const text = parts
+        .filter((part) => part.type === 'text' && !part.synthetic && !part.ignored)
+        .map(part => part.text.trim())
+        .filter(Boolean)
+        .join('\n\n');
+    return text || undefined;
+}
+export function extractBlocks(messages) {
+    const blocks = [];
+    for (const message of messages) {
+        const text = visibleText(message.parts);
+        if (text)
+            blocks.push({ key: message.info.id, role: message.info.role, text });
+        for (const part of message.parts) {
+            if (part.type === 'compaction') {
+                blocks.push({
+                    key: part.id,
+                    role: 'compact',
+                    text: '> Context compacted. Earlier turns above are preserved in this archive.',
+                });
+            }
+        }
+    }
+    return blocks;
+}
+function shortID(id) {
+    return id.replace(/^ses_/, '').split('-')[0]?.slice(0, 8) || 'session';
+}
+function formatDate(timestamp) {
+    const date = new Date(timestamp);
+    const parts = new Intl.DateTimeFormat('en-CA', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false,
+    }).formatToParts(date);
+    const get = (type) => parts.find(part => part.type === type)?.value || '00';
+    const day = `${get('year')}-${get('month')}-${get('day')}`;
+    return {
+        month: `${get('year')}-${get('month')}`,
+        file: `${day}-${get('hour')}${get('minute')}`,
+        header: date.toLocaleString(undefined, {
+            dateStyle: 'medium',
+            timeStyle: 'short',
+        }),
+        day,
+    };
+}
+export function renderMarkdown(state, sessionID) {
+    const users = state.blocks.filter(block => block.role === 'user').length;
+    const assistants = state.blocks.filter(block => block.role === 'assistant').length;
+    const lines = [
+        `# ${state.title || `Session ${shortID(sessionID)}`}`,
+        '',
+        `- **Session**: \`${sessionID}\``,
+        `- **Started**: ${formatDate(state.start).header}`,
+    ];
+    if (state.machine.hostname)
+        lines.push(`- **Machine**: ${state.machine.hostname}`);
+    if (state.machine.tmux)
+        lines.push(`- **tmux session**: \`${state.machine.tmux}\``);
+    lines.push(`- **Turns archived**: ${users} user / ${assistants} assistant`, '', '---', '');
+    for (const block of state.blocks) {
+        if (block.role === 'compact')
+            lines.push(block.text, '');
+        else
+            lines.push(block.role === 'user' ? '## User' : '## Assistant', '', block.text.trimEnd(), '');
+    }
+    return `${lines.join('\n').trimEnd()}\n`;
+}
+function body(markdown) {
+    return (markdown.split('\n---\n', 2)[1] || markdown).trim();
+}
+export function bodyCovers(oldBody, newBody) {
+    if (!oldBody || oldBody === newBody)
+        return true;
+    return (newBody.startsWith(oldBody) &&
+        newBody.slice(oldBody.length).startsWith('\n\n'));
+}
+async function readJSON(path, fallback) {
+    try {
+        const value = JSON.parse(await readFile(path, 'utf8'));
+        return value && typeof value === 'object' ? value : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+async function atomicJSON(path, value, mode) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${process.pid}.tmp`;
+    await writeFile(temporary, JSON.stringify(value), { mode: mode ?? 0o600 });
+    await chmod(temporary, mode ?? 0o600);
+    await rename(temporary, path);
+}
+export async function loadConfig(paths = defaultPaths()) {
+    return readJSON(paths.config, {});
+}
+export async function saveConfig(config, paths = defaultPaths()) {
+    await atomicJSON(paths.config, config);
+}
+export function effectiveRepo(config, home = homedir()) {
+    return resolve(expandHome(process.env.OPENCODE_ARCHIVE_REPO ||
+        config.repo ||
+        '~/opencode-conversations', home));
+}
+export function effectiveMode(config) {
+    const mode = process.env.OPENCODE_ARCHIVE_MODE || config.mode || 'auto';
+    return mode === 'manual' ? 'manual' : 'auto';
+}
+async function log(paths, message) {
+    try {
+        await mkdir(paths.app, { recursive: true, mode: 0o700 });
+        await appendFile(paths.log, `[${new Date().toISOString()}] ${maskUrl(message)}\n`);
+    }
+    catch {
+        // Archiving must never disrupt OpenCode.
+    }
+}
+export async function run(repo, command, args, timeout = 30_000) {
+    try {
+        const result = await execFileAsync(command, args, {
+            cwd: repo,
+            encoding: 'utf8',
+            timeout,
+        });
+        return { status: 0, stdout: result.stdout, stderr: result.stderr };
+    }
+    catch (error) {
+        const failure = error;
+        return {
+            status: failure.killed
+                ? 124
+                : typeof failure.code === 'number'
+                    ? failure.code
+                    : 127,
+            stdout: failure.stdout || '',
+            stderr: failure.stderr || failure.message,
+        };
+    }
+}
+export function git(repo, args, timeout = 30_000) {
+    return run(repo, 'git', ['-C', repo, ...args], timeout);
+}
+async function ensureRepo(repo) {
+    await mkdir(repo, { recursive: true });
+    if (!existsSync(join(repo, '.git')))
+        await git(repo, ['init']);
+    if (!(await git(repo, ['config', 'user.email'])).stdout.trim()) {
+        await git(repo, ['config', 'user.email', 'opencode-archiver@localhost']);
+        await git(repo, ['config', 'user.name', 'opencode-conversation-archiver']);
+    }
+    if (!existsSync(join(repo, '.gitignore')))
+        await writeFile(join(repo, '.gitignore'), '.DS_Store\n');
+}
+async function stageArchives(repo, config) {
+    const pathspec = config.subdir || ':(glob)**/*.md';
+    await git(repo, ['add', '-A', '--', pathspec, '.gitignore']);
+}
+async function stageMigrationSources(repo, archivePaths) {
+    if (archivePaths.length)
+        await git(repo, ['add', '-A', '--', ...archivePaths]);
+}
+async function tmuxSession() {
+    if (!process.env.TMUX)
+        return undefined;
+    const result = await run(process.cwd(), 'tmux', ['display-message', '-p', '#S'], 5_000);
+    return result.status === 0 ? result.stdout.trim() || undefined : undefined;
+}
+async function withLock(path, callback, waitMs = 30_000, staleMs = 5 * 60_000) {
+    await mkdir(dirname(path), { recursive: true });
+    const deadline = Date.now() + waitMs;
+    while (true) {
+        try {
+            await mkdir(path);
+            break;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST' ||
+                Date.now() >= deadline)
+                throw error;
+            if (Date.now() - (await stat(path)).mtimeMs > staleMs) {
+                await rm(path, { recursive: true, force: true });
+                continue;
+            }
+            await new Promise(resolvePromise => setTimeout(resolvePromise, 50));
+        }
+    }
+    try {
+        return await callback();
+    }
+    finally {
+        await rm(path, { recursive: true, force: true });
+    }
+}
+async function resolvePath(repo, state, sessionID, config, paths, excluded) {
+    const index = await readJSON(paths.index, {});
+    const date = formatDate(state.start);
+    const prefix = config.subdir
+        ? `${config.subdir.replace(/^\/+|\/+$/g, '')}/`
+        : '';
+    const base = `${prefix}${date.month}/${date.file}-${slugify(state.title || shortID(sessionID))}`;
+    const choices = [
+        `${base}.md`,
+        `${base}-${shortID(sessionID)}.md`,
+        `${base}-${sessionID}.md`,
+    ];
+    if (state.file &&
+        state.diverted &&
+        state.file !== excluded &&
+        index[state.file] === sessionID &&
+        existsSync(join(repo, state.file)))
+        return state.file;
+    for (const choice of choices) {
+        if (choice === excluded)
+            continue;
+        const owner = index[choice];
+        if (owner && owner !== sessionID)
+            continue;
+        if (choice === state.file ||
+            owner === sessionID ||
+            (!owner && !existsSync(join(repo, choice))))
+            return choice;
+    }
+    // All deterministic names may already protect richer files; find an unused
+    // suffix because preservation takes priority over a stable filename.
+    for (let suffix = 1;; suffix += 1) {
+        const fallback = `${base}-${sessionID}-preserved-${suffix}.md`;
+        if (fallback !== excluded &&
+            !index[fallback] &&
+            !existsSync(join(repo, fallback)))
+            return fallback;
+    }
+}
+async function writeArchive(conversation, config, paths) {
+    const sessionID = conversation.session.id;
+    const statePath = join(paths.state, `${sessionID}.json`);
+    const extracted = extractBlocks(conversation.messages);
+    const fallback = {
+        title: conversation.session.title || '',
+        file: null,
+        start: conversation.session.time.created,
+        blocks: [],
+        machine: {},
+        diverted: false,
+    };
+    const loaded = await readJSON(statePath, fallback);
+    let state = {
+        title: typeof loaded.title === 'string' ? loaded.title : fallback.title,
+        file: typeof loaded.file === 'string' ? loaded.file : null,
+        start: typeof loaded.start === 'number' ? loaded.start : fallback.start,
+        blocks: Array.isArray(loaded.blocks) ? loaded.blocks : [],
+        machine: loaded.machine && typeof loaded.machine === 'object'
+            ? loaded.machine
+            : {},
+        diverted: loaded.diverted === true,
+    };
+    const previousRenderedBody = state.blocks.length
+        ? body(renderMarkdown(state, sessionID))
+        : '';
+    const positions = new Map(state.blocks.map((block, index) => [block.key, index]));
+    for (const block of extracted) {
+        const position = positions.get(block.key);
+        if (position === undefined) {
+            positions.set(block.key, state.blocks.length);
+            state.blocks.push(block);
+            continue;
+        }
+        state.blocks[position] = block;
+    }
+    if (!state.blocks.length)
+        return { repo: effectiveRepo(config), file: '', turns: 0, changed: false };
+    const incomingTitle = conversation.session.title;
+    const isPlaceholder = (title) => /^New session(?:\s*-|$)/i.test(title);
+    if (incomingTitle &&
+        (!state.title ||
+            (isPlaceholder(state.title) && !isPlaceholder(incomingTitle))))
+        state.title = incomingTitle;
+    state.machine.hostname ||= hostname();
+    const tmux = await tmuxSession();
+    if (tmux)
+        state.machine.tmux = tmux;
+    else if (!process.env.TMUX)
+        delete state.machine.tmux;
+    const repo = effectiveRepo(config);
+    await ensureRepo(repo);
+    let next = await resolvePath(repo, state, sessionID, config, paths);
+    const previous = state.file;
+    const indexBeforeRename = await readJSON(paths.index, {});
+    if (previous &&
+        previous !== next &&
+        indexBeforeRename[previous] === sessionID &&
+        existsSync(join(repo, previous))) {
+        await mkdir(dirname(join(repo, next)), { recursive: true });
+        const moved = await git(repo, ['mv', '--', previous, next]);
+        if (moved.status !== 0)
+            await rename(join(repo, previous), join(repo, next)).catch(() => {
+                next = previous;
+            });
+    }
+    const markdown = renderMarkdown(state, sessionID);
+    const target = join(repo, next);
+    if (existsSync(target)) {
+        const old = await readFile(target, 'utf8').catch(() => '__unreadable__');
+        const oldBody = body(old);
+        const isExpectedPriorRender = oldBody === previousRenderedBody;
+        if (!isExpectedPriorRender && !bodyCovers(oldBody, body(markdown))) {
+            state.file = null;
+            next = await resolvePath(repo, state, sessionID, config, paths, next);
+            state.diverted = true;
+        }
+    }
+    const destination = join(repo, next);
+    await mkdir(dirname(destination), { recursive: true });
+    const before = await readFile(destination, 'utf8').catch(() => '');
+    await writeFile(destination, markdown);
+    state.file = next;
+    await atomicJSON(statePath, state);
+    const index = await readJSON(paths.index, {});
+    if (previous && previous !== next && index[previous] === sessionID)
+        delete index[previous];
+    index[next] = sessionID;
+    await atomicJSON(paths.index, index);
+    return {
+        repo,
+        file: next,
+        turns: state.blocks.filter(block => block.role === 'user').length,
+        changed: before !== markdown,
+    };
+}
+export async function push(repo, paths = defaultPaths()) {
+    return withLock(join(paths.app, 'archive.lock'), () => withLock(join(paths.app, 'push.lock'), async () => {
+        if ((await git(repo, ['remote'])).stdout.trim()) {
+            const remoteHeads = await git(repo, [
+                'ls-remote',
+                '--heads',
+                'origin',
+            ]);
+            if (remoteHeads.status !== 0)
+                return remoteHeads;
+            if (!remoteHeads.stdout.trim()) {
+                const firstPush = await git(repo, ['push', '-u', 'origin', 'HEAD'], 120_000);
+                return firstPush;
+            }
+            const upstream = await git(repo, [
+                'rev-parse',
+                '--abbrev-ref',
+                '--symbolic-full-name',
+                '@{u}',
+            ]);
+            if (upstream.status !== 0) {
+                const remoteHead = await git(repo, [
+                    'ls-remote',
+                    '--symref',
+                    'origin',
+                    'HEAD',
+                ]);
+                if (remoteHead.status !== 0)
+                    return remoteHead;
+                const branch = remoteHead.stdout.match(/ref: refs\/heads\/([^\s]+)\s+HEAD/)?.[1];
+                if (!branch)
+                    return {
+                        status: 1,
+                        stdout: '',
+                        stderr: 'remote has branches but no default branch was found',
+                    };
+                const tracking = await git(repo, [
+                    'branch',
+                    '--set-upstream-to',
+                    `origin/${branch}`,
+                ]);
+                if (tracking.status !== 0)
+                    return tracking;
+            }
+            const pull = await git(repo, [
+                '-c',
+                'rebase.autoStash=true',
+                'pull',
+                '--rebase',
+                '-X',
+                'theirs',
+            ], 120_000);
+            if (pull.status !== 0) {
+                if (existsSync(join(repo, '.git', 'rebase-merge')) ||
+                    existsSync(join(repo, '.git', 'rebase-apply')))
+                    await git(repo, ['rebase', '--abort']);
+                await log(paths, `pull --rebase failed: ${pull.stderr || pull.stdout}`);
+                return pull;
+            }
+        }
+        const result = await git(repo, ['push'], 120_000);
+        await appendFile(paths.pushLog, maskUrl(`${result.stdout}${result.stderr}`)).catch(() => undefined);
+        return result;
+    }, PUSH_LOCK_WAIT_MS, PUSH_LOCK_STALE_MS), ARCHIVE_LOCK_WAIT_MS, ARCHIVE_LOCK_STALE_MS);
+}
+function pushDetached(repo, paths) {
+    const child = spawn(process.execPath, [
+        fileURLToPath(new URL('./push-worker.js', import.meta.url)),
+        repo,
+        paths.app,
+    ], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+}
+export async function archiveConversation(conversation, paths = defaultPaths(), commit = true) {
+    return withLock(join(paths.app, 'archive.lock'), async () => {
+        const config = await loadConfig(paths);
+        const result = await writeArchive(conversation, config, paths);
+        if (!result.file || !commit || effectiveMode(config) === 'manual')
+            return { file: result.file, turns: result.turns };
+        await stageArchives(result.repo, config);
+        if (!(await git(result.repo, ['status', '--porcelain'])).stdout.trim())
+            return { file: result.file, turns: result.turns };
+        const title = conversation.session.title || shortID(conversation.session.id);
+        const committed = await git(result.repo, [
+            'commit',
+            '-m',
+            `archive: ${formatDate(conversation.session.time.created).day} ${title}`,
+        ]);
+        if (committed.status === 0)
+            pushDetached(result.repo, paths);
+        else
+            await log(paths, `commit failed: ${committed.stderr}`);
+        return { file: result.file, turns: result.turns };
+    }, ARCHIVE_LOCK_WAIT_MS, ARCHIVE_LOCK_STALE_MS);
+}
+export async function commitPending(paths = defaultPaths(), message = `manual upload: ${new Date().toLocaleString()}`) {
+    return withLock(join(paths.app, 'archive.lock'), () => commitPendingLocked(paths, message), ARCHIVE_LOCK_WAIT_MS, ARCHIVE_LOCK_STALE_MS);
+}
+async function commitPendingLocked(paths, message) {
+    const repo = effectiveRepo(await loadConfig(paths));
+    if (!existsSync(join(repo, '.git')))
+        return { repo, committed: false };
+    await stageArchives(repo, await loadConfig(paths));
+    if (!(await git(repo, ['status', '--porcelain'])).stdout.trim())
+        return { repo, committed: false };
+    const result = await git(repo, ['commit', '-m', message]);
+    return result.status === 0
+        ? { repo, committed: true }
+        : {
+            repo,
+            committed: false,
+            error: maskUrl(result.stderr || result.stdout),
+        };
+}
+export async function upload(paths = defaultPaths()) {
+    const repo = effectiveRepo(await loadConfig(paths));
+    if (!existsSync(join(repo, '.git')))
+        return `archive repo not initialized yet (${repo})`;
+    const commit = await commitPending(paths);
+    if (commit.error)
+        return `commit failed: ${commit.error}`;
+    const result = await push(repo, paths);
+    return result.status === 0
+        ? `pushed (${repo})`
+        : `push skipped/failed: ${maskUrl(result.stderr || result.stdout)}`;
+}
+export async function setMode(mode, paths = defaultPaths()) {
+    return withLock(join(paths.app, 'archive.lock'), async () => {
+        const config = await loadConfig(paths);
+        config.mode = mode;
+        await saveConfig(config, paths);
+        return `conversation archiver mode: ${mode}`;
+    }, ARCHIVE_LOCK_WAIT_MS, ARCHIVE_LOCK_STALE_MS);
+}
+export async function setRepo(path, paths = defaultPaths()) {
+    return withLock(join(paths.app, 'archive.lock'), async () => {
+        const expanded = resolve(expandHome(path));
+        if (!isAbsolute(expandHome(path)))
+            throw new Error('repo path must be absolute or start with ~/');
+        if (existsSync(expanded) && !(await stat(expanded)).isDirectory())
+            throw new Error(`not a directory: ${expanded}`);
+        const config = await loadConfig(paths);
+        const old = effectiveRepo(config);
+        config.repo = expanded;
+        await saveConfig(config, paths);
+        const warning = process.env.OPENCODE_ARCHIVE_REPO
+            ? ' OPENCODE_ARCHIVE_REPO currently overrides this setting.'
+            : '';
+        return old === expanded
+            ? `archive repo already set to ${expanded}.${warning}`
+            : `archive repo repointed to ${expanded}; previous archive left untouched at ${old}.${warning}`;
+    }, ARCHIVE_LOCK_WAIT_MS, ARCHIVE_LOCK_STALE_MS);
+}
+export async function status(paths = defaultPaths()) {
+    const config = await loadConfig(paths);
+    const repo = effectiveRepo(config);
+    const lines = [`mode: ${effectiveMode(config)}`, `repo: ${repo}`];
+    if (!existsSync(join(repo, '.git')))
+        return [
+            ...lines,
+            'remote: none',
+            '--- recent commits ---',
+            '(no commits yet)',
+            '--- pending changes ---',
+        ].join('\n');
+    const remotes = (await git(repo, ['remote', '-v'])).stdout
+        .trim()
+        .split('\n')
+        .filter(Boolean);
+    lines.push(`remote: ${maskUrl(remotes[0] || 'none')}`, '--- recent commits ---');
+    lines.push((await git(repo, ['log', '--oneline', '-5'])).stdout.trim() ||
+        '(no commits yet)', '--- pending changes ---');
+    lines.push(...(await git(repo, ['status', '--short'])).stdout
+        .trim()
+        .split('\n')
+        .slice(0, 10)
+        .filter(Boolean));
+    return lines.join('\n');
+}
+export async function doctor(paths = defaultPaths()) {
+    const config = await loadConfig(paths);
+    const repo = effectiveRepo(config);
+    const gitVersion = await run(process.cwd(), 'git', ['--version']);
+    const problems = [];
+    const lines = [
+        '# OpenCode conversation-archiver doctor',
+        '',
+        '## Dependencies',
+    ];
+    if (gitVersion.status === 0)
+        lines.push(`- git: OK (${gitVersion.stdout.trim()})`);
+    else {
+        lines.push('- git: MISSING');
+        problems.push('Install git and ensure it is on PATH.');
+    }
+    lines.push('', '## Config', `- mode: ${effectiveMode(config)}`, `- repo: ${repo}`);
+    if (process.env.OPENCODE_ARCHIVE_MODE || process.env.OPENCODE_ARCHIVE_REPO)
+        lines.push('- OPENCODE_ARCHIVE_* environment override(s) active');
+    lines.push('', '## Archive repo');
+    if (!existsSync(join(repo, '.git')))
+        lines.push('- not initialized yet; created after the first visible turn');
+    else {
+        lines.push('- git repo: OK', `- last commit: ${(await git(repo, ['log', '-1', '--oneline'])).stdout.trim() || '(none)'}`);
+        const names = (await git(repo, ['remote'])).stdout
+            .trim()
+            .split('\n')
+            .filter(Boolean);
+        if (!names.length)
+            lines.push('- remote: NONE; archive is local-only');
+        else {
+            const remote = names.includes('origin') ? 'origin' : names[0];
+            const probe = await git(repo, ['ls-remote', '--heads', remote], 20_000);
+            lines.push(`- remote: ${remote}`, `- connection test: ${probe.status === 0 ? 'OK' : 'FAILED'}`);
+            if (probe.status !== 0)
+                problems.push(`Remote probe failed: ${maskUrl(probe.stderr || probe.stdout)}`);
+        }
+    }
+    const files = existsSync(paths.state) ? await readdir(paths.state) : [];
+    lines.push('', '## Archive activity', `- sessions tracked: ${files.filter(file => file.endsWith('.json') && file !== '_index.json').length}`);
+    lines.push('', '## Verdict', problems.length
+        ? `Found ${problems.length} problem(s):\n${problems.map((item, index) => `  ${index + 1}. ${item}`).join('\n')}`
+        : 'All checks passed.');
+    return lines.join('\n');
+}
+export async function connect(remoteUrl, token, subdir = 'opencode', paths = defaultPaths()) {
+    // Connect is intentionally one archive transaction: its HTTP calls are capped
+    // at 30s and git phases at 120s, while archive wait/stale limits are 15m/20m.
+    // Keeping the lock prevents a turn from committing during migration/rebase.
+    return withLock(join(paths.app, 'archive.lock'), () => connectLocked(remoteUrl, token, subdir, paths), ARCHIVE_LOCK_WAIT_MS, ARCHIVE_LOCK_STALE_MS);
+}
+async function connectLocked(remoteUrl, token, subdir, paths) {
+    const config = await loadConfig(paths);
+    const repo = effectiveRepo(config);
+    await ensureRepo(repo);
+    let url = remoteUrl.trim();
+    let credential = token.trim();
+    if (url.includes('/sb-connect/')) {
+        const parsed = new URL(url);
+        const code = parsed.pathname.split('/').filter(Boolean).at(-1);
+        const response = await fetch(`${parsed.origin}/api/memo_v2/sources/claude-code/activate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ code }),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!response.ok)
+            throw new Error(response.status === 404
+                ? 'connect link expired or already used'
+                : `connect failed: HTTP ${response.status}`);
+        const data = (await response.json());
+        url = data.remote_url || '';
+        credential = data.token || '';
+    }
+    if (!credential) {
+        credential = process.env.GSK_API_KEY || '';
+        if (!credential) {
+            const gsk = await readJSON(join(homedir(), '.genspark-tool-cli', 'config.json'), {});
+            credential = gsk.api_key || '';
+        }
+    }
+    if (!url && credential) {
+        const base = (process.env.GSK_BASE_URL || 'https://www.genspark.ai').replace(/\/$/, '');
+        const response = await fetch(`${base}/api/memo_v2/sources/claude-code/resolve`, {
+            headers: { Authorization: `Bearer ${credential}` },
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!response.ok)
+            throw new Error(`could not resolve Second Brain remote: HTTP ${response.status}`);
+        url = (await response.json()).remote_url || '';
+    }
+    if (!url || !credential)
+        throw new Error('connect requires an sb-connect link, a signed-in gsk CLI, or remote URL plus token');
+    const parsed = new URL(url);
+    if (!['http:', 'https:'].includes(parsed.protocol))
+        throw new Error('remote URL must use HTTP(S)');
+    const normalizedSubdir = subdir.replace(/^\/+|\/+$/g, '') || 'opencode';
+    if (normalizedSubdir.includes('\\') ||
+        normalizedSubdir
+            .split('/')
+            .some(part => !part || part === '.' || part === '..'))
+        throw new Error('subdir must be a relative path without empty, . or .. components');
+    const migratedSources = await migrateArchiveSubdir(repo, normalizedSubdir, paths);
+    await mkdir(paths.app, { recursive: true, mode: 0o700 });
+    await rm(paths.credentials, { force: true });
+    await writeFile(paths.credentials, `${parsed.protocol}//x-access-token:${credential}@${parsed.host}\n`, { mode: 0o600 });
+    await git(repo, [
+        'config',
+        'credential.helper',
+        `store --file=${JSON.stringify(paths.credentials)}`,
+    ]);
+    await git(repo, ['config', 'push.default', 'upstream']);
+    const remotes = (await git(repo, ['remote'])).stdout.split('\n');
+    await git(repo, remotes.includes('origin')
+        ? ['remote', 'set-url', 'origin', url]
+        : ['remote', 'add', 'origin', url]);
+    config.mode = 'auto';
+    config.subdir = normalizedSubdir;
+    await saveConfig(config, paths);
+    await stageMigrationSources(repo, migratedSources);
+    const migrationCommit = await commitPendingLocked(paths, `connect: move archive under ${normalizedSubdir}/`);
+    if (migrationCommit.error)
+        return `remote and credential saved, but archive commit failed: ${migrationCommit.error}`;
+    const sparse = await git(repo, ['sparse-checkout', 'set', config.subdir]);
+    if (sparse.status !== 0)
+        return `remote and credential saved, archive migration committed, but sparse checkout failed: ${maskUrl(sparse.stderr || sparse.stdout)}`;
+    return withLock(join(paths.app, 'push.lock'), async () => {
+        const remoteHead = await git(repo, [
+            'ls-remote',
+            '--symref',
+            'origin',
+            'HEAD',
+        ]);
+        if (remoteHead.status !== 0)
+            return `remote and credential saved, but remote probe failed: ${maskUrl(remoteHead.stderr || remoteHead.stdout)}`;
+        const remoteHeads = await git(repo, ['ls-remote', '--heads', 'origin']);
+        if (remoteHeads.status !== 0)
+            return `remote and credential saved, but remote probe failed: ${maskUrl(remoteHeads.stderr || remoteHeads.stdout)}`;
+        const branch = remoteHead.stdout.match(/ref: refs\/heads\/([^\s]+)\s+HEAD/)?.[1] ||
+            'main';
+        const fetched = await git(repo, ['fetch', 'origin', branch], 120_000);
+        if (fetched.status !== 0 && remoteHeads.stdout.trim())
+            return `remote and credential saved, but fetch failed: ${maskUrl(fetched.stderr)}`;
+        if (!remoteHeads.stdout.trim()) {
+            const firstPush = await git(repo, ['push', '-u', 'origin', `HEAD:${branch}`], 120_000);
+            return firstPush.status === 0
+                ? `connected; archive syncs under ${config.subdir}/`
+                : `remote and credential saved; first push failed and will retry: ${maskUrl(firstPush.stderr)}`;
+        }
+        const head = await git(repo, ['rev-parse', '--verify', 'HEAD']);
+        if (head.status === 0) {
+            const pull = await git(repo, ['pull', '--rebase', '-X', 'theirs', 'origin', branch], 120_000);
+            if (pull.status !== 0) {
+                if (existsSync(join(repo, '.git', 'rebase-merge')) ||
+                    existsSync(join(repo, '.git', 'rebase-apply')))
+                    await git(repo, ['rebase', '--abort']);
+                return `remote and credential saved, but pull failed: ${maskUrl(pull.stderr || pull.stdout)}`;
+            }
+        }
+        else {
+            const reset = await git(repo, ['reset', '--hard', 'FETCH_HEAD']);
+            if (reset.status !== 0)
+                return `remote and credential saved, but checkout failed: ${maskUrl(reset.stderr || reset.stdout)}`;
+        }
+        const pushed = await git(repo, ['push', '-u', 'origin', `HEAD:${branch}`], 120_000);
+        return pushed.status === 0
+            ? `connected; archive syncs under ${config.subdir}/`
+            : `remote and credential saved; first push failed and will retry: ${maskUrl(pushed.stderr)}`;
+    }, PUSH_LOCK_WAIT_MS, PUSH_LOCK_STALE_MS);
+}
+async function migrateArchiveSubdir(repo, subdir, paths) {
+    const index = await readJSON(paths.index, {});
+    const removedSources = [];
+    for (const [archivePath, sessionID] of Object.entries(index)) {
+        if (archivePath.startsWith(`${subdir}/`))
+            continue;
+        const destination = `${subdir}/${archivePath}`;
+        if (!existsSync(join(repo, archivePath)))
+            continue;
+        const destinationOwner = index[destination];
+        if (destinationOwner && destinationOwner !== sessionID) {
+            await rm(join(repo, archivePath), { force: true });
+            removedSources.push(archivePath);
+            delete index[archivePath];
+            const statePath = join(paths.state, `${sessionID}.json`);
+            const state = await readJSON(statePath, {});
+            if (state.file === archivePath) {
+                state.file = null;
+                await atomicJSON(statePath, state);
+            }
+            await atomicJSON(paths.index, index);
+            continue;
+        }
+        if (existsSync(join(repo, destination))) {
+            const destinationText = await readFile(join(repo, destination), 'utf8').catch(() => '');
+            const sourceText = await readFile(join(repo, archivePath), 'utf8').catch(() => '');
+            if (!destinationText || destinationText !== sourceText) {
+                await rm(join(repo, archivePath), { force: true });
+                removedSources.push(archivePath);
+                delete index[archivePath];
+                const statePath = join(paths.state, `${sessionID}.json`);
+                const state = await readJSON(statePath, {});
+                if (state.file === archivePath) {
+                    state.file = null;
+                    await atomicJSON(statePath, state);
+                }
+                await atomicJSON(paths.index, index);
+                continue;
+            }
+            await rm(join(repo, archivePath), { force: true });
+            removedSources.push(archivePath);
+        }
+        else {
+            await mkdir(dirname(join(repo, destination)), { recursive: true });
+            const moved = await git(repo, ['mv', '--', archivePath, destination]);
+            if (moved.status !== 0) {
+                try {
+                    await rename(join(repo, archivePath), join(repo, destination));
+                }
+                catch {
+                    await rm(join(repo, archivePath), { force: true });
+                    removedSources.push(archivePath);
+                    delete index[archivePath];
+                    const statePath = join(paths.state, `${sessionID}.json`);
+                    const state = await readJSON(statePath, {});
+                    if (state.file === archivePath) {
+                        state.file = null;
+                        await atomicJSON(statePath, state);
+                    }
+                    await atomicJSON(paths.index, index);
+                    continue;
+                }
+            }
+        }
+        removedSources.push(archivePath);
+        delete index[archivePath];
+        index[destination] = sessionID;
+        const statePath = join(paths.state, `${sessionID}.json`);
+        const state = await readJSON(statePath, {});
+        if (state.file === archivePath) {
+            state.file = destination;
+            await atomicJSON(statePath, state);
+        }
+        await atomicJSON(paths.index, index);
+    }
+    return removedSources;
+}
+export async function emitNotification(sessionID, title, turns) {
+    if (process.env.OPENCODE_ARCHIVE_NO_NOTIFY)
+        return;
+    const payload = Buffer.from(JSON.stringify({
+        v: 1,
+        magic: 'genterm-notify',
+        source: 'opencode-conversation-archiver',
+        sourceId: sessionID,
+        event: 'session.idle',
+        title: title || 'OpenCode',
+        body: `Turn complete · ${turns} ${turns === 1 ? 'turn' : 'turns'} archived`,
+    })).toString('base64');
+    let sequence = `\u001b]9999;${payload}\u001b\\`;
+    const tty = process.env.TMUX
+        ? (await run(process.cwd(), 'tmux', ['display-message', '-p', '#{pane_tty}'], 5_000)).stdout.trim()
+        : '/dev/tty';
+    if (!tty)
+        return;
+    if (process.env.TMUX) {
+        await run(process.cwd(), 'tmux', ['set', '-p', 'allow-passthrough', 'on'], 5_000);
+        sequence = `\u001bPtmux;${sequence.replaceAll('\u001b', '\u001b\u001b')}\u001b\\`;
+    }
+    await writeFile(tty, sequence).catch(() => undefined);
+}