@jlmarcos99/todos 0.0.0-stage → 1.1.0

package/dist/app/src/model/activity.js

@@ -0,0 +1 @@
+export {};

package/dist/app/src/model/daily.js

@@ -0,0 +1,34 @@
+/** Use local calendar dates, not UTC dates or rolling 24-hour windows. */
+export function dayKey(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+export function getDailyItems(vault, date, dayCount = 2) {
+    const includedDays = new Set();
+    for (let offset = 0; offset < dayCount; offset++) {
+        const day = new Date(date);
+        day.setDate(day.getDate() - offset);
+        includedDays.add(dayKey(day));
+    }
+    const activityByTask = new Map();
+    for (const entry of vault.activity) {
+        if (!includedDays.has(dayKey(entry.date)))
+            continue;
+        const entries = activityByTask.get(entry.taskId) ?? [];
+        entries.push(entry);
+        activityByTask.set(entry.taskId, entries);
+    }
+    const result = [];
+    for (const task of vault.tasks) {
+        const entries = activityByTask.get(task.id);
+        if (!entries?.length)
+            continue;
+        entries.sort((a, b) => a.date.getTime() - b.date.getTime());
+        const latest = entries[entries.length - 1];
+        result.push({ task, name: latest.taskName, status: latest.status, entries });
+    }
+    const statusOrder = { done: 0, 'in-progress': 1, todo: 2 };
+    return result.sort((a, b) => statusOrder[a.status] - statusOrder[b.status]);
+}

package/dist/app/src/model/task.js

@@ -0,0 +1 @@
+export {};

package/dist/app/src/model/vault.js

@@ -0,0 +1 @@
+export {};

package/dist/app/src/storage/atomic-file.js

@@ -0,0 +1,15 @@
+import { mkdir, rename, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+export async function writeJsonAtomically(file, value) {
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+        await rename(temporary, file);
+    }
+    catch (error) {
+        await rm(temporary, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}

package/dist/app/src/storage/record-codec.js

@@ -0,0 +1,57 @@
+const statuses = new Set(['todo', 'in-progress', 'done']);
+const kinds = new Set(['started', 'completed', 'reopened', 'note']);
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function record(value, label) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new Error(`${label} must be an object.`);
+    return value;
+}
+function string(value, field) {
+    if (typeof value !== 'string' || !value)
+        throw new Error(`Invalid ${field} in Todos data.`);
+    return value;
+}
+function id(value, field) {
+    const result = string(value, field);
+    if (!UUID_PATTERN.test(result))
+        throw new Error(`Invalid ${field} in Todos data; expected a UUID.`);
+    return result;
+}
+function date(value, field) {
+    const result = new Date(string(value, field));
+    if (!Number.isFinite(result.getTime()))
+        throw new Error(`Invalid ${field} in Todos data.`);
+    return result;
+}
+export function decodeTask(value) {
+    const item = record(value, 'Task');
+    if (!statuses.has(item.status))
+        throw new Error('Invalid task status in Todos data.');
+    return {
+        id: id(item.id, 'task id'), name: string(item.name, 'task name'), status: item.status,
+        date: date(item.date, 'task date'),
+        ...(item.completedAt ? { completedAt: date(item.completedAt, 'completion date') } : {}),
+        ...(typeof item.description === 'string' ? { description: item.description } : {}),
+    };
+}
+export function encodeTask(task) {
+    return { ...task, date: task.date.toISOString(), ...(task.completedAt ? { completedAt: task.completedAt.toISOString() } : {}) };
+}
+export function decodeActivity(value) {
+    const item = record(value, 'Activity');
+    if (!kinds.has(String(item.kind)) || !statuses.has(item.status))
+        throw new Error('Invalid activity in Todos data.');
+    return {
+        id: id(item.id, 'activity id'), taskId: id(item.taskId, 'activity task id'),
+        taskName: string(item.taskName, 'activity task name'), date: date(item.date, 'activity date'),
+        kind: item.kind, status: item.status,
+        ...(typeof item.note === 'string' ? { note: item.note } : {}),
+    };
+}
+export function encodeActivity(activity) {
+    return { ...activity, date: activity.date.toISOString() };
+}
+export function decodeVault(value) {
+    const item = record(value, 'Vault');
+    return { id: id(item.id, 'vault id'), name: string(item.name, 'vault name'), description: typeof item.description === 'string' ? item.description : '' };
+}

package/dist/app/src/storage/store.js

@@ -0,0 +1,187 @@
+import { randomUUID } from 'node:crypto';
+import { chmod, lstat, mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { writeJsonAtomically } from "./atomic-file.js";
+import { decodeActivity, decodeTask, decodeVault, encodeActivity, encodeTask } from "./record-codec.js";
+const FORMAT_VERSION = 1;
+const OWNER_MARKER = '.jmtodos-store';
+const STORE_FILE = 'store.json';
+const RECORD_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+export class StoreRepository {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    async initialize() {
+        await mkdir(this.root, { recursive: true, mode: 0o700 });
+        const entries = await readdir(this.root);
+        const partialOwned = entries.length === 1 && entries[0] === OWNER_MARKER;
+        const isRecognized = entries.includes(OWNER_MARKER) && entries.includes(STORE_FILE);
+        if (entries.length && !isRecognized && !partialOwned)
+            throw new Error(`Refusing to initialize a non-empty unrelated folder: ${this.root}`);
+        if (partialOwned || isRecognized)
+            await this.assertOwnerMarker();
+        await chmod(this.root, 0o700).catch(() => undefined);
+        if (isRecognized) {
+            await this.assertStoreVersion();
+            if (!(await this.loadVaults()).length)
+                await this.createVault('Personal', 'Your personal tasks and daily progress.');
+            return;
+        }
+        if (!partialOwned)
+            await writeFile(path.join(this.root, OWNER_MARKER), 'Todos managed task store\n', { mode: 0o600, flag: 'wx' });
+        await writeJsonAtomically(path.join(this.root, STORE_FILE), { formatVersion: FORMAT_VERSION });
+        await this.createVault('Personal', 'Your personal tasks and daily progress.');
+    }
+    async isInitialized() {
+        try {
+            await this.assertOwnerMarker();
+            await lstat(path.join(this.root, STORE_FILE));
+            await this.assertStoreVersion();
+            return true;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return false;
+            throw error;
+        }
+    }
+    async loadVaults() {
+        await this.assertStoreVersion();
+        const directory = path.join(this.root, 'vaults');
+        let ids;
+        try {
+            ids = (await readdir(directory, { withFileTypes: true })).filter(entry => entry.isDirectory()).map(entry => entry.name);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+        const vaults = [];
+        for (const id of ids.sort()) {
+            const base = path.join(directory, id);
+            const metadata = decodeVault(await this.readJson(path.join(base, 'vault.json')));
+            if (metadata.id !== id)
+                throw new Error(`Vault folder ID does not match its metadata: ${id}`);
+            const tasks = await this.readRecords(path.join(base, 'tasks'), decodeTask);
+            const activity = await this.readRecords(path.join(base, 'activity'), decodeActivity);
+            vaults.push({ ...metadata, tasks, activity });
+        }
+        const vaultIds = new Set();
+        const taskIds = new Set();
+        const activityIds = new Set();
+        for (const vault of vaults) {
+            if (vaultIds.has(vault.id))
+                throw new Error(`Duplicate vault ID in Todos data: ${vault.id}`);
+            vaultIds.add(vault.id);
+            for (const task of vault.tasks) {
+                if (taskIds.has(task.id))
+                    throw new Error(`Duplicate task ID in Todos data: ${task.id}`);
+                taskIds.add(task.id);
+            }
+            const thisVaultTaskIds = new Set(vault.tasks.map(task => task.id));
+            for (const item of vault.activity) {
+                if (activityIds.has(item.id))
+                    throw new Error(`Duplicate activity ID in Todos data: ${item.id}`);
+                activityIds.add(item.id);
+                if (!thisVaultTaskIds.has(item.taskId))
+                    throw new Error(`Activity ${item.id} refers to a missing task ${item.taskId}.`);
+            }
+        }
+        return vaults;
+    }
+    async createVault(name, description = '') {
+        const cleanName = name.trim();
+        if (!cleanName)
+            throw new Error('Vault name cannot be empty.');
+        const vault = { id: randomUUID(), name: cleanName, description: description.trim(), tasks: [], activity: [] };
+        await writeJsonAtomically(path.join(this.root, 'vaults', vault.id, 'vault.json'), {
+            id: vault.id, name: vault.name, description: vault.description,
+        });
+        return vault;
+    }
+    async saveVault(vault) {
+        await writeJsonAtomically(path.join(this.root, 'vaults', vault.id, 'vault.json'), {
+            id: vault.id, name: vault.name, description: vault.description,
+        });
+    }
+    async saveTask(vaultId, task) {
+        await writeJsonAtomically(path.join(this.root, 'vaults', vaultId, 'tasks', `${task.id}.json`), encodeTask(task));
+    }
+    async saveActivity(vaultId, activity) {
+        await writeJsonAtomically(path.join(this.root, 'vaults', vaultId, 'activity', `${activity.id}.json`), encodeActivity(activity));
+    }
+    async deleteTask(vaultId, taskId) {
+        await this.deleteRecord(this.recordPath(vaultId, 'tasks', taskId));
+    }
+    async deleteActivity(vaultId, activityId) {
+        await this.deleteRecord(this.recordPath(vaultId, 'activity', activityId));
+    }
+    async assertStoreVersion() {
+        const data = await this.readJson(path.join(this.root, STORE_FILE));
+        if (typeof data !== 'object' || data === null || !('formatVersion' in data) || data.formatVersion !== FORMAT_VERSION) {
+            throw new Error(`Unsupported Todos store format. Supported version: ${FORMAT_VERSION}.`);
+        }
+    }
+    async assertOwnerMarker() {
+        const marker = path.join(this.root, OWNER_MARKER);
+        const info = await lstat(marker);
+        if (!info.isFile() || info.isSymbolicLink() || (await readFile(marker, 'utf8')) !== 'Todos managed task store\n') {
+            throw new Error(`Invalid Todos ownership marker at ${marker}.`);
+        }
+    }
+    async readJson(file) {
+        try {
+            const info = await lstat(file);
+            if (!info.isFile() || info.isSymbolicLink())
+                throw new Error('expected a regular file');
+            return JSON.parse(await readFile(file, 'utf8'));
+        }
+        catch (error) {
+            throw new Error(`Could not read Todos data at ${file}: ${error.message}`);
+        }
+    }
+    recordPath(vaultId, folder, id) {
+        return path.join(this.root, 'vaults', this.assertRecordId(vaultId), folder, `${this.assertRecordId(id)}.json`);
+    }
+    assertRecordId(value) {
+        if (!RECORD_ID.test(value))
+            throw new Error('Refusing to delete a record with an invalid id.');
+        return value;
+    }
+    async deleteRecord(file) {
+        let info;
+        try {
+            info = await lstat(file);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        if (!info.isFile() || info.isSymbolicLink())
+            throw new Error(`Refusing to delete a non-regular file: ${file}`);
+        await rm(file);
+    }
+    async readRecords(directory, decode) {
+        let files;
+        try {
+            files = await readdir(directory);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+        const result = [];
+        for (const file of files.filter(name => name.endsWith('.json')).sort()) {
+            const decoded = decode(await this.readJson(path.join(directory, file)));
+            if (typeof decoded === 'object' && decoded !== null && 'id' in decoded && decoded.id !== file.slice(0, -5)) {
+                throw new Error(`Record filename does not match its ID: ${path.join(directory, file)}`);
+            }
+            result.push(decoded);
+        }
+        return result;
+    }
+}

package/dist/app/src/sync/git-client.js

@@ -0,0 +1,50 @@
+import { spawn } from 'node:child_process';
+export class GitCommandError extends Error {
+    args;
+    exitCode;
+    constructor(message, args, exitCode) {
+        super(message);
+        this.args = args;
+        this.exitCode = exitCode;
+        this.name = 'GitCommandError';
+    }
+}
+function redact(text) {
+    return text.replace(/(https?:\/\/)[^/@\s]+@/gi, '$1[credentials]@');
+}
+/** Runs Git with an argument vector and a fixed working directory; never through a shell. */
+export class GitClient {
+    directory;
+    constructor(directory) {
+        this.directory = directory;
+    }
+    run(args, allowFailure = false) {
+        return this.runOnce(args, allowFailure).catch(async (error) => {
+            if (!(error instanceof GitCommandError) || !error.message.toLowerCase().includes('index.lock'))
+                throw error;
+            await new Promise(resolve => setTimeout(resolve, 150));
+            return this.runOnce(args, allowFailure);
+        });
+    }
+    runOnce(args, allowFailure) {
+        return new Promise((resolve, reject) => {
+            const child = spawn('git', ['-C', this.directory, ...args], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                windowsHide: true,
+                env: { ...process.env, GIT_TERMINAL_PROMPT: '0', GCM_INTERACTIVE: '0' },
+            });
+            let stdout = '';
+            let stderr = '';
+            child.stdout.setEncoding('utf8').on('data', chunk => { stdout += chunk; });
+            child.stderr.setEncoding('utf8').on('data', chunk => { stderr += chunk; });
+            child.once('error', error => reject(new GitCommandError(`Could not run Git: ${error.message}`, args, null)));
+            child.once('close', code => {
+                const result = { stdout: redact(stdout), stderr: redact(stderr), exitCode: code };
+                if (code === 0 || allowFailure)
+                    resolve(result);
+                else
+                    reject(new GitCommandError(result.stderr.trim() || `Git ${args[0]} failed.`, args, code));
+            });
+        });
+    }
+}

package/dist/app/src/sync/git-repository.js

@@ -0,0 +1,291 @@
+import { randomUUID } from 'node:crypto';
+import { chmod, mkdir, readFile, readdir, realpath, rename, rm } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { GitClient, GitCommandError } from "./git-client.js";
+import { StoreRepository } from "../storage/store.js";
+export class GitRepository {
+    root;
+    git;
+    constructor(root) {
+        this.root = root;
+        this.git = new GitClient(root);
+    }
+    async isRepository() {
+        try {
+            const root = (await this.git.run(['rev-parse', '--show-toplevel'])).stdout.trim();
+            return path.resolve(await realpath(root)) === path.resolve(await realpath(this.root));
+        }
+        catch (error) {
+            if (error instanceof GitCommandError)
+                return false;
+            throw error;
+        }
+    }
+    async hasRemote() {
+        if (!(await this.isRepository()))
+            return false;
+        return (await this.git.run(['remote'], true)).stdout.trim().length > 0;
+    }
+    async remoteUrl() {
+        if (!(await this.isRepository()))
+            return undefined;
+        return (await this.git.run(['remote', 'get-url', 'origin'], true)).stdout.trim() || undefined;
+    }
+    async syncState() {
+        if (!(await this.hasRemote()))
+            return 'local-only';
+        if ((await this.git.run(['status', '--porcelain', '--', '.jmtodos-store', 'store.json', 'vaults'])).stdout.trim())
+            return 'pending';
+        const upstream = await this.git.run(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'], true);
+        if (upstream.exitCode !== 0 || !upstream.stdout.trim())
+            return 'pending';
+        const counts = await this.git.run(['rev-list', '--left-right', '--count', `HEAD...${upstream.stdout.trim()}`]);
+        const [ahead, behind] = counts.stdout.trim().split(/\s+/).map(Number);
+        return ahead === 0 && behind === 0 ? 'synced' : 'pending';
+    }
+    async linkRemote(url) {
+        const normalized = url.trim();
+        if (!normalized || /\s/.test(normalized) || /https?:\/\/[^/@\s]+@/i.test(normalized)) {
+            throw new Error('Enter an SSH or HTTPS Git URL without embedded credentials. Use your SSH agent or Git credential helper.');
+        }
+        const moduleDirectory = path.dirname(fileURLToPath(import.meta.url));
+        const applicationRoot = (await new GitClient(moduleDirectory).run(['rev-parse', '--show-toplevel'], true)).stdout.trim();
+        const dataRoot = await realpath(this.root);
+        const canonicalApplicationRoot = applicationRoot ? await realpath(applicationRoot).catch(() => applicationRoot) : '';
+        if (canonicalApplicationRoot && isInside(canonicalApplicationRoot, dataRoot)) {
+            throw new Error('The Todos data folder is inside the application checkout. Choose a separate global data folder before linking.');
+        }
+        const enclosingRoot = (await this.git.run(['rev-parse', '--show-toplevel'], true)).stdout.trim();
+        if (enclosingRoot && path.resolve(await realpath(enclosingRoot)) !== path.resolve(dataRoot)) {
+            throw new Error('The Todos data folder is inside another Git repository. Choose an isolated data folder before linking.');
+        }
+        if (!(await this.isRepository()))
+            await this.git.run(['init', '--initial-branch=main']);
+        await this.secureGitDirectory();
+        const existing = await this.remoteUrl();
+        const addedRemote = !existing;
+        if (existing) {
+            if (existing !== normalized)
+                throw new Error('A remote is already linked. Run `todos unlink` before linking another remote.');
+        }
+        else
+            await this.git.run(['remote', 'add', 'origin', normalized]);
+        await this.commitSnapshot('Initial local task snapshot');
+        try {
+            const head = await this.remoteHead();
+            if (!head) {
+                const refs = await this.git.run(['ls-remote', 'origin']);
+                if (refs.stdout.trim()) {
+                    if (addedRemote)
+                        await this.git.run(['remote', 'remove', 'origin']);
+                    throw new Error('The remote contains refs but no branch Todos can use. Local data was kept.');
+                }
+                await this.renameCurrentBranch('main');
+                await this.git.run(['push', '-u', 'origin', 'HEAD:refs/heads/main']);
+                return;
+            }
+            await this.git.run(['fetch', 'origin']);
+            const remoteRef = `origin/${head}`;
+            if (!(await this.isTodosStore(remoteRef))) {
+                if (addedRemote)
+                    await this.git.run(['remote', 'remove', 'origin']);
+                throw new Error('The remote is non-empty and does not contain a recognized Todos store. Local data was kept.');
+            }
+            let clonePath;
+            try {
+                clonePath = await this.cloneAndValidateRemote(normalized, head);
+            }
+            catch (error) {
+                if (addedRemote)
+                    await this.git.run(['remote', 'remove', 'origin']);
+                throw error;
+            }
+            if (await this.isPristineLocalStore()) {
+                await this.adoptRemote(clonePath);
+                return;
+            }
+            await rm(clonePath, { recursive: true, force: true });
+            await this.renameCurrentBranch(head);
+            await this.mergeRemote(remoteRef);
+            await this.git.run(['push', '-u', 'origin', `HEAD:refs/heads/${head}`]);
+        }
+        catch (error) {
+            if (error instanceof GitCommandError)
+                throw new Error(`Could not link remote; local tasks remain safe. ${error.message}`);
+            throw error;
+        }
+    }
+    async syncBeforeRead() {
+        if (!(await this.hasRemote()))
+            return;
+        await this.git.run(['fetch', 'origin']);
+        const head = await this.remoteHead();
+        if (head) {
+            await this.mergeRemote(`origin/${head}`);
+            await this.commitAndPush('Synchronize pending task changes');
+        }
+    }
+    async commitAndPush(reason) {
+        if (!(await this.hasRemote()))
+            return;
+        await this.commitSnapshot(reason);
+        try {
+            await this.pushCurrentBranch();
+        }
+        catch {
+            await this.git.run(['fetch', 'origin']);
+            const head = await this.remoteHead();
+            if (head)
+                await this.mergeRemote(`origin/${head}`);
+            await this.pushCurrentBranch();
+        }
+    }
+    async unlink() {
+        if (await this.hasRemote())
+            await this.git.run(['remote', 'remove', 'origin']);
+    }
+    async commitSnapshot(reason) {
+        await this.git.run(['add', '-A', '--', '.jmtodos-store', 'store.json', 'vaults']);
+        const changed = await this.git.run(['diff', '--cached', '--quiet'], true);
+        if (changed.exitCode === 1) {
+            await this.git.run(['-c', 'user.name=Todos', '-c', 'user.email=todos@localhost', 'commit', '-m', `Todos: ${reason}`]);
+        }
+        else if (changed.exitCode !== 0)
+            throw new Error('Could not inspect staged task changes before committing.');
+    }
+    async remoteHead() {
+        const result = await this.git.run(['ls-remote', '--symref', 'origin', 'HEAD']);
+        const head = result.stdout.match(/^ref:\s+refs\/heads\/(.+)\s+HEAD$/m)?.[1];
+        if (head)
+            return head;
+        const refs = await this.git.run(['ls-remote', '--heads', 'origin']);
+        return refs.stdout.match(/\srefs\/heads\/(.+)$/m)?.[1];
+    }
+    async isTodosStore(ref) {
+        const marker = await this.git.run(['show', `${ref}:.jmtodos-store`], true);
+        const store = await this.git.run(['show', `${ref}:store.json`], true);
+        if (!marker.stdout || !store.stdout)
+            return false;
+        try {
+            return JSON.parse(store.stdout).formatVersion === 1;
+        }
+        catch {
+            return false;
+        }
+    }
+    async isPristineLocalStore() {
+        try {
+            const entries = (await readdir(this.root)).filter(entry => entry !== '.git').sort();
+            if (entries.join('|') !== '.jmtodos-store|store.json|vaults')
+                return false;
+            const vaultIds = await readdir(path.join(this.root, 'vaults'));
+            if (vaultIds.length !== 1)
+                return false;
+            const vaultDir = path.join(this.root, 'vaults', vaultIds[0]);
+            const metadata = JSON.parse(await readFile(path.join(vaultDir, 'vault.json'), 'utf8'));
+            const tasks = await entriesOrEmpty(path.join(vaultDir, 'tasks'));
+            const activity = await entriesOrEmpty(path.join(vaultDir, 'activity'));
+            return metadata.name === 'Personal' && tasks.length === 0 && activity.length === 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    async cloneAndValidateRemote(url, branch) {
+        const parent = path.dirname(this.root);
+        const clonePath = path.join(parent, `.jmtodos-clone-${randomUUID()}`);
+        await mkdir(parent, { recursive: true, mode: 0o700 });
+        try {
+            await new GitClient(parent).run(['clone', '--quiet', '--branch', branch, '--', url, clonePath]);
+            await restrictPermissions(clonePath);
+            const store = new StoreRepository(clonePath);
+            if (!(await store.isInitialized()))
+                throw new Error('The remote clone does not contain a valid Todos store.');
+            if (!(await store.loadVaults()).length)
+                throw new Error('The remote Todos store has no vaults. Local data was kept.');
+            return clonePath;
+        }
+        catch (error) {
+            await rm(clonePath, { recursive: true, force: true }).catch(() => undefined);
+            throw error;
+        }
+    }
+    async adoptRemote(clonePath) {
+        const backupPath = path.join(path.dirname(this.root), `.jmtodos-local-${randomUUID()}`);
+        await rename(this.root, backupPath);
+        try {
+            await rename(clonePath, this.root);
+            await chmod(this.root, 0o700).catch(() => undefined);
+            await this.secureGitDirectory();
+            await rm(backupPath, { recursive: true, force: true });
+        }
+        catch (error) {
+            if (await entriesOrEmpty(this.root).then(entries => entries.length > 0).catch(() => false)) {
+                await rename(this.root, clonePath).catch(() => undefined);
+            }
+            await rename(backupPath, this.root).catch(() => undefined);
+            await rm(clonePath, { recursive: true, force: true }).catch(() => undefined);
+            throw error;
+        }
+    }
+    async renameCurrentBranch(name) {
+        const current = await this.git.run(['branch', '--show-current']);
+        if (current.stdout.trim() !== name)
+            await this.git.run(['branch', '-m', name]);
+    }
+    async pushCurrentBranch() {
+        const branch = (await this.git.run(['branch', '--show-current'])).stdout.trim();
+        if (!branch)
+            throw new Error('Cannot push a detached Todos repository.');
+        await this.git.run(['push', 'origin', `HEAD:refs/heads/${branch}`]);
+    }
+    async secureGitDirectory() {
+        const result = await this.git.run(['rev-parse', '--absolute-git-dir']);
+        await chmod(result.stdout.trim(), 0o700).catch(() => undefined);
+        await chmod(path.join(result.stdout.trim(), 'config'), 0o600).catch(() => undefined);
+    }
+    async mergeRemote(ref) {
+        const localBeforeRemote = await this.git.run(['merge-base', '--is-ancestor', 'HEAD', ref], true);
+        if (localBeforeRemote.exitCode === 0) {
+            await this.git.run(['merge', '--ff-only', ref]);
+            return;
+        }
+        const remoteBeforeLocal = await this.git.run(['merge-base', '--is-ancestor', ref, 'HEAD'], true);
+        if (remoteBeforeLocal.exitCode === 0)
+            return;
+        try {
+            await this.git.run(['-c', 'user.name=Todos', '-c', 'user.email=todos@localhost', 'merge', '--no-edit', '--allow-unrelated-histories', ref]);
+        }
+        catch (error) {
+            await this.git.run(['merge', '--abort'], true);
+            throw new Error(`Git sync found conflicting task records. Both commits are preserved; resolve the conflict in ${this.root} and retry. ${error.message}`);
+        }
+    }
+}
+async function entriesOrEmpty(directory) {
+    try {
+        return await readdir(directory);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+async function restrictPermissions(directory) {
+    await chmod(directory, 0o700).catch(() => undefined);
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isSymbolicLink())
+            continue;
+        if (entry.isDirectory())
+            await restrictPermissions(fullPath);
+        else if (entry.isFile())
+            await chmod(fullPath, 0o600).catch(() => undefined);
+    }
+}
+function isInside(parent, candidate) {
+    const relative = path.relative(path.resolve(parent), path.resolve(candidate));
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}