Add advanced synchronize dialog and APK tooling

2026-03-29 21:38:46 -07:00
parent 6e2760c514
commit 96ec583c7e
11 changed files with 1154 additions and 80 deletions
@@ -141,6 +141,64 @@ func (m *Manager) Synchronize() error {
 	}
 }

+func (m *Manager) SynchronizeFromLocal(path string) error {
+	other, _, err := loadLocalSource(path, m.key)
+	if err != nil {
+		return err
+	}
+	merged, err := m.mergedWithPeer(other)
+	if err != nil {
+		return err
+	}
+	return m.persistMergedToCurrentSource(merged)
+}
+
+func (m *Manager) SynchronizeToLocal(path string) error {
+	other, config, err := loadLocalSourceOrEmpty(path, m.key)
+	if err != nil {
+		return err
+	}
+	merged, err := m.mergedWithPeer(other)
+	if err != nil {
+		return err
+	}
+	if err := saveModelToLocal(path, merged, m.key, configOrCurrent(config, m.config)); err != nil {
+		return err
+	}
+	m.model = merged
+	m.locked = false
+	return nil
+}
+
+func (m *Manager) SynchronizeFromRemote(client webdav.Client, path string) error {
+	other, _, _, err := loadRemoteSource(client, path, m.key)
+	if err != nil {
+		return err
+	}
+	merged, err := m.mergedWithPeer(other)
+	if err != nil {
+		return err
+	}
+	return m.persistMergedToCurrentSource(merged)
+}
+
+func (m *Manager) SynchronizeToRemote(client webdav.Client, path string) error {
+	other, config, version, err := loadRemoteSourceOrEmpty(client, path, m.key)
+	if err != nil {
+		return err
+	}
+	merged, err := m.mergedWithPeer(other)
+	if err != nil {
+		return err
+	}
+	if err := saveModelToRemote(client, path, merged, m.key, configOrCurrent(config, m.config), version); err != nil {
+		return err
+	}
+	m.model = merged
+	m.locked = false
+	return nil
+}
+
 func (m *Manager) SaveAs(path string) error {
 	if err := m.saveToPath(path); err != nil {
 		return err
@@ -351,6 +409,61 @@ func (m *Manager) baseModel() (vault.Model, error) {
 	return model, nil
 }

+func (m *Manager) mergedWithPeer(other vault.Model) (vault.Model, error) {
+	current, err := m.currentModelForPersistence()
+	if err != nil {
+		return vault.Model{}, err
+	}
+	return mergePeerModels(current, other), nil
+}
+
+func (m *Manager) persistMergedToCurrentSource(merged vault.Model) error {
+	switch {
+	case m.remoteClient != nil && m.remotePath != "":
+		if err := saveModelToRemote(*m.remoteClient, m.remotePath, merged, m.key, configOrCurrent(m.config, nil), m.remoteVersion); err != nil {
+			return err
+		}
+		return m.reloadCurrentRemote(merged)
+	case m.path != "":
+		if err := saveModelToLocal(m.path, merged, m.key, configOrCurrent(m.config, nil)); err != nil {
+			return err
+		}
+		return m.reloadCurrentLocal(merged)
+	default:
+		return ErrNoPath
+	}
+}
+
+func (m *Manager) reloadCurrentLocal(merged vault.Model) error {
+	encoded, err := encodeModelWithConfig(merged, m.key, configOrCurrent(m.config, nil))
+	if err != nil {
+		return err
+	}
+	m.model = merged
+	m.encoded = encoded
+	m.locked = false
+	return nil
+}
+
+func (m *Manager) reloadCurrentRemote(merged vault.Model) error {
+	encoded, err := encodeModelWithConfig(merged, m.key, configOrCurrent(m.config, nil))
+	if err != nil {
+		return err
+	}
+	content, version, err := m.remoteClient.Open(m.remotePath)
+	if err != nil {
+		return fmt.Errorf("reopen remote %s after synchronize: %w", m.remotePath, err)
+	}
+	m.model = merged
+	m.encoded = encoded
+	m.remoteVersion = version
+	m.locked = false
+	if len(content) > 0 {
+		m.encoded = content
+	}
+	return nil
+}
+
 func mergeModels(base, local, latest vault.Model) vault.Model {
 	merged := latest
 	merged.Entries = mergeEntrySet(base.Entries, local.Entries, latest.Entries)
@@ -360,6 +473,15 @@ func mergeModels(base, local, latest vault.Model) vault.Model {
 	return merged
 }

+func mergePeerModels(primary, secondary vault.Model) vault.Model {
+	merged := cloneModel(secondary)
+	merged.Entries = mergePeerEntrySet(primary.Entries, secondary.Entries)
+	merged.Templates = mergePeerEntrySet(primary.Templates, secondary.Templates)
+	merged.RecycleBin = mergePeerEntrySet(primary.RecycleBin, secondary.RecycleBin)
+	merged.Groups = mergePeerGroups(primary.Groups, secondary.Groups)
+	return merged
+}
+
 func mergeEntrySet(base, local, latest []vault.Entry) []vault.Entry {
 	baseByID := mapEntries(base)
 	localByID := mapEntries(local)
@@ -416,6 +538,33 @@ func mergeConflictedEntry(current, latest vault.Entry) vault.Entry {
 	return current
 }

+func mergePeerEntrySet(primary, secondary []vault.Entry) []vault.Entry {
+	outByID := mapEntries(secondary)
+	for _, item := range primary {
+		if existing, ok := outByID[item.ID]; ok && !sameEntryVersion(item, existing) {
+			outByID[item.ID] = mergeConflictedEntry(cloneEntry(item), existing)
+			continue
+		}
+		outByID[item.ID] = cloneEntry(item)
+	}
+
+	out := make([]vault.Entry, 0, len(outByID))
+	for _, item := range outByID {
+		out = append(out, item)
+	}
+	slices.SortFunc(out, func(a, b vault.Entry) int {
+		switch {
+		case a.Title < b.Title:
+			return -1
+		case a.Title > b.Title:
+			return 1
+		default:
+			return 0
+		}
+	})
+	return out
+}
+
 func mapEntries(entries []vault.Entry) map[string]vault.Entry {
 	out := make(map[string]vault.Entry, len(entries))
 	for _, item := range entries {
@@ -482,6 +631,20 @@ func cloneHistory(history []vault.Entry) []vault.Entry {
 	return out
 }

+func cloneModel(model vault.Model) vault.Model {
+	out := model
+	out.Entries = cloneHistory(model.Entries)
+	out.Templates = cloneHistory(model.Templates)
+	out.RecycleBin = cloneHistory(model.RecycleBin)
+	if len(model.Groups) > 0 {
+		out.Groups = make([][]string, len(model.Groups))
+		for i := range model.Groups {
+			out.Groups[i] = slices.Clone(model.Groups[i])
+		}
+	}
+	return out
+}
+
 func sameEntryVersion(a, b vault.Entry) bool {
 	return entriesEqual(a, b)
 }
@@ -526,6 +689,119 @@ func mergeGroups(base, local, latest [][]string) [][]string {
 	return out
 }

+func mergePeerGroups(primary, secondary [][]string) [][]string {
+	set := map[string][]string{}
+	for _, path := range secondary {
+		set[pathKey(path)] = slices.Clone(path)
+	}
+	for _, path := range primary {
+		set[pathKey(path)] = slices.Clone(path)
+	}
+	out := make([][]string, 0, len(set))
+	for _, path := range set {
+		out = append(out, path)
+	}
+	slices.SortFunc(out, func(a, b []string) int {
+		joinedA := pathKey(a)
+		joinedB := pathKey(b)
+		switch {
+		case joinedA < joinedB:
+			return -1
+		case joinedA > joinedB:
+			return 1
+		default:
+			return 0
+		}
+	})
+	return out
+}
+
+func loadLocalSource(path string, key vault.MasterKey) (vault.Model, *vault.KDBXConfig, error) {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return vault.Model{}, nil, fmt.Errorf("open %s for synchronize: %w", path, err)
+	}
+	model, config, err := vault.LoadKDBXWithConfig(bytes.NewReader(content), key)
+	if err != nil {
+		return vault.Model{}, nil, fmt.Errorf("decode %s for synchronize: %w", path, err)
+	}
+	return model, config, nil
+}
+
+func loadLocalSourceOrEmpty(path string, key vault.MasterKey) (vault.Model, *vault.KDBXConfig, error) {
+	model, config, err := loadLocalSource(path, key)
+	if err == nil {
+		return model, config, nil
+	}
+	if errors.Is(err, os.ErrNotExist) || strings.Contains(err.Error(), os.ErrNotExist.Error()) {
+		return vault.Model{}, nil, nil
+	}
+	return vault.Model{}, nil, err
+}
+
+func loadRemoteSource(client webdav.Client, path string, key vault.MasterKey) (vault.Model, *vault.KDBXConfig, webdav.Version, error) {
+	content, version, err := client.Open(path)
+	if err != nil {
+		return vault.Model{}, nil, webdav.Version{}, fmt.Errorf("open remote %s for synchronize: %w", path, err)
+	}
+	model, config, err := vault.LoadKDBXWithConfig(bytes.NewReader(content), key)
+	if err != nil {
+		return vault.Model{}, nil, webdav.Version{}, fmt.Errorf("decode remote %s for synchronize: %w", path, err)
+	}
+	return model, config, version, nil
+}
+
+func loadRemoteSourceOrEmpty(client webdav.Client, path string, key vault.MasterKey) (vault.Model, *vault.KDBXConfig, webdav.Version, error) {
+	model, config, version, err := loadRemoteSource(client, path, key)
+	if err == nil {
+		return model, config, version, nil
+	}
+	if strings.Contains(err.Error(), "unexpected status 404") {
+		return vault.Model{}, nil, webdav.Version{}, nil
+	}
+	return vault.Model{}, nil, webdav.Version{}, err
+}
+
+func encodeModelWithConfig(model vault.Model, key vault.MasterKey, config *vault.KDBXConfig) ([]byte, error) {
+	var encoded bytes.Buffer
+	if err := vault.SaveKDBXWithConfigAndKey(&encoded, model, key, config); err != nil {
+		return nil, fmt.Errorf("encode synchronized vault: %w", err)
+	}
+	return encoded.Bytes(), nil
+}
+
+func saveModelToLocal(path string, model vault.Model, key vault.MasterKey, config *vault.KDBXConfig) error {
+	encoded, err := encodeModelWithConfig(model, key, config)
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+		return fmt.Errorf("create parent dir for %s: %w", path, err)
+	}
+	if err := os.WriteFile(path, encoded, 0o600); err != nil {
+		return fmt.Errorf("write synchronized %s: %w", path, err)
+	}
+	return nil
+}
+
+func saveModelToRemote(client webdav.Client, path string, model vault.Model, key vault.MasterKey, config *vault.KDBXConfig, version webdav.Version) error {
+	encoded, err := encodeModelWithConfig(model, key, config)
+	if err != nil {
+		return err
+	}
+	if _, err := client.Save(path, bytes.NewReader(encoded), version); err != nil {
+		return fmt.Errorf("save synchronized remote %s: %w", path, err)
+	}
+	return nil
+}
+
+func configOrCurrent(config, fallback *vault.KDBXConfig) *vault.KDBXConfig {
+	if config != nil {
+		return config
+	}
+	return fallback
+}
+
 func pathKey(path []string) string {
 	return strings.Join(path, "\x00")
 }