@code_tin/dsh-sync 0.0.0-stage → 0.2.0

package/index.js

@@ -0,0 +1,197 @@
+/**
+ * Host half of `dsh-sync`.
+ *
+ * Responsibilities:
+ * - own the git mirror engine (`lib/sync.js`);
+ * - register the human `/sync` command;
+ * - expose the same operations to the Settings page through a Remote service.
+ *
+ * The browser half only renders the settings page; every operation lives here
+ * so the command line and the page cannot disagree.
+ */
+import os from 'node:os'
+import path from 'node:path'
+import { SessionGitSync, validateBranch } from './lib/sync.js'
+import { AutoPushScheduler } from './lib/auto.js'
+import { registerRemoteService } from './lib/remote.js'
+
+const SERVICE_KEY = 'dshSync'
+const NAMESPACE = 'dsh-sync'
+
+/** The command needs the registry; without it the plugin has nothing to do. */
+export const inject = ['commands']
+
+function formatTime(value) {
+  if (!value) return '无'
+  const date = new Date(value)
+  if (Number.isNaN(date.getTime())) return value
+  return date.toLocaleString('zh-CN', { hour12: false })
+}
+
+function formatStatus(status) {
+  const lines = [
+    'DSH 会话 Git 同步',
+    `远程仓库: ${status.remote || '（未配置，在 设置 → 插件 → 会话 Git 同步 中填写）'}`,
+    `分支: ${status.branch}`,
+    `本地会话: ${status.local.sessions} 个会话 / ${status.local.files} 个文件`,
+    `镜像仓库: ${status.mirror.initialized
+      ? `${status.mirror.sessions} 个会话 / ${status.mirror.files} 个文件`
+      : '尚未初始化（首次 /sync push 时创建）'}`,
+  ]
+  if (status.autoPush) {
+    if (!status.remote) {
+      lines.push(`自动同步: 已开启（每 ${status.autoPushIntervalMinutes} 分钟），但尚未配置远程仓库`)
+    } else {
+      const next = status.autoPushNextAt
+        ? `，下次 ${formatTime(new Date(status.autoPushNextAt).toISOString())}`
+        : ''
+      lines.push(`自动同步: 每 ${status.autoPushIntervalMinutes} 分钟推送一次${next}`)
+    }
+  } else {
+    lines.push('自动同步: 已关闭（在设置页开启）')
+  }
+  if (status.state.lastPushAt) {
+    lines.push(`上次推送: ${formatTime(status.state.lastPushAt)} ${status.state.lastPushOk === false ? '失败' : '成功'}`)
+  }
+  if (status.state.lastAutoPushAt) {
+    lines.push(`上次自动推送: ${formatTime(status.state.lastAutoPushAt)} ${status.state.lastAutoPushOk === false ? '失败' : '成功'}`)
+  }
+  if (status.state.lastPullAt) {
+    lines.push(`上次拉取: ${formatTime(status.state.lastPullAt)} ${status.state.lastPullOk === false ? '失败' : '成功'}`)
+  }
+  if (status.state.lastError) lines.push(`最近错误: ${status.state.lastError}`)
+  lines.push('用法: /sync | /sync pull | /sync push')
+  return lines.join('\n')
+}
+
+function success(text) {
+  return { kind: 'success', text }
+}
+
+function failure(text) {
+  return { kind: 'error', text }
+}
+
+export function apply(ctx) {
+  const home = process.env.DSH_HOME || path.join(os.homedir(), '.dsh')
+  const sync = new SessionGitSync({
+    home,
+    logger: ctx.logger,
+    flush: () => ctx.get('sessionPersistence')?.flush(),
+  })
+  const scheduler = new AutoPushScheduler({ sync, logger: ctx.logger })
+
+  /** Status plus the live timer state the page and command both display. */
+  const readStatus = async () => ({
+    ...(await sync.status()),
+    autoPushNextAt: scheduler.nextAt,
+    autoPushRunning: scheduler.running,
+  })
+
+  ctx.effect(() => {
+    scheduler.start()
+    return () => scheduler.stop()
+  }, 'dsh-sync: auto push timer')
+
+  ctx.effect(() => ctx.commands.register({
+    name: 'sync',
+    description: '在设备之间通过 Git 同步 DSH 会话：status / pull / push',
+    input: { hint: 'status | pull | push' },
+    async handler(invocation) {
+      const argument = String(invocation.rawInput ?? '').trim().toLowerCase()
+      try {
+        if (argument === '' || argument === 'status') {
+          return success(formatStatus(await readStatus()))
+        }
+        if (argument === 'help') {
+          return success([
+            '/sync          查看同步状态',
+            '/sync pull     拉取远程会话到本地（不覆盖本地已有会话）',
+            '/sync push     把本地会话推送到 Git 远程仓库',
+            '/sync test     测试已保存的 Git 地址',
+          ].join('\n'))
+        }
+        if (argument === 'pull') {
+          const result = await sync.pull()
+          if (result.ok === false) return failure(`拉取失败：${result.message}`)
+          return success(
+            `拉取完成：新增 ${result.addedSessions} 个会话（${result.addedFiles} 个文件），`
+            + `跳过 ${result.skippedFiles} 个本地已存在的文件。`,
+          )
+        }
+        if (argument === 'push') {
+          const result = await sync.push()
+          if (result.ok === false) return failure(`推送失败：${result.message}`)
+          const text = result.pushed
+            ? `推送完成：${result.sessions} 个会话（${result.files} 个文件）。`
+            : '推送完成：远程已是最新，无需更新。'
+          return success(result.warning ? `${text}\n注意：${result.warning}` : text)
+        }
+        if (argument === 'test') {
+          const settings = await sync.readSettings()
+          if (!settings.remote) return failure('尚未配置 Git 地址，请先在设置页面填写。')
+          const result = await sync.test(settings.remote)
+          if (result.ok === false) return failure(`连接失败：${result.message}`)
+          return success(`连接成功：远程有 ${result.branches.length} 个分支。`)
+        }
+        return failure(`未知参数 “${argument}”。用法: /sync | /sync pull | /sync push`)
+      } catch (error) {
+        return failure(`同步失败：${error instanceof Error ? error.message : String(error)}`)
+      }
+    },
+  }), 'dsh-sync: /sync command')
+
+  const withStatus = async (result) => {
+    let status
+    try {
+      status = await readStatus()
+    } catch {
+      status = undefined
+    }
+    return status === undefined ? result : { ...result, status }
+  }
+
+  const dispose = registerRemoteService({
+    ctx,
+    serviceKey: SERVICE_KEY,
+    namespace: NAMESPACE,
+    methods: [
+      {
+        method: 'status',
+        implementation: function status() {
+          return readStatus()
+        },
+      },
+      {
+        method: 'save',
+        implementation: async function save(remote, branch, autoPush, autoPushIntervalMinutes) {
+          const normalizedBranch = validateBranch(branch)
+          const result = await sync.save(remote, normalizedBranch, autoPush, autoPushIntervalMinutes)
+          await scheduler.refresh()
+          return withStatus(result)
+        },
+      },
+      {
+        method: 'test',
+        implementation: async function test(remote) {
+          return sync.test(remote)
+        },
+      },
+      {
+        method: 'pull',
+        implementation: async function pull() {
+          return withStatus(await sync.pull())
+        },
+      },
+      {
+        method: 'push',
+        implementation: async function push() {
+          return withStatus(await sync.push())
+        },
+      },
+    ],
+  })
+  ctx.effect(() => dispose, 'dsh-sync: remote service')
+
+  ctx.logger?.info?.(`dsh-sync ready: sessions=${sync.sessionsRoot}`)
+}

package/lib/auto.js

@@ -0,0 +1,115 @@
+/**
+ * Periodic auto-push for `dsh-sync`.
+ *
+ * The host owns one scheduler; it re-reads settings before every run so the
+ * checkbox and interval in the Settings page take effect without a restart.
+ * Each run is a normal `push`, so it shares the engine's queue and state
+ * recording with manual pushes.
+ */
+import { DEFAULT_AUTO_PUSH_INTERVAL_MINUTES } from './sync.js'
+
+export class AutoPushScheduler {
+  constructor({ sync, logger, setTimer, clearTimer } = {}) {
+    if (!sync) throw new Error('AutoPushScheduler needs a sync engine.')
+    this.sync = sync
+    this.logger = logger
+    this.setTimer = setTimer ?? ((fn, ms) => setTimeout(fn, ms))
+    this.clearTimer = clearTimer ?? ((id) => clearTimeout(id))
+    this.stopped = true
+    this.timer = undefined
+    this.nextAt = null
+    this.running = false
+  }
+
+  /** Begin watching settings; the first run happens one interval from now. */
+  start() {
+    if (!this.stopped) return
+    this.stopped = false
+    void this.arm()
+  }
+
+  stop() {
+    this.stopped = true
+    this.cancel()
+    this.nextAt = null
+  }
+
+  /** Re-arm after settings changed (enable/disable/interval). */
+  refresh() {
+    if (this.stopped) return Promise.resolve()
+    return this.arm()
+  }
+
+  cancel() {
+    if (this.timer !== undefined) {
+      this.clearTimer(this.timer)
+      this.timer = undefined
+    }
+  }
+
+  async arm() {
+    this.cancel()
+    this.nextAt = null
+    if (this.stopped) return
+    let settings
+    try {
+      settings = await this.sync.readSettings()
+    } catch (error) {
+      this.logger?.warn?.(`dsh-sync: cannot read settings for auto-sync: ${describeError(error)}`)
+      return
+    }
+    if (this.stopped) return
+    if (!settings.autoPush || settings.remote === '') return
+    const minutes = settings.autoPushIntervalMinutes || DEFAULT_AUTO_PUSH_INTERVAL_MINUTES
+    const delay = minutes * 60_000
+    this.nextAt = Date.now() + delay
+    this.timer = this.setTimer(() => {
+      void this.tick()
+    }, delay)
+    // A pending auto-push must never keep the host process alive.
+    this.timer?.unref?.()
+  }
+
+  async tick() {
+    this.timer = undefined
+    this.nextAt = null
+    if (this.stopped) return
+    if (this.running) {
+      void this.arm()
+      return
+    }
+    let settings
+    try {
+      settings = await this.sync.readSettings()
+    } catch (error) {
+      this.logger?.warn?.(`dsh-sync: cannot read settings for auto-sync: ${describeError(error)}`)
+      void this.arm()
+      return
+    }
+    if (!settings.autoPush || settings.remote === '') return
+
+    this.running = true
+    let outcome = { ok: false }
+    try {
+      const result = await this.sync.push()
+      outcome = result
+      if (result?.ok === false) {
+        this.logger?.warn?.(`dsh-sync: auto push skipped: ${result.message ?? 'not configured'}`)
+      }
+    } catch (error) {
+      this.logger?.warn?.(`dsh-sync: auto push failed: ${describeError(error)}`)
+    } finally {
+      this.running = false
+      if (!this.stopped) void this.arm()
+    }
+    try {
+      await this.sync.recordAutoPush(outcome)
+    } catch (error) {
+      this.logger?.warn?.(`dsh-sync: cannot record auto push: ${describeError(error)}`)
+    }
+  }
+}
+
+function describeError(error) {
+  return error instanceof Error ? error.message : String(error)
+}

package/lib/remote.js

@@ -0,0 +1,62 @@
+/**
+ * Minimal host-side Remote service for the browser half.
+ *
+ * The Harness Web client reaches a plugin's host code through the Typert
+ * gateway (`ctx.connection.rpc.call('/api', '<namespace>/<method>', { args })`).
+ * The gateway only routes to a registered Cordis service that carries a
+ * `typertRemote` binding and the source-mode method descriptor on its
+ * prototype. Building that by hand keeps this plugin dependency-free: it uses
+ * only `ctx.reflect.provide` (a Cordis core service) and the documented
+ * descriptor key.
+ *
+ * A method is addressed as `<namespace>/<method>`, and the gateway spreads the
+ * request's `args` object across the implementation's parameters, matching
+ * names exactly. Keep one parameter per wire field.
+ */
+
+/** Descriptor key the gateway reads off the service prototype. */
+const REMOTE_METHODS = '@deepseek-ai/dsh-typert-protocol/remote-methods'
+
+/**
+ * Register one Remote service.
+ *
+ * @param {object} deps
+ * @param {import('@deepseek-ai/cordis').Context} deps.ctx owning context
+ * @param {string} deps.serviceKey Cordis service key
+ * @param {string} deps.namespace wire namespace used in the endpoint
+ * @param {Array<{ method: string, implementation: Function }>} deps.methods
+ * @returns {() => void} disposer that unregisters the service
+ */
+export function registerRemoteService({ ctx, serviceKey, namespace, methods }) {
+  const service = {}
+  Object.defineProperty(service, 'ctx', { value: ctx, enumerable: false, writable: true })
+  Object.defineProperty(service, 'name', { value: serviceKey, enumerable: false, writable: true })
+  Object.defineProperty(service, 'typertRemote', {
+    value: Object.freeze({ service, serviceKey, namespace }),
+    enumerable: false,
+  })
+
+  const prototype = {}
+  for (const { method, implementation } of methods) {
+    Object.defineProperty(prototype, method, {
+      value: implementation,
+      enumerable: false,
+      writable: false,
+    })
+  }
+  Object.defineProperty(prototype, REMOTE_METHODS, {
+    value: Object.freeze({
+      version: 1,
+      methods: Object.freeze(
+        methods.map(({ method }) => Object.freeze({
+          method,
+          invocation: Object.freeze({ kind: 'direct' }),
+        })),
+      ),
+    }),
+    enumerable: false,
+  })
+  Object.setPrototypeOf(service, prototype)
+
+  return ctx.reflect.provide(serviceKey, service)
+}