dsh-memory-sync 0.0.0-stage → 0.1.1

package/lib/git.mjs

@@ -0,0 +1,286 @@
+import { spawn } from 'node:child_process'
+import { hostname } from 'node:os'
+
+function pad2(value) {
+  return String(value).padStart(2, '0')
+}
+
+/** Local ISO timestamp with a numeric offset, e.g. 2026-11-05T15:53:12+0800. */
+export function localIso(date = new Date()) {
+  const offset = -date.getTimezoneOffset()
+  const sign = offset >= 0 ? '+' : '-'
+  const abs = Math.abs(offset)
+  return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`
+    + `T${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}`
+    + `${sign}${pad2(Math.floor(abs / 60))}${pad2(abs % 60)}`
+}
+
+export function tail(text, limit = 500) {
+  const clean = String(text || '').replace(/\s+/g, ' ').trim()
+  if (clean.length <= limit) return clean
+  return `…${clean.slice(-limit)}`
+}
+
+/** Kill the whole tree on Windows (cmd/git may spawn children). */
+function killTree(child) {
+  if (!child || child.exitCode !== null) return
+  if (process.platform === 'win32') {
+    try {
+      spawn('taskkill', ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' })
+      return
+    } catch {
+      // fall through
+    }
+  }
+  try {
+    child.kill('SIGTERM')
+  } catch {
+    // already gone
+  }
+}
+
+/**
+ * Run a process without a shell, with a timeout and a bounded output buffer.
+ */
+export function runProcess(command, args, {
+  cwd,
+  env,
+  timeoutMs = 60000,
+  maxBytes = 4 * 1024 * 1024,
+} = {}) {
+  return new Promise((resolve) => {
+    const started = Date.now()
+    let stdout = ''
+    let stderr = ''
+    let truncated = false
+    let timedOut = false
+    let settled = false
+    let timer = null
+
+    const finish = (code, signal, errorMessage = '') => {
+      if (settled) return
+      settled = true
+      if (timer) clearTimeout(timer)
+      resolve({
+        code: Number.isInteger(code) ? code : -1,
+        signal: signal || null,
+        stdout,
+        stderr: errorMessage && !stderr ? errorMessage : stderr,
+        timedOut,
+        truncated,
+        durationMs: Date.now() - started,
+      })
+    }
+
+    let child
+    try {
+      child = spawn(command, args, {
+        cwd,
+        env: { ...process.env, ...(env || {}) },
+        windowsHide: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      })
+    } catch (error) {
+      finish(-1, null, String(error?.message || error))
+      return
+    }
+
+    const take = (chunk, which) => {
+      const text = chunk.toString('utf8')
+      if (which === 'out') {
+        const room = maxBytes - stdout.length
+        if (room <= 0) {
+          truncated = true
+          return
+        }
+        stdout += room >= text.length ? text : text.slice(0, room)
+        if (room < text.length) truncated = true
+        return
+      }
+      const room = maxBytes - stderr.length
+      if (room > 0) stderr += room >= text.length ? text : text.slice(0, room)
+    }
+
+    child.stdout?.on('data', (chunk) => take(chunk, 'out'))
+    child.stderr?.on('data', (chunk) => take(chunk, 'err'))
+    child.on('error', (error) => finish(-1, null, String(error?.message || error)))
+    child.on('close', (code, signal) => finish(code, signal))
+
+    if (timeoutMs > 0) {
+      timer = setTimeout(() => {
+        timedOut = true
+        killTree(child)
+      }, Math.max(250, timeoutMs))
+      timer.unref?.()
+    }
+  })
+}
+
+export async function runGit(cfg, args, { timeoutMs = cfg.localTimeoutMs, cwd = cfg.repoPath } = {}) {
+  return runProcess(cfg.gitPath, ['-C', cwd, ...args], { cwd, timeoutMs })
+}
+
+export async function resolveRemote(cfg) {
+  for (const name of [cfg.remote, 'origin', 'cloud']) {
+    if (!name) continue
+    const result = await runGit(cfg, ['remote', 'get-url', name], { timeoutMs: 15000 })
+    if (result.code === 0 && result.stdout.trim()) return name
+  }
+  return ''
+}
+
+export async function inspectRepo(cfg) {
+  const dir = await runGit(cfg, ['rev-parse', '--git-dir'], { timeoutMs: 15000 })
+  if (dir.code !== 0) {
+    return { ok: false, detail: tail(dir.stderr || dir.stdout) || 'not a git repo' }
+  }
+
+  const branchResult = await runGit(cfg, ['branch', '--show-current'], { timeoutMs: 15000 })
+  const branch = branchResult.stdout.trim() || cfg.branch
+  const headResult = await runGit(cfg, ['rev-parse', '--short', 'HEAD'], { timeoutMs: 15000 })
+  const status = await runGit(cfg, ['status', '--porcelain'], { timeoutMs: 20000 })
+  const remote = await resolveRemote(cfg)
+
+  let ahead = 0
+  let behind = 0
+  if (remote) {
+    const counts = await runGit(
+      cfg,
+      ['rev-list', '--left-right', '--count', `HEAD...${remote}/${cfg.branch}`],
+      { timeoutMs: 20000 },
+    )
+    if (counts.code === 0) {
+      const [a, b] = counts.stdout.trim().split(/\s+/).map(Number)
+      ahead = Number.isFinite(a) ? a : 0
+      behind = Number.isFinite(b) ? b : 0
+    }
+  }
+
+  return {
+    ok: true,
+    branch,
+    head: headResult.code === 0 ? headResult.stdout.trim() : '',
+    dirty: status.stdout.trim().length > 0,
+    ahead,
+    behind,
+    remote,
+  }
+}
+
+function failure(phase, started, detail, extra = {}) {
+  return {
+    name: phase,
+    ok: false,
+    durationMs: Date.now() - started,
+    detail: tail(detail),
+    ...extra,
+  }
+}
+
+/**
+ * One local round trip: pull --rebase --autostash, commit dirty files, push.
+ * A rejected push is retried once after fetch + rebase (the non-fast-forward case).
+ */
+export async function syncLocal(cfg) {
+  const started = Date.now()
+  const repo = await inspectRepo(cfg)
+  if (!repo.ok) return failure('local', started, repo.detail)
+  if (!repo.remote) return failure('local', started, `no git remote named ${cfg.remote} (or origin)`)
+
+  const pullArgs = ['pull', '--rebase', '--autostash', repo.remote, cfg.branch]
+  let pull = await runGit(cfg, pullArgs)
+  if (pull.code !== 0) {
+    // A conflicted rebase leaves the work tree in a rebase state; abort so the
+    // user's files stay usable, then report instead of guessing a resolution.
+    await runGit(cfg, ['rebase', '--abort'], { timeoutMs: 15000 })
+    pull = await runGit(cfg, pullArgs)
+    if (pull.code !== 0) {
+      const detail = pull.stderr || pull.stdout
+      return failure('local', started, detail, { phase: 'pull', conflict: /conflict/i.test(detail) })
+    }
+  }
+
+  await runGit(cfg, ['add', '-A'])
+  const status = await runGit(cfg, ['status', '--porcelain'])
+  let committed = false
+  if (status.stdout.trim()) {
+    const nameResult = await runGit(cfg, ['config', 'user.name'], { timeoutMs: 10000 })
+    const emailResult = await runGit(cfg, ['config', 'user.email'], { timeoutMs: 10000 })
+    const commitArgs = ['commit', '-m', `${cfg.commitPrefix}: ${hostname()} ${localIso()}`]
+    if (!nameResult.stdout.trim()) commitArgs.unshift('-c', 'user.name=DSH Memory Sync')
+    if (!emailResult.stdout.trim()) commitArgs.unshift('-c', 'user.email=memory-sync@localhost')
+    const commit = await runGit(cfg, commitArgs)
+    if (commit.code !== 0) return failure('local', started, commit.stderr || commit.stdout, { phase: 'commit' })
+    committed = true
+  }
+
+  let push = await runGit(cfg, ['push', repo.remote, `HEAD:${cfg.branch}`])
+  let retried = false
+  if (push.code !== 0) {
+    retried = true
+    await runGit(cfg, ['fetch', repo.remote], { timeoutMs: 30000 })
+    const rebase = await runGit(cfg, ['rebase', `${repo.remote}/${cfg.branch}`], { timeoutMs: 30000 })
+    if (rebase.code === 0) {
+      push = await runGit(cfg, ['push', repo.remote, `HEAD:${cfg.branch}`])
+    } else {
+      await runGit(cfg, ['rebase', '--abort'], { timeoutMs: 15000 })
+    }
+  }
+  if (push.code !== 0) {
+    const detail = push.stderr || push.stdout
+    return failure('local', started, detail, { phase: 'push', retried, conflict: /conflict/i.test(detail) })
+  }
+
+  const after = await inspectRepo(cfg)
+  return {
+    name: 'local',
+    ok: true,
+    durationMs: Date.now() - started,
+    committed,
+    retried,
+    head: after.ok ? after.head : '',
+    dirty: after.ok ? after.dirty : false,
+  }
+}
+
+/** Phase two: ask the peer to commit and push its side. */
+export async function syncPeer(cfg) {
+  const started = Date.now()
+  if (cfg.mode !== 'peer') {
+    return { name: 'peer', ok: true, skipped: true, durationMs: 0, detail: 'local 模式' }
+  }
+  if (!cfg.peerHost || !cfg.peerUser) {
+    return failure('peer', started, 'peerHost / peerUser 未配置，已跳过云端段')
+  }
+
+  const args = [
+    '-o', 'BatchMode=yes',
+    '-o', 'ConnectTimeout=10',
+    '-o', 'ServerAliveInterval=5',
+    '-o', 'ServerAliveCountMax=2',
+    '-o', 'StrictHostKeyChecking=accept-new',
+  ]
+  if (cfg.peerKeyPath) args.push('-i', cfg.peerKeyPath)
+  args.push(`${cfg.peerUser}@${cfg.peerHost}`, `DSH_SYNC_NAME=${cfg.peerEnvName} ${cfg.peerCommand}`)
+
+  const result = await runProcess('ssh', args, { timeoutMs: cfg.peerTimeoutMs })
+  return {
+    name: 'peer',
+    ok: result.code === 0,
+    exitCode: result.code,
+    durationMs: Date.now() - started,
+    timedOut: result.timedOut,
+    detail: result.code === 0 ? '' : tail(result.stderr || result.stdout),
+  }
+}
+
+/** The three-phase startup handshake: local push -> peer commit/push -> local pull. */
+export async function runStartupChain(cfg) {
+  const phases = []
+  phases.push(await syncLocal(cfg))
+  phases.push(await syncPeer(cfg))
+  phases.push(await syncLocal(cfg))
+  const checked = phases.filter((phase) => !phase.skipped)
+  const ok = checked.every((phase) => phase.ok)
+  return { ok, phases, head: phases[phases.length - 1]?.head || '' }
+}

package/lib/lock.mjs

@@ -0,0 +1,43 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { hostname } from 'node:os'
+import { join } from 'node:path'
+
+const STALE_MS = 15 * 60 * 1000
+
+/**
+ * Cross-process lock built from a directory (atomic on Windows and POSIX).
+ * Returns null when another process holds a fresh lock.
+ */
+export async function acquireLock(lockDir, { staleMs = STALE_MS, now = Date.now() } = {}) {
+  await mkdir(lockDir, { recursive: true }).catch(() => {})
+  const lockPath = join(lockDir, 'sync.lock')
+
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      await mkdir(lockPath)
+      await writeFile(
+        join(lockPath, 'owner.json'),
+        JSON.stringify({ pid: process.pid, host: hostname(), at: now }),
+        'utf8',
+      ).catch(() => {})
+      return {
+        path: lockPath,
+        release: async () => {
+          await rm(lockPath, { recursive: true, force: true }).catch(() => {})
+        },
+      }
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error
+      let stale = false
+      try {
+        const owner = JSON.parse(await readFile(join(lockPath, 'owner.json'), 'utf8'))
+        stale = !Number.isFinite(Number(owner?.at)) || now - Number(owner.at) > staleMs
+      } catch {
+        stale = true
+      }
+      if (!stale) return null
+      await rm(lockPath, { recursive: true, force: true }).catch(() => {})
+    }
+  }
+  return null
+}

package/lib/notify.mjs

@@ -0,0 +1,53 @@
+import { spawn } from 'node:child_process'
+
+function runDetached(command, args) {
+  try {
+    const child = spawn(command, args, {
+      detached: true,
+      windowsHide: true,
+      stdio: 'ignore',
+    })
+    child.unref?.()
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Best-effort failure popup. There is no host notification service, so this
+ * talks to the OS directly. Never throws: a missing notifier must not turn a
+ * sync failure into a crash.
+ */
+export async function notifyFailure({ title, message, logger } = {}) {
+  const safeTitle = String(title || 'DSH memory sync failed')
+  const safeMessage = String(message || 'The startup memory sync did not complete.')
+  try {
+    if (process.platform === 'win32') {
+      const script = [
+        '$w = New-Object -ComObject WScript.Shell;',
+        `$null = $w.Popup('${escapePowerShell(safeMessage)}', 300, '${escapePowerShell(safeTitle)}', 48)`,
+      ].join(' ')
+      runDetached('powershell.exe', [
+        '-NoProfile',
+        '-NonInteractive',
+        '-WindowStyle', 'Hidden',
+        '-Command', script,
+      ])
+      return
+    }
+    if (process.platform === 'darwin') {
+      const escaped = safeMessage.replace(/\\/g, '\\\\').replace(/"/g, '\\"')
+      const escapedTitle = safeTitle.replace(/\\/g, '\\\\').replace(/"/g, '\\"')
+      runDetached('osascript', ['-e', `display dialog "${escaped}" with title "${escapedTitle}" buttons {"OK"} default button 1 with icon caution`])
+      return
+    }
+    runDetached('notify-send', ['--urgency=critical', safeTitle, safeMessage])
+  } catch (error) {
+    logger?.warn?.(`notify failed: ${error?.message || error}`)
+  }
+}
+
+function escapePowerShell(text) {
+  return String(text).replace(/\r?\n/g, ' ').replace(/'/g, "''")
+}

package/lib/state.mjs

@@ -0,0 +1,59 @@
+import { appendFile, mkdir, readFile, rename, stat, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+
+const MAX_LOG_BYTES = 1024 * 1024
+
+export async function ensureDir(dir) {
+  await mkdir(dir, { recursive: true })
+}
+
+export async function readJson(file, fallback = null) {
+  try {
+    return JSON.parse(await readFile(file, 'utf8'))
+  } catch {
+    return fallback
+  }
+}
+
+/** Write JSON via a temp file + rename so a crash never leaves half a file. */
+export async function writeJsonAtomic(file, value) {
+  const dir = dirname(file)
+  await mkdir(dir, { recursive: true })
+  const tmp = join(dir, `.${Date.now()}.${process.pid}.tmp`)
+  await writeFile(tmp, JSON.stringify(value, null, 2), 'utf8')
+  await rename(tmp, file)
+}
+
+/** Keep the log bounded: one previous generation is enough. */
+export async function rotateLog(file, maxBytes = MAX_LOG_BYTES) {
+  try {
+    const info = await stat(file)
+    if (info.size > maxBytes) await rename(file, `${file}.1`)
+  } catch {
+    // no log yet
+  }
+}
+
+/**
+ * Tiny logger: console + best-effort file. Never throws, never blocks a turn.
+ */
+export function createLogger({ dir, tag = 'memory-sync' }) {
+  const file = join(dir, 'sync.log')
+  const write = (level, message) => {
+    const line = `${new Date().toISOString()} [${tag}] ${level} ${message}\n`
+    try {
+      if (level === 'error') console.error(line.trimEnd())
+      else if (level === 'warn') console.warn(line.trimEnd())
+      else console.log(line.trimEnd())
+    } catch {
+      // console can be closed in a packaged app
+    }
+    void appendFile(file, line).catch(() => {})
+  }
+  return {
+    file,
+    info: (message) => write('info', message),
+    warn: (message) => write('warn', message),
+    error: (message) => write('error', message),
+  }
+}

package/lib/status.mjs

@@ -0,0 +1,70 @@
+import { mkdir, rename, writeFile } from 'node:fs/promises'
+import { hostname, platform, release, userInfo } from 'node:os'
+import { dirname, join } from 'node:path'
+
+function pad2(n) {
+  return String(n).padStart(2, '0')
+}
+
+/** Local wall-clock stamp: `YYYY-MM-DD HH:mm:ss`. */
+export function stampLocal(date = new Date()) {
+  const d = date instanceof Date ? date : new Date(date)
+  if (Number.isNaN(d.getTime())) return '-'
+  return (
+    `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ` +
+    `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`
+  )
+}
+
+/** The process start time, derived from Node's uptime (no extra state needed). */
+export function processStartedAt(now = Date.now()) {
+  return new Date(now - process.uptime() * 1000)
+}
+
+function currentUser() {
+  try {
+    return userInfo().username || process.env.USERNAME || process.env.USER || 'unknown'
+  } catch {
+    return process.env.USERNAME || process.env.USER || 'unknown'
+  }
+}
+
+/**
+ * Render the human-readable PC snapshot. Kept to the same shape the old
+ * watcher wrote, so the cloud-side AGENTS.md can keep reading `状态刷新`.
+ */
+export function renderStatus({ now = new Date(), startedAt } = {}) {
+  const started = startedAt instanceof Date ? startedAt : processStartedAt(now.getTime())
+  return [
+    '# 电脑侧状态（自动生成，勿手改）',
+    '',
+    `- 主机名：${hostname()}`,
+    `- 用户：${currentUser()}`,
+    `- 系统：${platform()} ${release()}`,
+    `- DSH 本次启动：${stampLocal(started)}`,
+    `- 状态刷新：${stampLocal(now)}`,
+    '',
+  ].join('\n')
+}
+
+/**
+ * Write the snapshot atomically. Never throws: a failed snapshot must not
+ * block the memory sync itself.
+ */
+export async function writeStatusFile({ statusFile, logger, now = new Date(), startedAt } = {}) {
+  const file = String(statusFile || '').trim()
+  if (!file) return false
+  try {
+    const dir = dirname(file)
+    await mkdir(dir, { recursive: true })
+    const text = renderStatus({ now, startedAt })
+    const tmp = join(dir, `.${Date.now()}.${process.pid}.status.tmp`)
+    await writeFile(tmp, text, 'utf8')
+    await rename(tmp, file)
+    logger?.info?.(`status snapshot written: ${file}`)
+    return true
+  } catch (error) {
+    logger?.warn?.(`status snapshot failed: ${error?.message || error}`)
+    return false
+  }
+}

package/lib/sync.mjs

@@ -0,0 +1,193 @@
+import { join } from 'node:path'
+
+import { acquireLock } from './lock.mjs'
+import { inspectRepo, runStartupChain } from './git.mjs'
+import { notifyFailure } from './notify.mjs'
+import { readJson, writeJsonAtomic } from './state.mjs'
+import { writeStatusFile } from './status.mjs'
+
+/**
+ * Owns the startup timer, the one-at-a-time lock, retry/self-heal timers and
+ * the last-run record. Pure Node; no host services besides the injected logger.
+ */
+export function createSyncRuntime({ cfg, logger }) {
+  const lastRunFile = join(cfg.stateDir, 'last-run.json')
+  const lockDir = join(cfg.stateDir, 'lock')
+
+  let startupTimer = null
+  let retryTimer = null
+  let healTimer = null
+  let running = null
+  let lastRun = null
+  let notified = false
+  let disposed = false
+
+  const log = (level, message) => logger?.[level]?.(message)
+
+  function clearTimers() {
+    for (const timer of [startupTimer, retryTimer, healTimer]) {
+      if (timer) clearTimeout(timer)
+    }
+    startupTimer = null
+    retryTimer = null
+    healTimer = null
+  }
+
+  async function execute(trigger) {
+    if (disposed) return { ok: false, skipped: true, trigger, reason: 'disposed' }
+    if (running) return running
+
+    running = (async () => {
+      const lock = await acquireLock(lockDir)
+      if (!lock) return { ok: false, locked: true, trigger, at: new Date().toISOString() }
+      try {
+        log('info', `sync start (${trigger}) mode=${cfg.mode}`)
+        if (cfg.statusFile) {
+          await writeStatusFile({ statusFile: cfg.statusFile, logger })
+        }
+        const result = await runStartupChain(cfg)
+        const run = { ...result, trigger, at: new Date().toISOString() }
+        lastRun = run
+        await writeJsonAtomic(lastRunFile, run).catch(() => {})
+        log(
+          result.ok ? 'info' : 'warn',
+          `sync ${result.ok ? 'ok' : 'FAILED'} (${trigger}) head=${result.head || '-'}`,
+        )
+        return run
+      } catch (error) {
+        const run = {
+          ok: false,
+          phases: [],
+          trigger,
+          at: new Date().toISOString(),
+          error: String(error?.message || error),
+        }
+        lastRun = run
+        log('error', `sync crashed (${trigger}): ${run.error}`)
+        return run
+      } finally {
+        await lock.release().catch(() => {})
+        running = null
+      }
+    })()
+
+    return running
+  }
+
+  function finalFailure(run) {
+    if (cfg.notifyOnFailure && !notified) {
+      notified = true
+      const failed = (run.phases || [])
+        .filter((phase) => !phase.ok && !phase.skipped)
+        .map((phase) => phase.name)
+        .join('/')
+      const detail = failed || run.error || 'unknown'
+      void notifyFailure({
+        title: 'DSH 记忆同步失败',
+        message: `三段同步没有完成（${detail}）。详见 ${logger?.file || cfg.stateDir}。`,
+        logger,
+      })
+    }
+    armHeal()
+  }
+
+  function armRetry(run) {
+    if (disposed || cfg.retryDelaySec <= 0) {
+      finalFailure(run)
+      return
+    }
+    if (retryTimer) clearTimeout(retryTimer)
+    retryTimer = setTimeout(() => {
+      retryTimer = null
+      void execute('retry').then((next) => afterRun(next, 'retry'))
+    }, cfg.retryDelaySec * 1000)
+    retryTimer.unref?.()
+  }
+
+  function armHeal() {
+    if (disposed || cfg.healIntervalSec <= 0) return
+    if (healTimer) clearTimeout(healTimer)
+    healTimer = setTimeout(() => {
+      healTimer = null
+      void execute('heal').then((next) => {
+        if (next.ok) {
+          notified = false
+          return
+        }
+        armHeal()
+      })
+    }, cfg.healIntervalSec * 1000)
+    healTimer.unref?.()
+  }
+
+  function afterRun(run, trigger) {
+    if (!run || run.skipped) return
+    if (run.locked) {
+      log('info', 'another sync holds the lock; will retry later')
+      armHeal()
+      return
+    }
+    if (run.ok) {
+      notified = false
+      return
+    }
+    if (trigger === 'startup') {
+      armRetry(run)
+      return
+    }
+    finalFailure(run)
+  }
+
+  function scheduleStartup() {
+    if (!cfg.enabled || !cfg.runOnStartup) {
+      log('info', 'startup sync disabled by config')
+      return
+    }
+    if (process.uptime() > cfg.startupGraceSec) {
+      log('info', `plugin mounted after ${Math.round(process.uptime())}s; treating as a reload, not a boot`)
+      return
+    }
+    // Let the app finish booting before touching git or ssh.
+    startupTimer = setTimeout(() => {
+      startupTimer = null
+      void execute('startup').then((run) => afterRun(run, 'startup'))
+    }, 2500)
+    startupTimer.unref?.()
+  }
+
+  async function run(trigger = 'manual') {
+    return execute(trigger)
+  }
+
+  async function status() {
+    const stored = lastRun || (await readJson(lastRunFile, null))
+    const repo = await inspectRepo(cfg)
+    return {
+      ok: Boolean(repo.ok),
+      repo: repo.ok
+        ? {
+            path: cfg.repoPath,
+            branch: repo.branch,
+            head: repo.head,
+            dirty: repo.dirty,
+            ahead: repo.ahead,
+            behind: repo.behind,
+            remote: repo.remote,
+          }
+        : { path: cfg.repoPath, error: repo.detail || 'not a git repo' },
+      lastRun: stored,
+      running: Boolean(running),
+      enabled: cfg.enabled,
+      mode: cfg.mode,
+      peerConfigured: Boolean(cfg.peerHost && cfg.peerUser),
+      logFile: logger?.file || '',
+    }
+  }
+
+  function dispose() {
+    disposed = true
+    clearTimers()
+  }
+
+  return { scheduleStartup, run, status, dispose }
+}