opencode-multidevice-sync 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 doomsday616
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,15 @@
+OpenCode Multidevice Sync
+
+This project is derived from opencode-github-sync version 3.0.1:
+https://github.com/doomsday616/opencode-github-sync
+Upstream revision: f9b2c200d3d67e161aaaf26c554c81c5fdea64dd
+Original copyright: Copyright (c) 2026 doomsday616
+Original license: MIT (retained in LICENSE).
+
+Modifications: Copyright (c) 2026 logser13 and contributors, MIT.
+Changes include non-destructive session import, deterministic exports,
+local project preservation, verified backups, conflict detection,
+path mapping, diagnostics, preview isolation and regression tests.
+
+Independent community fork. Not an official OpenCode component and not
+endorsed by the original author. No warranty; see LICENSE.

package/README.md

@@ -0,0 +1,111 @@
+# OpenCode Multidevice Sync
+
+A community fork of `opencode-github-sync` 3.0.1 for moving OpenCode configuration and selected conversations between computers.
+
+**Early preview, not a stable production release.** Keep independent backups. Use one active computer at a time. This project is not affiliated with OpenCode or the upstream author.
+
+[Русская документация](README.ru.md) | [Migration](docs/MIGRATION.md) | [Safety model](docs/SAFETY.md) | [Roadmap](docs/ROADMAP.md)
+
+## What is implemented
+
+- Configuration, skills, plugins and machine-local overrides via a private GitHub repository.
+- Selected conversations as compressed JSON shards, never a live SQLite database in Git.
+- Non-destructive SQLite UPSERT and preservation of existing project metadata, including `global`.
+- Deterministic serialization with canonical ordering; unchanged exports stay byte-identical.
+- Whole-batch transactional session import, schema/ownership validation and integrity checks before commit.
+- Verified SQLite snapshots before modifying session data, with configurable backup retention.
+- Per-session content baselines to detect divergent edits, including message changes without a timestamp change.
+- Canonical-to-local path mappings, reversed on export.
+- `doctor`, `backup`, offline `restore`, and isolated `--dry-run` previews.
+- A local process lock and debounced auto-push. This is **not** a distributed multi-writer lock.
+
+## Requirements
+
+Node.js 22.13+ (24 LTS recommended), Git, GitHub CLI (`gh`), and an initialized OpenCode installation. The plugin dependency is pinned to the OpenCode 1.18.30 SDK. Other OpenCode schema versions require testing; unsupported columns fail closed rather than being silently dropped.
+
+The source-code repository is public. Your **separate sync-data repository must be private**. Do not point the tool at this source-code repository.
+
+## Install from source
+
+```sh
+git clone https://github.com/logser13/opencode-multidevice-sync.git
+cd opencode-multidevice-sync
+npm ci
+npm run check
+npm pack
+npm install -g ./opencode-multidevice-sync-0.1.0.tgz
+omds --version
+```
+
+On Windows PowerShell with script execution disabled, use `npm.cmd` and `omds.cmd`. Changing execution policy is not required.
+
+This repository does not imply an npm registry release. Until a registry release is announced, install the locally built tarball or the reviewed GitHub release asset.
+
+## First device
+
+```sh
+gh auth login
+omds init my-opencode-config
+omds sessions enable
+omds doctor
+omds push --dry-run
+omds push
+```
+
+Start OpenCode once before importing conversations so it creates its own database schema and synthetic project. Configuration and session settings are stored in `~/.config/opencode/opencode-sync.jsonc`; the legacy filename is kept for migration compatibility.
+
+## Second device
+
+```sh
+gh auth login
+omds link YOUR_ACCOUNT/my-opencode-config
+omds sessions enable
+omds pull --dry-run
+omds pull
+```
+
+Use a different `machineAlias` on each device. Keep credentials local and review machine-specific paths before starting OpenCode. See `examples/work-laptop.jsonc` and `examples/home-laptop.jsonc`.
+
+## OpenCode plugin
+
+For an installation from a local tarball, find the absolute installed plugin entry:
+
+```sh
+npm root -g
+# Append /opencode-multidevice-sync/dist/plugin/index.js
+```
+
+Add its absolute file URL to the OpenCode `plugin` array, for example `file:///C:/Users/YOU/AppData/Roaming/npm/node_modules/opencode-multidevice-sync/dist/plugin/index.js`. Do not paste this example without adapting the path. Do not run the upstream sync plugin or its old safe-wrapper alongside this plugin.
+
+`autoPullOnStartup` checks for incoming changes at startup. `autoPushOnIdle` is opt-in and waits for a successful initial pull; errors are logged and surfaced as notifications. Restart OpenCode after changes to imported configuration or sessions. Wait for a successful push before switching computers; closing the app or losing the network can interrupt a sync.
+
+## Recovery
+
+```sh
+omds doctor --json
+omds backup
+```
+
+Close every OpenCode process cleanly before restoring:
+
+```sh
+omds restore /absolute/path/to/verified-backup.db --offline
+```
+
+Restore refuses existing WAL/SHM/journal files rather than deleting them. The current database is backed up first. `--force` does not bypass the offline requirement. Never delete database journals to force a restore.
+
+## Limitations you must understand
+
+A sync transfers history and configuration, not the project's source files, browser profiles, active processes, external tool-output files or API credentials. Transfer project files separately. Path mapping covers session `directory`/`path` and project `worktree`, not every path embedded in message text or tool JSON.
+
+Time/count/size limits select what gets exported. Existing remote shards are not automatically deleted when one device lacks a session or its selection window expires. Git history may retain data even after a file is removed.
+
+A private repository is access control, not end-to-end encryption. Conversations can contain secrets even when credential-file sync is disabled. The credential scanner is a best-effort guard, not proof that a repository is free of secrets.
+
+Conflicting sessions stop the import for manual review. There is no automatic merge of competing conversations. `--dry-run` uses a disposable snapshot and can require additional disk space; previews with `extraPaths` are refused. Local locking does not prevent simultaneous writers on other computers.
+
+## Development and origin
+
+Run `npm run check` for lint, type checking, build and tests. SQLite tests must execute, not silently skip. CI covers supported Node versions on Windows, Linux and macOS.
+
+Based on [doomsday616/opencode-github-sync](https://github.com/doomsday616/opencode-github-sync), version 3.0.1. The original MIT copyright and permission notice remain in [LICENSE](LICENSE). See [NOTICE](NOTICE) for attribution and [CONTRIBUTING.md](CONTRIBUTING.md) for development rules.

package/README.ru.md

@@ -0,0 +1,57 @@
+# OpenCode Multidevice Sync
+
+Независимый форк `opencode-github-sync 3.0.1` для переноса настроек и выбранных диалогов OpenCode между компьютерами.
+
+**Версия 0.1.0 - предварительная, не стабильный production-релиз.** Используйте один активный компьютер и отдельные резервные копии. Проект не связан официально с OpenCode или автором исходного пакета.
+
+## Что сделано
+
+- Настройки, инструкции, skills и плагины через отдельный приватный GitHub-репозиторий.
+- Диалоги переносятся отдельными JSON.gz-файлами. Живая `opencode.db` не отправляется в Git.
+- Настоящий UPSERT без каскадного удаления сессий. Локальная запись `global` не перезаписывается.
+- Стабильная сериализация: повторный экспорт без изменений не создает новые файлы.
+- Транзакция на весь импорт. Проверяются схема, принадлежность строк, внешние ключи и целостность БД.
+- Проверенные SQLite-снимки перед импортом. Откат транзакции при ошибке.
+- Обнаружение изменений одной сессии на двух компьютерах по хешам содержимого.
+- Сопоставление путей между компьютерами, диагностика и восстановление.
+
+## Установка из исходников
+
+Нужны Node.js 22.13+ (рекомендуется 24), Git, GitHub CLI и OpenCode. Зависимость SDK зафиксирована на 1.18.30. Совместимость с другими версиями необходимо проверять.
+
+```sh
+git clone https://github.com/logser13/opencode-multidevice-sync.git
+cd opencode-multidevice-sync
+npm ci
+npm run check
+npm pack
+npm install -g ./opencode-multidevice-sync-0.1.0.tgz
+```
+
+В PowerShell используйте `npm.cmd` и `omds.cmd`, если Windows блокирует `.ps1`. Публикация исходников не означает публикацию пакета в npm.
+
+## Настройка
+
+На первом компьютере: `gh auth login`, затем `omds init my-opencode-config`, `omds sessions enable`, `omds doctor`, `omds push --dry-run` и `omds push`.
+
+На втором: установите тот же пакет, запустите OpenCode один раз для создания БД, выполните `gh auth login`, `omds link YOUR_ACCOUNT/my-opencode-config`, `omds sessions enable`, `omds pull --dry-run` и `omds pull`.
+
+Репозиторий с исходниками и репозиторий с личными настройками - разные репозитории. Личные настройки и диалоги нельзя отправлять в публичный репозиторий проекта.
+
+Локальные параметры находятся в `~/.config/opencode/opencode-sync.jsonc`. Имя сохранено для совместимости. Укажите разные `machineAlias`. Секреты и состояние интерфейса по умолчанию не переносятся.
+
+Для подключения плагина добавьте в `plugin` абсолютный `file:///.../opencode-multidevice-sync/dist/plugin/index.js` установленного пакета. Корень глобальных npm-пакетов показывает `npm root -g`. Не запускайте одновременно исходный sync, старую safe-обертку и новый плагин.
+
+## Ежедневная работа
+
+`autoPullOnStartup` проверяет обновления при запуске. `autoPushOnIdle` включается отдельно. Перед переходом на другой компьютер дождитесь успешной отправки. После импорта перезапустите OpenCode. При конфликте обе версии сохраняются для ручного разбора, автоматического слияния диалогов нет.
+
+`omds doctor --json` проверяет состояние. `omds backup` делает проверенный снимок. Для восстановления закройте OpenCode и выполните `omds restore ПУТЬ_К_КОПИИ --offline`. При наличии WAL/SHM восстановление откажется работать: не удаляйте эти файлы вручную.
+
+## Ограничения
+
+Локальная блокировка не защищает от двух одновременно работающих компьютеров. Файлы проектов, браузерные профили, активные процессы и внешние результаты инструментов не синхронизируются. Пути внутри произвольного текста сообщений не преобразуются.
+
+Приватный GitHub - не сквозное шифрование. Секреты могут оказаться в самих диалогах. Фильтры по времени и размеру ограничивают новые экспорты, но не удаляют автоматически прежние архивы и историю Git.
+
+[Инструкция миграции](docs/MIGRATION.md), [модель безопасности](docs/SAFETY.md), [планы](docs/ROADMAP.md). Проект основан на MIT-коде doomsday616; исходное уведомление сохранено в LICENSE и NOTICE.

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":""}

package/dist/cli/index.js

@@ -0,0 +1,460 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import { createDatabaseBackup, latestDatabaseBackup, listDatabaseBackups, restoreDatabaseBackup, } from "../core/backup.js";
+import { git } from "../core/git.js";
+import { assertPrivateRemote } from "../core/guard.js";
+import { checkDatabaseHealth, healthProblems } from "../core/health.js";
+import { withSyncLock } from "../core/lock.js";
+import { getDatabasePath, getRoots } from "../core/paths.js";
+import { listSessions } from "../core/sessions.js";
+import { repoUrl } from "../core/settings.js";
+import { OVERRIDES_TEMPLATE, loadSettings, overridesPath, saveSettings, settingsPath, } from "../core/settings.js";
+import { SetupError, discoverSyncRepos, initSync, linkSync } from "../core/setup.js";
+import { sqliteAvailable } from "../core/sqlite.js";
+import { SyncError, formatBytes, pull, push, status } from "../core/sync.js";
+import { Spinner, banner, createCliReporter, detail, fail, heading, info, keyValue, ok, outcome, rule, warn, write, } from "./render.js";
+import { glyph, paint, style } from "./theme.js";
+const LOCK_WAIT_MS = 5 * 60 * 1000;
+function parseArgs(argv) {
+    const positional = [];
+    const flags = new Set();
+    const values = new Map();
+    for (const arg of argv) {
+        if (!arg.startsWith("-")) {
+            positional.push(arg);
+            continue;
+        }
+        const clean = arg.replace(/^--?/, "");
+        const eq = clean.indexOf("=");
+        if (eq !== -1)
+            values.set(clean.slice(0, eq), clean.slice(eq + 1));
+        else
+            flags.add(clean);
+    }
+    return { command: positional.shift() ?? "help", positional, flags, values };
+}
+async function confirm(question, lines) {
+    if (!process.stdin.isTTY)
+        return false;
+    write();
+    write(`  ${paint(" FORCE ", style.bold, style.red)}  ${paint(question, style.bold, style.text)}`);
+    for (const line of lines)
+        write(`  ${paint(`${glyph.bullet} ${line}`, style.muted)}`);
+    write();
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve) => {
+        rl.question(`  ${paint("Type", style.muted)} ${paint("yes", style.bold, style.red)} ${paint("to continue: ", style.muted)}`, resolve);
+    });
+    rl.close();
+    write();
+    return answer.trim().toLowerCase() === "yes";
+}
+// ── Commands ────────────────────────────────────────────────────────────────
+async function runSync(action, args) {
+    const force = args.flags.has("force") || args.flags.has("f");
+    const dryRun = args.flags.has("dry-run") || args.flags.has("n");
+    const roots = getRoots();
+    banner(action === "push" ? "push to GitHub" : "pull from GitHub", force ? "FORCE" : undefined);
+    if (force && !dryRun) {
+        const consequences = action === "push"
+            ? ["Any change made on another machine and not pulled here will be overwritten."]
+            : [
+                "Uncommitted local changes will be discarded.",
+                "Skills and state directories will be rewritten from the repository.",
+            ];
+        if (!(await confirm(`Force ${action}?`, consequences))) {
+            info("Cancelled.");
+            return;
+        }
+    }
+    const spinner = new Spinner(action === "push" ? "Preparing push" : "Preparing pull");
+    spinner.start();
+    const reporter = createCliReporter(spinner);
+    try {
+        const result = await withSyncLock(roots.config, { waitMs: LOCK_WAIT_MS }, () => action === "push"
+            ? push({ force, dryRun, reporter, roots })
+            : pull({ force, dryRun, reporter, roots }));
+        spinner.stop();
+        if (result.sessions) {
+            const bits = [];
+            if (result.sessions.exported !== undefined)
+                bits.push(`${result.sessions.exported} exported`);
+            if (result.sessions.imported !== undefined)
+                bits.push(`${result.sessions.imported} imported`);
+            if (result.sessions.skipped)
+                bits.push(`${result.sessions.skipped} skipped`);
+            if (bits.length > 0)
+                detail(`Sessions: ${bits.join(", ")}`);
+        }
+        outcome(dryRun ? `${result.message} (dry run)` : result.message, result.changed);
+        if (result.restartRequired && result.changed) {
+            info("Restart OpenCode for the new configuration to take effect.");
+            write();
+        }
+    }
+    finally {
+        spinner.stop();
+    }
+}
+function runStatus() {
+    banner("status");
+    const roots = getRoots();
+    const state = status({ roots });
+    if (!state.configured) {
+        fail("No sync repository configured.");
+        write();
+        info("Run `omds init` to create one.");
+        const found = discoverSyncRepos();
+        if (found.length > 0) {
+            write();
+            detail(`Existing private repositories that look like a match: ${found.slice(0, 5).join(", ")}`);
+            detail("Link one with: omds link <owner/repo>");
+        }
+        write();
+        return;
+    }
+    keyValue("repository", paint(state.remote ?? "-", style.text));
+    keyValue("branch", paint(state.branch, style.text));
+    keyValue("machine", paint(state.machineAlias, style.text));
+    if (!state.initialized) {
+        write();
+        warn("The local repository is not initialised yet. Run `omds pull`.");
+        write();
+        return;
+    }
+    const sync = state.ahead === 0 && state.behind === 0
+        ? paint("in sync", style.green)
+        : [
+            state.ahead > 0 ? paint(`${state.ahead} to push`, style.yellow) : "",
+            state.behind > 0 ? paint(`${state.behind} to pull`, style.cyan) : "",
+        ]
+            .filter(Boolean)
+            .join(paint("  ", style.faint));
+    keyValue("state", sync);
+    keyValue("uncommitted", state.dirty === 0 ? paint("clean", style.green) : paint(`${state.dirty} file(s)`, style.yellow));
+    keyValue("overrides", state.overridesActive ? paint("active", style.accent) : paint("none", style.muted));
+    keyValue("sessions", state.sessionsEnabled
+        ? paint(`enabled · ${state.sessionShards} shard(s)`, style.text)
+        : paint("disabled", style.muted));
+    if (state.lastCommit) {
+        heading("Last commit");
+        detail(state.lastCommit);
+        if (state.lastCommitDate)
+            detail(state.lastCommitDate);
+    }
+    write();
+}
+function runInit(args, mode) {
+    banner(mode === "init" ? "create a sync repository" : "link an existing repository");
+    const reporter = createCliReporter();
+    const options = {
+        repo: args.positional[0],
+        reporter,
+        includeCredentials: args.flags.has("credentials"),
+        includeSessions: args.flags.has("sessions"),
+    };
+    const result = mode === "init" ? initSync(options) : linkSync(options);
+    ok(result.created
+        ? `Created ${paint(`${result.target.owner}/${result.target.name}`, style.bold, style.text)}`
+        : `Linked ${paint(`${result.target.owner}/${result.target.name}`, style.bold, style.text)}`);
+    detail(`settings  ${result.settingsFile}`);
+    detail(`overrides ${result.overridesFile}`);
+    heading("Next");
+    write(`  ${paint("1.", style.faint)} ${mode === "init" ? "omds push" : "omds pull"}`);
+    write(`  ${paint("2.", style.faint)} Restart OpenCode`);
+    write();
+}
+async function runSessions(args) {
+    const sub = args.positional[0] ?? "list";
+    const roots = getRoots();
+    const settings = loadSettings(roots.config);
+    if (sub === "list") {
+        banner("sessions");
+        if (!(await sqliteAvailable())) {
+            fail("No SQLite driver available. Use Node 22.5+ or run under Bun.");
+            write();
+            return;
+        }
+        const limit = Number(args.values.get("limit") ?? 20);
+        const sessions = await listSessions(getDatabasePath(roots), limit);
+        if (sessions.length === 0) {
+            info("No sessions found.");
+            write();
+            return;
+        }
+        for (const session of sessions) {
+            const when = new Date(session.timeUpdated).toISOString().slice(0, 16).replace("T", " ");
+            const title = session.title || paint("(untitled)", style.faint);
+            write(`  ${paint(when, style.faint)}  ${title}`);
+            write(`  ${paint(" ".repeat(16), style.faint)}  ${paint(session.id, style.faint)}`);
+        }
+        write();
+        detail(`Pin a session with: omds sessions include <id>`);
+        write();
+        return;
+    }
+    if (sub === "include" || sub === "exclude") {
+        const id = args.positional[1];
+        if (!id)
+            throw new SyncError(`Usage: omds sessions ${sub} <session-id>`);
+        const list = sub === "include" ? settings.sessions.include : settings.sessions.exclude;
+        if (!list.includes(id))
+            list.push(id);
+        saveSettings(settings, roots.config);
+        banner("sessions");
+        ok(`${sub === "include" ? "Pinned" : "Excluded"} ${paint(id, style.text)}`);
+        write();
+        return;
+    }
+    if (sub === "enable" || sub === "disable") {
+        settings.sessions.enabled = sub === "enable";
+        saveSettings(settings, roots.config);
+        banner("sessions");
+        ok(`Session sync ${sub}d`);
+        if (sub === "enable") {
+            detail(`Window: ${settings.sessions.days} day(s), up to ${settings.sessions.maxSessions} sessions`);
+            detail(`Per-session cap: ${formatBytes(settings.sessions.maxSessionBytes)}`);
+            warn("Only enable this for a private repository — conversations are private data.");
+        }
+        write();
+        return;
+    }
+    throw new SyncError(`Unknown sessions subcommand: ${sub}`);
+}
+async function runDoctor(args) {
+    const roots = getRoots();
+    const settings = loadSettings(roots.config);
+    const remote = repoUrl(settings);
+    const issues = [];
+    const database = getDatabasePath(roots);
+    let health;
+    try {
+        health = await checkDatabaseHealth(database);
+        if (settings.sessions.enabled && !health.ok)
+            issues.push(...healthProblems(health));
+    }
+    catch (error) {
+        issues.push(error.message);
+    }
+    if (!remote)
+        issues.push("Sync repository is not configured");
+    else {
+        const reachable = git(["ls-remote", remote, "HEAD"], { cwd: roots.config });
+        if (!reachable.ok)
+            issues.push("Remote is unreachable or authentication failed");
+        try {
+            assertPrivateRemote(remote, settings);
+        }
+        catch (error) {
+            issues.push(error.message);
+        }
+    }
+    const report = {
+        package: "opencode-multidevice-sync",
+        version: "0.1.0",
+        machine: settings.machineAlias ?? "auto",
+        database: health,
+        sessionSync: settings.sessions.enabled,
+        backupBeforeImport: settings.sessions.backupBeforeImport,
+        credentialsSync: settings.includeCredentials,
+        backups: listDatabaseBackups().length,
+        issues,
+        ok: issues.length === 0,
+        note: "Preflight checks only; not a guarantee of conflict-free concurrent editing. Keep one active device.",
+    };
+    if (args.flags.has("json"))
+        console.log(JSON.stringify(report, null, 2));
+    else {
+        banner("doctor");
+        keyValue("version", report.version);
+        keyValue("machine", report.machine);
+        keyValue("sessions", String(health?.sessions ?? 0));
+        keyValue("messages", String(health?.messages ?? 0));
+        keyValue("parts", String(health?.parts ?? 0));
+        keyValue("database integrity", health?.ok ? "OK" : "NOT OK");
+        keyValue("backups", String(report.backups));
+        if (report.ok)
+            ok("Preflight checks passed");
+        else
+            for (const issue of issues)
+                fail(issue);
+        info(report.note);
+        write();
+    }
+    if (!report.ok)
+        process.exitCode = 1;
+}
+async function runBackup() {
+    const roots = getRoots();
+    const settings = loadSettings(roots.config);
+    const result = await withSyncLock(roots.config, { waitMs: LOCK_WAIT_MS }, () => createDatabaseBackup(getDatabasePath(roots), undefined, settings.sessions.backupRetention));
+    banner("backup");
+    ok("Verified SQLite snapshot created");
+    detail(result.path);
+    detail(formatBytes(result.bytes));
+}
+function assertOpenCodeClosed() {
+    const windows = process.platform === "win32";
+    const check = spawnSync(windows ? "tasklist.exe" : "ps", windows ? ["/FO", "CSV", "/NH"] : ["-A", "-o", "comm="], { encoding: "utf8", windowsHide: true, timeout: 10000 });
+    if (check.status !== 0)
+        throw new SyncError("Cannot check running applications; restore refused");
+    if (windows
+        ? /^"(?:opencode|opencode-cli)\.exe"/im.test(check.stdout)
+        : /(?:^|\/)(?:opencode|OpenCode)(?:\n|$)/m.test(check.stdout))
+        throw new SyncError("OpenCode is running. Close it cleanly before restoring.");
+}
+async function runRestore(args) {
+    if (!args.flags.has("offline"))
+        throw new SyncError("Restore requires --offline and all OpenCode processes closed. --force cannot bypass this check.");
+    assertOpenCodeClosed();
+    const roots = getRoots();
+    const backup = args.positional[0]
+        ? { path: path.resolve(args.positional[0]) }
+        : latestDatabaseBackup();
+    if (!backup)
+        throw new SyncError("No database backup found");
+    if (!args.flags.has("yes") &&
+        !(await confirm("Restore verified backup?", [
+            backup.path,
+            "Existing database will be backed up first. No WAL files will be deleted.",
+        ])))
+        return;
+    const safety = await withSyncLock(roots.config, { waitMs: LOCK_WAIT_MS }, () => restoreDatabaseBackup(getDatabasePath(roots), backup.path, { offlineConfirmed: true }));
+    ok("Database restored");
+    if (safety)
+        detail(`Previous database: ${safety}`);
+}
+function runOverrides() {
+    banner("per-machine overrides");
+    const roots = getRoots();
+    const file = overridesPath(roots.config);
+    if (!fs.existsSync(file)) {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, OVERRIDES_TEMPLATE);
+        ok("Created the overrides file");
+    }
+    detail(file);
+    write();
+    info("Anything in this file stays on this machine and is re-applied after every pull.");
+    write();
+}
+function runConfig() {
+    banner("settings");
+    const roots = getRoots();
+    const file = settingsPath(roots.config);
+    if (!fs.existsSync(file)) {
+        fail("No settings file yet. Run `omds init`.");
+        write();
+        return;
+    }
+    detail(file);
+    write();
+    write(fs.readFileSync(file, "utf8").trimEnd());
+    write();
+}
+function runHelp() {
+    banner("sync OpenCode across machines");
+    heading("Setup");
+    command("init [name|owner/repo]", "Create a private sync repository");
+    command("link <owner/repo>", "Use an existing sync repository");
+    heading("Sync");
+    command("push", "Send this machine's configuration");
+    command("pull", "Apply the shared configuration");
+    command("status", "Show what is in sync and what is not");
+    heading("Sessions");
+    command("sessions list", "Show recent sessions and their ids");
+    command("sessions enable | disable", "Turn selective session sync on or off");
+    command("sessions include <id>", "Always sync a session, ignoring the time window");
+    command("sessions exclude <id>", "Never sync a session");
+    heading("Safety and recovery");
+    command("doctor [--json]", "Check repository and database integrity");
+    command("backup", "Create a consistent verified SQLite backup");
+    command("restore [file] --offline", "Restore after OpenCode is fully closed");
+    heading("Machine-local");
+    command("overrides", "Open the per-machine configuration patch");
+    command("config", "Show the current settings");
+    heading("Flags");
+    command("--force", "Overwrite the other side on conflict");
+    command("--dry-run", "Report what would change without doing it");
+    write();
+    rule();
+    write(`  ${paint("docs", style.faint)}  ${paint("https://github.com/logser13/opencode-multidevice-sync", style.muted)}`);
+    write();
+}
+function command(name, description) {
+    const padded = name.padEnd(30);
+    write(`  ${paint(padded, style.cyan)}${paint(description, style.muted)}`);
+}
+// ── Entry point ─────────────────────────────────────────────────────────────
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.flags.has("version")) {
+        console.log("0.1.0");
+        return;
+    }
+    switch (args.command) {
+        case "doctor":
+            await runDoctor(args);
+            return;
+        case "backup":
+            await runBackup();
+            return;
+        case "restore":
+            await runRestore(args);
+            return;
+        case "push":
+        case "pull":
+            await runSync(args.command, args);
+            return;
+        case "status":
+            runStatus();
+            return;
+        case "init":
+            runInit(args, "init");
+            return;
+        case "link":
+            runInit(args, "link");
+            return;
+        case "sessions":
+            await runSessions(args);
+            return;
+        case "overrides":
+            runOverrides();
+            return;
+        case "config":
+            runConfig();
+            return;
+        case "help":
+        case "--help":
+        case "-h":
+            runHelp();
+            return;
+        default:
+            banner();
+            fail(`Unknown command: ${args.command}`);
+            write();
+            info("Run `omds help` to see everything.");
+            write();
+            process.exitCode = 1;
+    }
+}
+main().catch((error) => {
+    const err = error;
+    write();
+    if (err instanceof SyncError || err instanceof SetupError || err.name === "GitAuthError") {
+        fail(err.message);
+    }
+    else {
+        fail(err.message || String(error));
+        if (process.env.OPENCODE_SYNC_VERBOSE === "1" && err.stack) {
+            write();
+            detail(err.stack);
+        }
+    }
+    write();
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map