Remove D1 and add SQLite GitHub backup for HF

.env.example

@@ -74,11 +74,24 @@ WEBDAV_PASSWORD=
 WEBDAV_BEARER_TOKEN=
 WEBDAV_ROOT_PATH=
 
-# GitHub bootstrap
-GITHUB_REPO=
-GITHUB_TOKEN=
-GITHUB_MODE=releases
-GITHUB_PREFIX=
-GITHUB_RELEASE_TAG=
-GITHUB_BRANCH=
-GITHUB_API_BASE=https://api.github.com
+# GitHub bootstrap
+GITHUB_REPO=
+GITHUB_TOKEN=
+GITHUB_MODE=releases
+GITHUB_PREFIX=
+GITHUB_RELEASE_TAG=
+GITHUB_BRANCH=
+GITHUB_API_BASE=https://api.github.com
+
+# SQLite backup to GitHub (recommended for HuggingFace Spaces without persistent disk)
+# Auto-enables when both repo and token are set, or set SQLITE_BACKUP_ENABLED=true explicitly.
+SQLITE_BACKUP_ENABLED=
+SQLITE_BACKUP_GITHUB_REPO=
+SQLITE_BACKUP_GITHUB_TOKEN=
+SQLITE_BACKUP_GITHUB_BRANCH=main
+SQLITE_BACKUP_PATH=backups/k-vault.db
+SQLITE_BACKUP_INTERVAL_MS=15000
+SQLITE_BACKUP_IDLE_MS=120000
+SQLITE_BACKUP_GIT_LFS=true
+SQLITE_BACKUP_GIT_USER_NAME=K-Vault Backup Bot
+SQLITE_BACKUP_GIT_USER_EMAIL=k-vault-backup@users.noreply.github.com

Dockerfile

@@ -9,7 +9,7 @@ RUN npm ci --omit=dev
 FROM node:22-alpine
 WORKDIR /app
 
-RUN apk add --no-cache nginx
+RUN apk add --no-cache nginx git git-lfs
 
 COPY --from=api-deps /app/server/node_modules /app/server/node_modules
 COPY server /app/server

HUGGINGFACE-SPACES.md

@@ -9,11 +9,11 @@ To make Spaces deployment possible, this repository now includes a root-level `D
 
 ## Recommended Space Setup
 
-1. Create a new **Docker Space**.
-2. Use the root `Dockerfile`.
-3. Copy the contents of `README-HF-SPACES.md` to the root `README.md` in your Space repository.
-4. Add the runtime secrets and variables listed below.
-5. If your Space supports persistent storage, keep it enabled so SQLite data survives restarts.
+1. Create a new **Docker Space**.
+2. Use the root `Dockerfile`.
+3. Copy the contents of `README-HF-SPACES.md` to the root `README.md` in your Space repository.
+4. Add the runtime secrets and variables listed below.
+5. Configure SQLite GitHub backup if you need data to survive Space restarts.
 
 ## Required Secrets
 
@@ -99,48 +99,57 @@ If you do not set any backend variables, the app can still boot, and you can cre
 
 Use either `WEBDAV_USERNAME` + `WEBDAV_PASSWORD`, or `WEBDAV_BEARER_TOKEN`.
 
-### GitHub
-
-| Name | Where to store | Required |
-| :--- | :--- | :---: |
-| `GITHUB_REPO` | Variable | yes |
+### GitHub
+
+| Name | Where to store | Required |
+| :--- | :--- | :---: |
+| `GITHUB_REPO` | Variable | yes |
 | `GITHUB_TOKEN` | Secret | yes |
 | `GITHUB_MODE` | Variable | no |
 | `GITHUB_PREFIX` | Variable | no |
 | `GITHUB_RELEASE_TAG` | Variable | no |
-| `GITHUB_BRANCH` | Variable | no |
-| `GITHUB_API_BASE` | Variable | no |
-
-## Variables You Usually Do Not Need To Override
-
-These are already baked into the root `Dockerfile` for Spaces:
+| `GITHUB_BRANCH` | Variable | no |
+| `GITHUB_API_BASE` | Variable | no |
+
+## SQLite GitHub Backup
+
+If your Space filesystem is ephemeral, use a separate GitHub repository as the SQLite backup target. K-Vault will:
+
+- `git pull` the latest backup before the API starts
+- restore `k-vault.db` from that repository
+- start periodic backup only after SQLite writes happen
+- stop the backup timer automatically after an idle period
+- `git push` the latest SQLite snapshot back to GitHub
+
+The backup flow uses `git-lfs` by default and the image now includes both `git` and `git-lfs`.
+Make sure Git LFS is enabled for the backup repository before first use.
+
+| Name | Where | Required | Purpose |
+| :--- | :---: | :---: | :--- |
+| `SQLITE_BACKUP_ENABLED` | Variable | no | Force enable/disable backup. If omitted, backup auto-enables when repo + token are present |
+| `SQLITE_BACKUP_GITHUB_REPO` | Variable | yes* | Backup repo, e.g. `owner/repo` or full `https://github.com/...git` URL |
+| `SQLITE_BACKUP_GITHUB_TOKEN` | Secret | yes* | GitHub token with push access to the backup repo |
+| `SQLITE_BACKUP_GITHUB_BRANCH` | Variable | no | Branch to restore from and push to. Default: `main` |
+| `SQLITE_BACKUP_PATH` | Variable | no | SQLite snapshot path inside the repo. Default: `backups/k-vault.db` |
+| `SQLITE_BACKUP_INTERVAL_MS` | Variable | no | Backup interval after activity. Default: `15000` |
+| `SQLITE_BACKUP_IDLE_MS` | Variable | no | Stop the timer after this much idle time. Default: `120000` |
+| `SQLITE_BACKUP_GIT_LFS` | Variable | no | Use Git LFS for the SQLite snapshot. Default: `true` |
+| `SQLITE_BACKUP_GIT_USER_NAME` | Variable | no | Commit author name |
+| `SQLITE_BACKUP_GIT_USER_EMAIL` | Variable | no | Commit author email |
+
+\* `SQLITE_BACKUP_GITHUB_REPO` and `SQLITE_BACKUP_GITHUB_TOKEN` are both required when backup is enabled.
+
+## Variables You Usually Do Not Need To Override
+
+These are already baked into the root `Dockerfile` for Spaces:
 
 - `PORT=8787`
 - `APP_PORT=7860`
 - `DATA_DIR=/data`
-- `DB_PATH=/data/k-vault.db`
-- `CHUNK_DIR=/data/chunks`
-
-## Cloudflare D1 (Optional)
-
-When configured, K-Vault uses Cloudflare D1 for persistent storage of `storage_configs`, `app_settings`, `sessions`, and `guest_upload_counters`. Files metadata stays in local SQLite.
-
-| Name | Where | Required | Purpose |
-| :--- | :---: | :---: | :--- |
-| `CF_ACCOUNT_ID` | Variable | yes* | Cloudflare account ID |
-| `CF_D1_DATABASE_ID` | Variable | yes* | D1 database ID |
-| `CF_API_TOKEN` | Secret | yes* | API token with D1 Edit permission |
-| `CF_D1_API_BASE` | Variable | no | Override API base (default: `https://api.cloudflare.com/client/v4`) |
-
-\* All three (`CF_ACCOUNT_ID`, `CF_D1_DATABASE_ID`, `CF_API_TOKEN`) must be set to enable D1. Otherwise SQLite is used.
-
-D1 tables are created automatically on first run. You can also run the schema manually:
-
-```sh
-npx wrangler d1 execute <db-name> --remote --file=server/lib/d1/schema.sql
-```
-
-## Minimum Working Configuration
+- `DB_PATH=/data/k-vault.db`
+- `CHUNK_DIR=/data/chunks`
+
+## Minimum Working Configuration
 
 If you want the smallest possible setup, start with:
 

server/app.js

@@ -8,9 +8,10 @@ const { normalizeFolderPath } = require('./lib/repos/file-repo');
 const { toStorageErrorPayload } = require('./lib/utils/storage-error');
 const { createShareSignature, verifyShareSignature } = require('./lib/utils/share-link');
 
-async function createApp() {
-  const app = new Hono();
-  const container = await createContainer(process.env);
+async function createApp() {
+  const app = new Hono();
+  const container = await createContainer(process.env);
+  app.container = container;
 
   app.use('*', cors({
     origin: (origin) => origin || '*',
@@ -730,8 +731,8 @@ async function createApp() {
   });
 
   // --- Status ---
-  app.get('/api/status', async (c) => {
-    const { storageRepo, storageFactory, authService, guestService, settingsStore } = getServices(c);
+  app.get('/api/status', async (c) => {
+    const { storageRepo, storageFactory, authService, guestService, settingsStore, sqliteBackup } = getServices(c);
 
     const status = {
       telegram: {
@@ -748,14 +749,15 @@ async function createApp() {
       huggingface: { connected: false, enabled: false, configured: false, layer: 'direct', message: 'Not configured' },
       webdav: { connected: false, enabled: false, configured: false, layer: 'mounted', message: 'Not configured' },
       github: { connected: false, enabled: false, configured: false, layer: 'direct', message: 'Not configured' },
-      auth: {
-        enabled: authService.isAuthRequired(),
-        message: authService.isAuthRequired() ? 'Password auth enabled' : 'No auth required',
-      },
-      guestUpload: guestService.getConfig(),
-      settings: { connected: false, message: 'Unknown' },
-      diagnostics: {},
-    };
+      auth: {
+        enabled: authService.isAuthRequired(),
+        message: authService.isAuthRequired() ? 'Password auth enabled' : 'No auth required',
+      },
+      guestUpload: guestService.getConfig(),
+      sqliteBackup: sqliteBackup?.getStatus?.() || { enabled: false, running: false, dirty: false, message: 'Disabled' },
+      settings: { connected: false, message: 'Unknown' },
+      diagnostics: {},
+    };
 
     status.settings = await settingsStore.healthCheck();
 

server/db/index.js

@@ -1,67 +1,126 @@
-const fs = require('node:fs');
-const path = require('node:path');
-const { DatabaseSync } = require('node:sqlite');
-
-function executeStatement(stmt, method, params) {
-  if (params == null) {
-    return stmt[method]();
-  }
-  if (Array.isArray(params)) {
-    return stmt[method](...params);
-  }
-  return stmt[method](params);
-}
-
-function initDatabase(dbPath) {
-  const fullPath = path.resolve(dbPath);
-  fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-
-  const db = new DatabaseSync(fullPath);
-  const schemaPath = path.resolve(__dirname, 'schema.sql');
-  const schema = fs.readFileSync(schemaPath, 'utf8');
-  db.exec(schema);
-
-  return db;
-}
-
-function run(db, sql, params) {
-  const stmt = db.prepare(sql);
-  return executeStatement(stmt, 'run', params);
-}
-
-function get(db, sql, params) {
-  const stmt = db.prepare(sql);
-  return executeStatement(stmt, 'get', params);
-}
-
-function all(db, sql, params) {
-  const stmt = db.prepare(sql);
-  return executeStatement(stmt, 'all', params);
-}
-
-function transaction(db, callback) {
-  db.exec('BEGIN');
-  try {
-    const result = callback();
-    db.exec('COMMIT');
-    return result;
-  } catch (error) {
-    db.exec('ROLLBACK');
-    throw error;
-  }
-}
-
-function cleanupExpiredState(db) {
-  const now = Date.now();
-  run(db, 'DELETE FROM sessions WHERE expires_at <= ?', [now]);
-  run(db, 'DELETE FROM chunk_uploads WHERE expires_at <= ?', [now]);
-}
-
-module.exports = {
-  initDatabase,
-  run,
-  get,
-  all,
-  transaction,
-  cleanupExpiredState,
-};
+const fs = require('node:fs');
+const path = require('node:path');
+const { DatabaseSync } = require('node:sqlite');
+
+function isMutationSql(sql) {
+  const normalized = String(sql || '').trim().toUpperCase();
+  return (
+    normalized.startsWith('INSERT') ||
+    normalized.startsWith('UPDATE') ||
+    normalized.startsWith('DELETE') ||
+    normalized.startsWith('REPLACE') ||
+    normalized.startsWith('ALTER') ||
+    normalized.startsWith('CREATE') ||
+    normalized.startsWith('DROP') ||
+    normalized.startsWith('VACUUM')
+  );
+}
+
+function isSchemaMutationSql(sql) {
+  const normalized = String(sql || '').trim().toUpperCase();
+  return (
+    normalized.startsWith('ALTER') ||
+    normalized.startsWith('CREATE') ||
+    normalized.startsWith('DROP') ||
+    normalized.startsWith('VACUUM')
+  );
+}
+
+function registerMutationObserver(db, observer) {
+  if (!db || typeof observer !== 'function') return () => {};
+
+  if (!db.__mutationObservers) {
+    Object.defineProperty(db, '__mutationObservers', {
+      configurable: false,
+      enumerable: false,
+      writable: false,
+      value: new Set(),
+    });
+  }
+
+  db.__mutationObservers.add(observer);
+
+  return () => {
+    db.__mutationObservers?.delete(observer);
+  };
+}
+
+function notifyMutationObservers(db, sql, result) {
+  if (!db?.__mutationObservers || !isMutationSql(sql)) return;
+  if (!isSchemaMutationSql(sql) && Number(result?.changes || 0) <= 0) return;
+
+  for (const observer of db.__mutationObservers) {
+    try {
+      observer(sql);
+    } catch (error) {
+      console.warn('[db] Mutation observer failed:', error?.message || error);
+    }
+  }
+}
+
+function executeStatement(stmt, method, params) {
+  if (params == null) {
+    return stmt[method]();
+  }
+  if (Array.isArray(params)) {
+    return stmt[method](...params);
+  }
+  return stmt[method](params);
+}
+
+function initDatabase(dbPath) {
+  const fullPath = path.resolve(dbPath);
+  fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+
+  const db = new DatabaseSync(fullPath);
+  const schemaPath = path.resolve(__dirname, 'schema.sql');
+  const schema = fs.readFileSync(schemaPath, 'utf8');
+  db.exec(schema);
+
+  return db;
+}
+
+function run(db, sql, params) {
+  const stmt = db.prepare(sql);
+  const result = executeStatement(stmt, 'run', params);
+  notifyMutationObservers(db, sql, result);
+  return result;
+}
+
+function get(db, sql, params) {
+  const stmt = db.prepare(sql);
+  return executeStatement(stmt, 'get', params);
+}
+
+function all(db, sql, params) {
+  const stmt = db.prepare(sql);
+  return executeStatement(stmt, 'all', params);
+}
+
+function transaction(db, callback) {
+  db.exec('BEGIN');
+  try {
+    const result = callback();
+    db.exec('COMMIT');
+    return result;
+  } catch (error) {
+    db.exec('ROLLBACK');
+    throw error;
+  }
+}
+
+function cleanupExpiredState(db) {
+  const now = Date.now();
+  run(db, 'DELETE FROM sessions WHERE expires_at <= ?', [now]);
+  run(db, 'DELETE FROM chunk_uploads WHERE expires_at <= ?', [now]);
+}
+
+module.exports = {
+  initDatabase,
+  run,
+  get,
+  all,
+  transaction,
+  cleanupExpiredState,
+  registerMutationObserver,
+};

server/index.js

@@ -1,12 +1,36 @@
-const { serve } = require('@hono/node-server');
-const { createApp } = require('./app');
-
-async function main() {
-  const app = await createApp();
-  const port = Number(process.env.PORT || 8787);
-  console.log(`[k-vault] Starting Docker runtime on :${port}`);
-  serve({ fetch: app.fetch, port });
-}
+const { serve } = require('@hono/node-server');
+const { createApp } = require('./app');
+
+async function main() {
+  const app = await createApp();
+  const container = app.container;
+  const port = Number(process.env.PORT || 8787);
+  console.log(`[k-vault] Starting Docker runtime on :${port}`);
+  serve({ fetch: app.fetch, port });
+
+  let shuttingDown = false;
+  const shutdown = async (signal) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+
+    console.log(`[k-vault] Received ${signal}, flushing state...`);
+    try {
+      await container?.close?.();
+    } catch (error) {
+      console.error('[k-vault] Shutdown failed:', error);
+      process.exitCode = 1;
+    } finally {
+      process.exit();
+    }
+  };
+
+  process.on('SIGINT', () => {
+    void shutdown('SIGINT');
+  });
+  process.on('SIGTERM', () => {
+    void shutdown('SIGTERM');
+  });
+}
 
 main().catch((err) => {
   console.error('[k-vault] Startup failed:', err);

server/lib/backup/sqlite-github-backup.js

@@ -0,0 +1,450 @@
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+
+function normalizeRepo(repo) {
+  const value = String(repo || '').trim();
+  if (!value) return '';
+  if (/^https?:\/\//i.test(value)) return value.replace(/\/+$/, '');
+  return `https://github.com/${value.replace(/^\/+/, '').replace(/\.git$/i, '')}.git`;
+}
+
+function sqliteLiteral(value) {
+  return String(value || '').replace(/'/g, "''");
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isLikelySqliteFile(filePath) {
+  try {
+    const handle = fs.openSync(filePath, 'r');
+    const header = Buffer.alloc(16);
+    fs.readSync(handle, header, 0, 16, 0);
+    fs.closeSync(handle);
+    return header.toString('utf8') === 'SQLite format 3\u0000';
+  } catch {
+    return false;
+  }
+}
+
+class SqliteGitHubBackup {
+  constructor({ config, dbPath }) {
+    this.config = config || {};
+    this.dbPath = path.resolve(dbPath);
+    this.repoUrl = normalizeRepo(this.config.repo);
+    this.repoDir = path.resolve(this.config.repoDir || path.dirname(this.dbPath));
+    this.snapshotPath = String(this.config.snapshotPath || 'backups/k-vault.db').replace(/^\/+/, '');
+    this.snapshotTempPath = path.join(path.dirname(this.dbPath), '.sqlite-backup.tmp');
+    this.enabled = Boolean(this.config.enabled);
+    this.requiredConfigured = Boolean(this.repoUrl && this.config.token);
+
+    this.db = null;
+    this.intervalHandle = null;
+    this.idleHandle = null;
+    this.flushPromise = null;
+    this.dirty = false;
+    this.activityCounter = 0;
+    this.lastActivityAt = 0;
+    this.lastBackupAt = 0;
+    this.lastRestoreAt = 0;
+    this.lastError = '';
+    this.stoppedReason = 'idle';
+  }
+
+  validateConfig() {
+    if (!this.enabled) return;
+    if (!this.requiredConfigured) {
+      throw new Error('SQLite GitHub backup is enabled but SQLITE_BACKUP_GITHUB_REPO/SQLITE_BACKUP_GITHUB_TOKEN is incomplete.');
+    }
+  }
+
+  attachDatabase(db) {
+    this.db = db;
+  }
+
+  getStatus() {
+    if (!this.enabled) {
+      return {
+        enabled: false,
+        running: false,
+        dirty: false,
+        message: 'SQLite GitHub backup disabled',
+      };
+    }
+
+    return {
+      enabled: true,
+      running: Boolean(this.intervalHandle),
+      dirty: this.dirty,
+      branch: this.config.branch,
+      snapshotPath: this.snapshotPath,
+      lastActivityAt: this.lastActivityAt || null,
+      lastBackupAt: this.lastBackupAt || null,
+      lastRestoreAt: this.lastRestoreAt || null,
+      message: this.lastError || (this.intervalHandle ? 'SQLite GitHub backup active' : `SQLite GitHub backup idle (${this.stoppedReason})`),
+    };
+  }
+
+  buildGitEnv() {
+    const env = {
+      ...process.env,
+      GIT_TERMINAL_PROMPT: '0',
+    };
+
+    if (!this.config.token) {
+      return env;
+    }
+
+    const remoteUrl = new URL(this.repoUrl);
+    env.GIT_CONFIG_COUNT = '1';
+    env.GIT_CONFIG_KEY_0 = `http.${remoteUrl.protocol}//${remoteUrl.host}/.extraheader`;
+    env.GIT_CONFIG_VALUE_0 = `AUTHORIZATION: basic ${Buffer.from(`x-access-token:${this.config.token}`).toString('base64')}`;
+    return env;
+  }
+
+  runGit(args, options = {}) {
+    const { cwd, allowFailure = false } = options;
+    const env = this.buildGitEnv();
+
+    return new Promise((resolve, reject) => {
+      const child = spawn('git', args, {
+        cwd,
+        env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout.on('data', (chunk) => {
+        stdout += chunk.toString();
+      });
+      child.stderr.on('data', (chunk) => {
+        stderr += chunk.toString();
+      });
+
+      child.on('error', (error) => {
+        if (allowFailure) {
+          resolve({ ok: false, code: -1, stdout, stderr: error.message });
+          return;
+        }
+        reject(error);
+      });
+
+      child.on('close', (code) => {
+        const result = {
+          ok: code === 0,
+          code,
+          stdout: stdout.trim(),
+          stderr: stderr.trim(),
+        };
+
+        if (!result.ok && !allowFailure) {
+          const message = result.stderr || result.stdout || `git ${args.join(' ')} failed with exit code ${code}`;
+          reject(new Error(message));
+          return;
+        }
+
+        resolve(result);
+      });
+    });
+  }
+
+  async remoteBranchExists() {
+    const result = await this.runGit(
+      ['ls-remote', '--heads', this.repoUrl, this.config.branch],
+      { allowFailure: true }
+    );
+    return result.ok && Boolean(result.stdout);
+  }
+
+  async ensureGitLfs(repoDir) {
+    if (!this.config.lfsEnabled) return;
+
+    const version = await this.runGit(['lfs', 'version'], { allowFailure: true });
+    if (!version.ok) {
+      throw new Error('git-lfs is required for SQLite GitHub backup but is not available.');
+    }
+
+    await this.runGit(['-C', repoDir, 'lfs', 'install', '--local']);
+    await this.runGit(['-C', repoDir, 'lfs', 'track', this.snapshotPath]);
+  }
+
+  async ensureRepoReady({ syncRemote = false } = {}) {
+    await fsp.mkdir(path.dirname(this.repoDir), { recursive: true });
+
+    if (!fs.existsSync(path.join(this.repoDir, '.git'))) {
+      await this.runGit(['clone', this.repoUrl, this.repoDir]);
+    }
+
+    await this.runGit(['-C', this.repoDir, 'config', 'user.name', this.config.gitUserName]);
+    await this.runGit(['-C', this.repoDir, 'config', 'user.email', this.config.gitUserEmail]);
+    await this.ensureGitLfs(this.repoDir);
+
+    const remoteBranchExists = await this.remoteBranchExists();
+    const currentBranch = await this.runGit(['-C', this.repoDir, 'branch', '--show-current'], { allowFailure: true });
+    const currentName = currentBranch.stdout.trim();
+
+    if (remoteBranchExists) {
+      const localBranch = await this.runGit(
+        ['-C', this.repoDir, 'rev-parse', '--verify', `refs/heads/${this.config.branch}`],
+        { allowFailure: true }
+      );
+
+      if (currentName !== this.config.branch) {
+        if (localBranch.ok) {
+          await this.runGit(['-C', this.repoDir, 'switch', this.config.branch]);
+        } else {
+          await this.runGit(['-C', this.repoDir, 'switch', '--track', `origin/${this.config.branch}`]);
+        }
+      }
+
+      if (syncRemote) {
+        await this.runGit(['-C', this.repoDir, 'pull', '--ff-only', 'origin', this.config.branch]);
+        if (this.config.lfsEnabled) {
+          await this.runGit(['-C', this.repoDir, 'lfs', 'pull', 'origin', this.config.branch]);
+        }
+      }
+    } else if (currentName !== this.config.branch) {
+      const localBranch = await this.runGit(
+        ['-C', this.repoDir, 'rev-parse', '--verify', `refs/heads/${this.config.branch}`],
+        { allowFailure: true }
+      );
+
+      if (localBranch.ok) {
+        await this.runGit(['-C', this.repoDir, 'switch', this.config.branch]);
+      } else {
+        await this.runGit(['-C', this.repoDir, 'switch', '-c', this.config.branch]);
+      }
+    }
+  }
+
+  async restoreIfAvailable() {
+    if (!this.enabled) {
+      return { restored: false, skipped: true, reason: 'disabled' };
+    }
+
+    this.validateConfig();
+    await this.ensureRepoReady({ syncRemote: true });
+
+    const sourcePath = path.join(this.repoDir, this.snapshotPath);
+    if (!fs.existsSync(sourcePath)) {
+      return { restored: false, skipped: true, reason: 'missing-backup' };
+    }
+
+    if (!isLikelySqliteFile(sourcePath)) {
+      throw new Error(`Backup file is not a valid SQLite snapshot: ${this.snapshotPath}`);
+    }
+
+    await fsp.mkdir(path.dirname(this.dbPath), { recursive: true });
+    await fsp.copyFile(sourcePath, this.dbPath);
+    this.lastRestoreAt = Date.now();
+    this.lastError = '';
+
+    console.log(`[sqlite-backup] Restored ${this.snapshotPath} from ${this.config.branch}`);
+
+    return { restored: true, sourcePath };
+  }
+
+  recordActivity() {
+    if (!this.enabled) return;
+
+    this.lastActivityAt = Date.now();
+    this.activityCounter += 1;
+    this.dirty = true;
+    this.lastError = '';
+
+    if (!this.intervalHandle) {
+      this.intervalHandle = setInterval(() => {
+        void this.flushNow('interval');
+      }, this.config.intervalMs);
+    }
+
+    if (this.idleHandle) {
+      clearTimeout(this.idleHandle);
+    }
+
+    this.idleHandle = setTimeout(() => {
+      void this.handleIdleTimeout();
+    }, this.config.idleMs);
+  }
+
+  async handleIdleTimeout() {
+    try {
+      if (this.dirty) {
+        await this.flushNow('idle-timeout');
+      }
+    } catch (error) {
+      this.lastError = error?.message || String(error);
+    } finally {
+      if (this.dirty) {
+        this.idleHandle = setTimeout(() => {
+          void this.handleIdleTimeout();
+        }, this.config.idleMs);
+        return;
+      }
+      this.stop('idle-timeout');
+    }
+  }
+
+  stop(reason = 'manual') {
+    this.stoppedReason = reason;
+
+    if (this.intervalHandle) {
+      clearInterval(this.intervalHandle);
+      this.intervalHandle = null;
+    }
+
+    if (this.idleHandle) {
+      clearTimeout(this.idleHandle);
+      this.idleHandle = null;
+    }
+  }
+
+  async exportSnapshot() {
+    await fsp.mkdir(path.dirname(this.snapshotTempPath), { recursive: true });
+    await fsp.rm(this.snapshotTempPath, { force: true });
+
+    if (this.db) {
+      this.db.exec(`VACUUM INTO '${sqliteLiteral(this.snapshotTempPath)}'`);
+      return;
+    }
+
+    await fsp.copyFile(this.dbPath, this.snapshotTempPath);
+  }
+
+  async stageSnapshot() {
+    await this.exportSnapshot();
+
+    const repoSnapshotPath = path.join(this.repoDir, this.snapshotPath);
+    await fsp.mkdir(path.dirname(repoSnapshotPath), { recursive: true });
+    await fsp.copyFile(this.snapshotTempPath, repoSnapshotPath);
+
+    const stageTargets = [this.snapshotPath];
+    const gitattributesPath = path.join(this.repoDir, '.gitattributes');
+    if (fs.existsSync(gitattributesPath)) {
+      stageTargets.push('.gitattributes');
+    }
+
+    await this.runGit(['-C', this.repoDir, 'add', '--', ...stageTargets]);
+    const status = await this.runGit(
+      ['-C', this.repoDir, 'status', '--porcelain', '--', ...stageTargets],
+      { allowFailure: true }
+    );
+
+    if (!status.ok) {
+      throw new Error(status.stderr || 'git status failed');
+    }
+
+    if (!status.stdout) {
+      return false;
+    }
+    return true;
+  }
+
+  async pushSnapshot(reason) {
+    const commitMessage = `chore: backup sqlite (${reason}) ${new Date().toISOString()}`;
+
+    await this.runGit(['-C', this.repoDir, 'commit', '-m', commitMessage]);
+
+    const firstPush = await this.runGit(
+      ['-C', this.repoDir, 'push', '-u', 'origin', this.config.branch],
+      { allowFailure: true }
+    );
+    if (firstPush.ok) {
+      return;
+    }
+
+    await this.runGit(['-C', this.repoDir, 'pull', '--rebase', 'origin', this.config.branch]);
+    if (this.config.lfsEnabled) {
+      await this.runGit(['-C', this.repoDir, 'lfs', 'pull', 'origin', this.config.branch], { allowFailure: true });
+    }
+    await this.runGit(['-C', this.repoDir, 'push', '-u', 'origin', this.config.branch]);
+  }
+
+  async performBackup(reason) {
+    if (!this.dirty) return false;
+
+    this.validateConfig();
+    await this.ensureRepoReady();
+    const snapshotActivity = this.activityCounter;
+
+    const changed = await this.stageSnapshot();
+    if (!changed) {
+      this.dirty = this.activityCounter > snapshotActivity;
+      return false;
+    }
+
+    await this.pushSnapshot(reason);
+    this.dirty = this.activityCounter > snapshotActivity;
+    this.lastBackupAt = Date.now();
+    this.lastError = '';
+
+    console.log(`[sqlite-backup] Pushed ${this.snapshotPath} to ${this.config.branch}`);
+
+    return true;
+  }
+
+  async flushNow(reason = 'manual') {
+    if (!this.enabled) return false;
+
+    if (this.flushPromise) {
+      return this.flushPromise;
+    }
+
+    this.flushPromise = (async () => {
+      try {
+        return await this.performBackup(reason);
+      } catch (error) {
+        this.lastError = error?.message || String(error);
+        console.error('[sqlite-backup] Backup failed:', this.lastError);
+        throw error;
+      } finally {
+        this.flushPromise = null;
+      }
+    })();
+
+    return this.flushPromise;
+  }
+
+  async shutdown() {
+    if (!this.enabled) return;
+
+    this.stop('shutdown');
+
+    if (this.flushPromise) {
+      await this.flushPromise.catch(() => {});
+    }
+
+    if (this.dirty) {
+      for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+          await this.flushNow('shutdown');
+          break;
+        } catch (error) {
+          if (attempt === 1) {
+            throw error;
+          }
+          await delay(1000);
+        }
+      }
+    }
+  }
+}
+
+function createSqliteGitHubBackup(config, dbPath) {
+  const backup = new SqliteGitHubBackup({
+    config,
+    dbPath,
+  });
+
+  return backup.enabled ? backup : null;
+}
+
+module.exports = {
+  SqliteGitHubBackup,
+  createSqliteGitHubBackup,
+};

server/lib/config.js

@@ -27,13 +27,18 @@ function pickEnvAlias(env, aliases = [], fallback = '') {
   return { value: fallback, source: '' };
 }
 
-function loadConfig(env = process.env) {
-  const dataDir = env.DATA_DIR
-    ? path.resolve(env.DATA_DIR)
-    : resolveDataPath('data');
-  const telegramToken = pickEnvAlias(env, ['TG_BOT_TOKEN', 'TG_Bot_Token']);
-  const telegramChatId = pickEnvAlias(env, ['TG_CHAT_ID', 'TG_Chat_ID']);
-  const telegramApiBase = pickEnvAlias(env, ['CUSTOM_BOT_API_URL'], 'https://api.telegram.org');
+function loadConfig(env = process.env) {
+  const dataDir = env.DATA_DIR
+    ? path.resolve(env.DATA_DIR)
+    : resolveDataPath('data');
+  const sqliteBackupRepo = env.SQLITE_BACKUP_GITHUB_REPO || env.SQLITE_BACKUP_REPO || '';
+  const sqliteBackupToken = env.SQLITE_BACKUP_GITHUB_TOKEN || env.SQLITE_BACKUP_TOKEN || '';
+  const sqliteBackupExplicit = env.SQLITE_BACKUP_ENABLED;
+  const sqliteBackupIntervalMs = Math.max(10000, toInt(env.SQLITE_BACKUP_INTERVAL_MS, 15000));
+  const sqliteBackupIdleMs = Math.max(sqliteBackupIntervalMs, toInt(env.SQLITE_BACKUP_IDLE_MS, 120000));
+  const telegramToken = pickEnvAlias(env, ['TG_BOT_TOKEN', 'TG_Bot_Token']);
+  const telegramChatId = pickEnvAlias(env, ['TG_CHAT_ID', 'TG_Chat_ID']);
+  const telegramApiBase = pickEnvAlias(env, ['CUSTOM_BOT_API_URL'], 'https://api.telegram.org');
 
   return {
     port: toInt(env.PORT, 8787),
@@ -56,20 +61,32 @@ function loadConfig(env = process.env) {
     configEncryptionKey: env.CONFIG_ENCRYPTION_KEY || env.FILE_URL_SECRET || env.SESSION_SECRET || '',
     sessionSecret: env.SESSION_SECRET || env.FILE_URL_SECRET || env.CONFIG_ENCRYPTION_KEY || '',
 
-    dataDir,
-    dbPath: env.DB_PATH ? path.resolve(env.DB_PATH) : path.join(dataDir, 'k-vault.db'),
-    chunkDir: env.CHUNK_DIR ? path.resolve(env.CHUNK_DIR) : path.join(dataDir, 'chunks'),
-    settingsStore: (env.SETTINGS_STORE || 'sqlite').toLowerCase(),
-    useD1: Boolean(
-      (env.CF_ACCOUNT_ID || env.CLOUDFLARE_ACCOUNT_ID) &&
-      (env.CF_D1_DATABASE_ID || env.CLOUDFLARE_D1_DATABASE_ID) &&
-      (env.CF_API_TOKEN || env.CLOUDFLARE_API_TOKEN)
-    ),
-    settingsRedisUrl: env.SETTINGS_REDIS_URL || env.REDIS_URL || '',
-    settingsRedisPrefix: env.SETTINGS_REDIS_PREFIX || 'k-vault',
-    settingsRedisConnectTimeoutMs: toInt(env.SETTINGS_REDIS_CONNECT_TIMEOUT_MS, 5000),
-
-    telegramApiBase: telegramApiBase.value,
+    dataDir,
+    dbPath: env.DB_PATH ? path.resolve(env.DB_PATH) : path.join(dataDir, 'k-vault.db'),
+    chunkDir: env.CHUNK_DIR ? path.resolve(env.CHUNK_DIR) : path.join(dataDir, 'chunks'),
+    settingsStore: (env.SETTINGS_STORE || 'sqlite').toLowerCase(),
+    settingsRedisUrl: env.SETTINGS_REDIS_URL || env.REDIS_URL || '',
+    settingsRedisPrefix: env.SETTINGS_REDIS_PREFIX || 'k-vault',
+    settingsRedisConnectTimeoutMs: toInt(env.SETTINGS_REDIS_CONNECT_TIMEOUT_MS, 5000),
+    sqliteBackup: {
+      enabled: sqliteBackupExplicit == null || sqliteBackupExplicit === ''
+        ? Boolean(sqliteBackupRepo && sqliteBackupToken)
+        : toBool(sqliteBackupExplicit, false),
+      repo: sqliteBackupRepo,
+      token: sqliteBackupToken,
+      branch: env.SQLITE_BACKUP_GITHUB_BRANCH || env.SQLITE_BACKUP_BRANCH || 'main',
+      repoDir: env.SQLITE_BACKUP_REPO_DIR
+        ? path.resolve(env.SQLITE_BACKUP_REPO_DIR)
+        : path.join(dataDir, 'sqlite-backup-repo'),
+      snapshotPath: env.SQLITE_BACKUP_PATH || 'backups/k-vault.db',
+      intervalMs: sqliteBackupIntervalMs,
+      idleMs: sqliteBackupIdleMs,
+      gitUserName: env.SQLITE_BACKUP_GIT_USER_NAME || 'K-Vault Backup Bot',
+      gitUserEmail: env.SQLITE_BACKUP_GIT_USER_EMAIL || 'k-vault-backup@users.noreply.github.com',
+      lfsEnabled: toBool(env.SQLITE_BACKUP_GIT_LFS, true),
+    },
+
+    telegramApiBase: telegramApiBase.value,
 
     // Optional bootstrap default storage from env.
     bootstrapDefaultStorage: {

server/lib/container.js

@@ -1,89 +1,74 @@
-const { initDatabase, cleanupExpiredState } = require('../db');
-const { loadConfig } = require('./config');
-const { AuthService } = require('./utils/auth');
-const { GuestService } = require('./utils/guest');
-const { StorageFactory } = require('./storage/factory');
-const { StorageConfigRepository } = require('./repos/storage-config-repo');
-const { StorageConfigRepositoryD1 } = require('./repos/storage-config-repo-d1');
-const { FileRepository } = require('./repos/file-repo');
-const { UploadService } = require('./services/upload-service');
-const { ChunkUploadService } = require('./services/chunk-service');
-const { createSettingsStore } = require('./settings/factory');
-const fs = require('node:fs');
-const path = require('node:path');
-const { createD1Client } = require('./d1/client');
-const { D1SessionStore } = require('./d1/session-store');
-const { D1GuestStore } = require('./d1/guest-store');
-
-const D1_SCHEMA_PATH = path.join(__dirname, 'd1', 'schema.sql');
-
-async function createContainer(env = process.env) {
-  const config = loadConfig(env);
-  const db = initDatabase(config.dbPath);
-
-  const d1Client = createD1Client(env);
-  const useD1 = Boolean(d1Client);
-  const fileRepo = new FileRepository(db);
-
-  let storageRepo;
-  let settingsStore;
-  let authService;
-  let guestService;
-
-  if (useD1) {
-    try {
-      const schemaSql = fs.readFileSync(D1_SCHEMA_PATH, 'utf8');
-      await d1Client.initSchema(schemaSql);
-    } catch (e) {
-      console.warn('[d1] Schema init warning:', e?.message || e);
-    }
-    storageRepo = new StorageConfigRepositoryD1(d1Client, config, fileRepo);
-    settingsStore = createSettingsStore({ db, config, d1Client });
-    const sessionStore = new D1SessionStore(d1Client);
-    const guestStore = new D1GuestStore(d1Client);
-    authService = new AuthService(sessionStore, config);
-    guestService = new GuestService(guestStore, config);
-
-    await storageRepo.ensureBootstrapStorage();
-    await sessionStore.cleanupExpired?.();
-  } else {
-    storageRepo = new StorageConfigRepository(db, config);
-    settingsStore = createSettingsStore({ db, config });
-    authService = new AuthService(db, config);
-    guestService = new GuestService(db, config);
-
-    await storageRepo.ensureBootstrapStorage();
-    cleanupExpiredState(db);
-  }
-  const storageFactory = new StorageFactory();
-
-  const uploadService = new UploadService({
-    storageRepo,
-    fileRepo,
-    storageFactory,
-  });
-
-  const chunkService = new ChunkUploadService({
-    db,
-    config,
-    uploadService,
-  });
-
-  return {
-    config,
-    db,
-    d1Client,
-    authService,
-    guestService,
-    storageRepo,
-    fileRepo,
-    storageFactory,
-    settingsStore,
-    uploadService,
-    chunkService,
-  };
-}
-
-module.exports = {
-  createContainer,
-};
+const { initDatabase, cleanupExpiredState, registerMutationObserver } = require('../db');
+const { loadConfig } = require('./config');
+const { AuthService } = require('./utils/auth');
+const { GuestService } = require('./utils/guest');
+const { StorageFactory } = require('./storage/factory');
+const { StorageConfigRepository } = require('./repos/storage-config-repo');
+const { FileRepository } = require('./repos/file-repo');
+const { UploadService } = require('./services/upload-service');
+const { ChunkUploadService } = require('./services/chunk-service');
+const { createSettingsStore } = require('./settings/factory');
+const { createSqliteGitHubBackup } = require('./backup/sqlite-github-backup');
+
+async function createContainer(env = process.env) {
+  const config = loadConfig(env);
+  const sqliteBackup = createSqliteGitHubBackup(config.sqliteBackup, config.dbPath);
+
+  if (sqliteBackup) {
+    await sqliteBackup.restoreIfAvailable();
+  }
+
+  const db = initDatabase(config.dbPath);
+  const unregisterBackupObserver = sqliteBackup
+    ? registerMutationObserver(db, () => sqliteBackup.recordActivity())
+    : () => {};
+
+  sqliteBackup?.attachDatabase(db);
+
+  const fileRepo = new FileRepository(db);
+  const storageRepo = new StorageConfigRepository(db, config);
+  const settingsStore = createSettingsStore({ db, config });
+  const authService = new AuthService(db, config);
+  const guestService = new GuestService(db, config);
+
+  await storageRepo.ensureBootstrapStorage();
+  cleanupExpiredState(db);
+
+  const storageFactory = new StorageFactory();
+
+  const uploadService = new UploadService({
+    storageRepo,
+    fileRepo,
+    storageFactory,
+  });
+
+  const chunkService = new ChunkUploadService({
+    db,
+    config,
+    uploadService,
+  });
+
+  return {
+    config,
+    db,
+    authService,
+    guestService,
+    storageRepo,
+    fileRepo,
+    storageFactory,
+    settingsStore,
+    uploadService,
+    chunkService,
+    sqliteBackup,
+    close: async () => {
+      unregisterBackupObserver();
+      await sqliteBackup?.shutdown();
+      await settingsStore?.close?.();
+      db.close?.();
+    },
+  };
+}
+
+module.exports = {
+  createContainer,
+};

server/lib/d1/client.js

@@ -1,129 +0,0 @@
-/**
- * Cloudflare D1 REST API client.
- * Uses: POST https://api.cloudflare.com/client/v4/accounts/{account_id}/d1/database/{database_id}/query
- * Body: { "sql": "...", "params": [] }
- * Auth: Authorization: Bearer {CF_API_TOKEN}
- */
-const DEFAULT_API_BASE = 'https://api.cloudflare.com/client/v4';
-
-class D1Client {
-  constructor({ accountId, databaseId, apiToken, apiBase = DEFAULT_API_BASE }) {
-    this.accountId = accountId;
-    this.databaseId = databaseId;
-    this.apiToken = apiToken;
-    this.baseUrl = `${apiBase.replace(/\/$/, '')}/accounts/${accountId}/d1/database/${databaseId}/query`;
-  }
-
-  async _request(sql, params = []) {
-    const res = await fetch(this.baseUrl, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${this.apiToken}`,
-      },
-      body: JSON.stringify({ sql, params }),
-    });
-
-    const json = await res.json();
-    if (!res.ok) {
-      const err = new Error(json.errors?.[0]?.message || `D1 API error: ${res.status}`);
-      err.status = res.status;
-      err.d1Errors = json.errors;
-      throw err;
-    }
-
-    if (!json.success) {
-      const err = new Error(json.errors?.[0]?.message || 'D1 request failed');
-      err.d1Errors = json.errors;
-      throw err;
-    }
-
-    return json;
-  }
-
-  /**
-   * Execute a query that returns rows. Returns array of row objects.
-   */
-  async all(sql, params = []) {
-    const json = await this._request(sql, params);
-    const first = json.result?.[0];
-    if (!first) return [];
-    const results = first.results;
-    return Array.isArray(results) ? results : [];
-  }
-
-  /**
-   * Execute a query and return the first row or null.
-   */
-  async get(sql, params = []) {
-    const rows = await this.all(sql, params);
-    return rows[0] ?? null;
-  }
-
-  /**
-   * Execute a statement (INSERT/UPDATE/DELETE). Returns meta with changes.
-   */
-  async run(sql, params = []) {
-    const json = await this._request(sql, params);
-    const first = json.result?.[0];
-    const meta = first?.meta || {};
-    return {
-      changes: meta.changes ?? 0,
-      last_row_id: meta.last_row_id ?? 0,
-    };
-  }
-
-  /**
-   * Execute multiple statements sequentially. D1 REST API does not support
-   * true transactions; this is best-effort sequential execution.
-   */
-  async transaction(fn) {
-    const self = this;
-    const tx = {
-      run: (sql, params) => self.run(sql, params),
-      get: (sql, params) => self.get(sql, params),
-      all: (sql, params) => self.all(sql, params),
-    };
-    return fn(tx);
-  }
-
-  async healthCheck() {
-    try {
-      await this.get('SELECT 1');
-      return { ok: true };
-    } catch (e) {
-      return { ok: false, error: String(e?.message || e) };
-    }
-  }
-
-  /**
-   * Initialize D1 schema. Run each statement separately (D1 REST API).
-   */
-  async initSchema(schemaSql) {
-    const stmts = schemaSql
-      .split(';')
-      .map((s) => s.trim())
-      .filter((s) => s && !s.startsWith('--'));
-    for (const sql of stmts) {
-      if (sql) await this.run(sql);
-    }
-  }
-}
-
-function createD1Client(env = process.env) {
-  const accountId = env.CF_ACCOUNT_ID || env.CLOUDFLARE_ACCOUNT_ID;
-  const databaseId = env.CF_D1_DATABASE_ID || env.CLOUDFLARE_D1_DATABASE_ID;
-  const apiToken = env.CF_API_TOKEN || env.CLOUDFLARE_API_TOKEN;
-  const apiBase = env.CF_D1_API_BASE || env.CLOUDFLARE_D1_API_BASE || DEFAULT_API_BASE;
-
-  if (!accountId || !databaseId || !apiToken) {
-    return null;
-  }
-
-  return new D1Client({ accountId, databaseId, apiToken, apiBase });
-}
-
-module.exports = {
-  D1Client,
-  createD1Client,
-};

server/lib/d1/guest-store.js

@@ -1,33 +0,0 @@
-/**
- * D1-backed guest upload counter store.
- */
-class D1GuestStore {
-  constructor(d1Client) {
-    this.d1 = d1Client;
-  }
-
-  async getCount(id) {
-    const row = await this.d1.get('SELECT count FROM guest_upload_counters WHERE id = ?', [id]);
-    return row ? Number(row.count) : 0;
-  }
-
-  async increment(id, ip, day) {
-    const now = Date.now();
-    const existing = await this.d1.get('SELECT count FROM guest_upload_counters WHERE id = ?', [id]);
-    if (!existing) {
-      await this.d1.run(
-        `INSERT INTO guest_upload_counters(id, ip, day, count, updated_at) VALUES (?, ?, ?, ?, ?)`,
-        [id, ip, day, 1, now]
-      );
-    } else {
-      await this.d1.run(
-        `UPDATE guest_upload_counters SET count = ?, updated_at = ? WHERE id = ?`,
-        [Number(existing.count) + 1, now, id]
-      );
-    }
-  }
-}
-
-module.exports = {
-  D1GuestStore,
-};

server/lib/d1/schema.sql

@@ -1,45 +0,0 @@
--- D1 schema for K-Vault (minimum D1 tables)
--- Run this in D1 before using: wrangler d1 execute <db> --remote --file=server/lib/d1/schema.sql
--- Or via REST API / Console
-
-CREATE TABLE IF NOT EXISTS storage_configs (
-  id TEXT PRIMARY KEY,
-  name TEXT NOT NULL,
-  type TEXT NOT NULL,
-  encrypted_payload TEXT NOT NULL,
-  is_default INTEGER NOT NULL DEFAULT 0,
-  enabled INTEGER NOT NULL DEFAULT 1,
-  metadata_json TEXT NOT NULL DEFAULT '{}',
-  created_at INTEGER NOT NULL,
-  updated_at INTEGER NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS idx_storage_configs_type ON storage_configs(type);
-CREATE INDEX IF NOT EXISTS idx_storage_configs_default ON storage_configs(is_default);
-
-CREATE TABLE IF NOT EXISTS sessions (
-  token TEXT PRIMARY KEY,
-  user_name TEXT NOT NULL,
-  created_at INTEGER NOT NULL,
-  expires_at INTEGER NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS idx_sessions_expires_at ON sessions(expires_at);
-
-CREATE TABLE IF NOT EXISTS guest_upload_counters (
-  id TEXT PRIMARY KEY,
-  ip TEXT NOT NULL,
-  day TEXT NOT NULL,
-  count INTEGER NOT NULL DEFAULT 0,
-  updated_at INTEGER NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS idx_guest_upload_counters_day ON guest_upload_counters(day);
-
-CREATE TABLE IF NOT EXISTS app_settings (
-  key TEXT PRIMARY KEY,
-  value_json TEXT NOT NULL,
-  updated_at INTEGER NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS idx_app_settings_updated_at ON app_settings(updated_at DESC);

server/lib/d1/session-store.js

@@ -1,34 +0,0 @@
-/**
- * D1-backed session store for AuthService.
- */
-class D1SessionStore {
-  constructor(d1Client) {
-    this.d1 = d1Client;
-  }
-
-  async createSession(userName, token, createdAt, expiresAt) {
-    await this.d1.run(
-      `INSERT INTO sessions(token, user_name, created_at, expires_at) VALUES (?, ?, ?, ?)`,
-      [token, userName, createdAt, expiresAt]
-    );
-  }
-
-  async getSession(token) {
-    if (!token) return null;
-    const row = await this.d1.get('SELECT * FROM sessions WHERE token = ?', [token]);
-    return row;
-  }
-
-  async deleteSession(token) {
-    if (!token) return;
-    await this.d1.run('DELETE FROM sessions WHERE token = ?', [token]);
-  }
-
-  async cleanupExpired() {
-    await this.d1.run('DELETE FROM sessions WHERE expires_at <= ?', [Date.now()]);
-  }
-}
-
-module.exports = {
-  D1SessionStore,
-};

server/lib/repos/storage-config-repo-d1.js

@@ -1,244 +0,0 @@
-/**
- * D1-backed StorageConfigRepository. All methods are async.
- */
-const { encryptJson, decryptJson, randomId } = require('../utils/crypto');
-const { normalizeStorageType } = require('../storage/common');
-
-class StorageConfigRepositoryD1 {
-  constructor(d1Client, appConfig, fileRepo) {
-    this.d1 = d1Client;
-    this.appConfig = appConfig;
-    this.fileRepo = fileRepo;
-  }
-
-  parseRow(row, includeSecrets = false) {
-    if (!row) return null;
-
-    const payloadBlob = JSON.parse(row.encrypted_payload || '{}');
-    let decrypted = {};
-    try {
-      decrypted = decryptJson(payloadBlob, this.appConfig.configEncryptionKey);
-    } catch (error) {
-      throw new Error(`Failed to decrypt storage config "${row.name}". Check CONFIG_ENCRYPTION_KEY.`);
-    }
-
-    return {
-      id: row.id,
-      name: row.name,
-      type: row.type,
-      enabled: Boolean(row.enabled),
-      isDefault: Boolean(row.is_default),
-      metadata: JSON.parse(row.metadata_json || '{}'),
-      createdAt: row.created_at,
-      updatedAt: row.updated_at,
-      config: includeSecrets ? decrypted : this.maskSensitiveFields(row.type, decrypted),
-    };
-  }
-
-  maskSensitiveFields(type, config) {
-    const cloned = { ...(config || {}) };
-    const secretFieldsByType = {
-      telegram: ['botToken'],
-      r2: ['accessKeyId', 'secretAccessKey'],
-      s3: ['accessKeyId', 'secretAccessKey'],
-      discord: ['botToken', 'webhookUrl'],
-      huggingface: ['token'],
-      webdav: ['password', 'bearerToken', 'token'],
-      github: ['token'],
-    };
-    (secretFieldsByType[type] || []).forEach((field) => {
-      if (cloned[field]) cloned[field] = '********';
-    });
-    return cloned;
-  }
-
-  mergeConfigPreserveSecrets(type, currentConfig, patchConfig) {
-    if (!patchConfig || typeof patchConfig !== 'object') return { ...(currentConfig || {}) };
-    const merged = { ...(currentConfig || {}) };
-    const incoming = { ...patchConfig };
-    const secretFieldsByType = {
-      telegram: ['botToken'],
-      r2: ['accessKeyId', 'secretAccessKey'],
-      s3: ['accessKeyId', 'secretAccessKey'],
-      discord: ['botToken', 'webhookUrl'],
-      huggingface: ['token'],
-      webdav: ['password', 'bearerToken', 'token'],
-      github: ['token'],
-    };
-    (secretFieldsByType[type] || []).forEach((field) => {
-      if (incoming[field] === '********') delete incoming[field];
-    });
-    return { ...merged, ...incoming };
-  }
-
-  async list(includeSecrets = false) {
-    const rows = await this.d1.all(
-      `SELECT * FROM storage_configs ORDER BY is_default DESC, type ASC, created_at ASC`
-    );
-    return rows.map((row) => this.parseRow(row, includeSecrets));
-  }
-
-  async getById(id, includeSecrets = true) {
-    const row = await this.d1.get('SELECT * FROM storage_configs WHERE id = ?', [id]);
-    return this.parseRow(row, includeSecrets);
-  }
-
-  async getDefault() {
-    const row = await this.d1.get(
-      'SELECT * FROM storage_configs WHERE is_default = 1 ORDER BY updated_at DESC LIMIT 1'
-    );
-    return this.parseRow(row, true);
-  }
-
-  async findEnabledByType(type) {
-    const normalized = normalizeStorageType(type);
-    const rows = await this.d1.all(
-      `SELECT * FROM storage_configs WHERE type = ? AND enabled = 1 ORDER BY is_default DESC, updated_at DESC`,
-      [normalized]
-    );
-    return rows.map((row) => this.parseRow(row, true));
-  }
-
-  async resolveStorageSelection({ storageId, storageMode }) {
-    if (storageId) {
-      const byId = await this.getById(storageId, true);
-      if (!byId || !byId.enabled) throw new Error('Selected storage config not found or disabled.');
-      return byId;
-    }
-    if (storageMode) {
-      const typed = await this.findEnabledByType(storageMode);
-      if (typed.length > 0) return typed[0];
-    }
-    const defaultConfig = await this.getDefault();
-    if (defaultConfig && defaultConfig.enabled) return defaultConfig;
-    const rows = await this.d1.all(
-      `SELECT * FROM storage_configs WHERE enabled = 1 ORDER BY is_default DESC, created_at ASC LIMIT 1`
-    );
-    return this.parseRow(rows[0] || null, true);
-  }
-
-  async create({ name, type, config, enabled = true, isDefault = false, metadata = {} }) {
-    const normalizedType = normalizeStorageType(type);
-    const now = Date.now();
-    const id = randomId('sc');
-    const encrypted = encryptJson(config, this.appConfig.configEncryptionKey);
-
-    await this.d1.transaction(async (tx) => {
-      if (isDefault) {
-        await tx.run('UPDATE storage_configs SET is_default = 0');
-      }
-      await tx.run(
-        `INSERT INTO storage_configs(
-          id, name, type, encrypted_payload, is_default, enabled, metadata_json, created_at, updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        [
-          id,
-          name,
-          normalizedType,
-          JSON.stringify(encrypted),
-          isDefault ? 1 : 0,
-          enabled ? 1 : 0,
-          JSON.stringify(metadata || {}),
-          now,
-          now,
-        ]
-      );
-    });
-
-    return this.getById(id, true);
-  }
-
-  async update(id, patch) {
-    const current = await this.getById(id, true);
-    if (!current) return null;
-
-    const nextType = normalizeStorageType(patch.type || current.type);
-    const nextConfig = this.mergeConfigPreserveSecrets(nextType, current.config, patch.config);
-    const encrypted = encryptJson(nextConfig, this.appConfig.configEncryptionKey);
-    const now = Date.now();
-
-    await this.d1.transaction(async (tx) => {
-      if (patch.isDefault) {
-        await tx.run('UPDATE storage_configs SET is_default = 0 WHERE id != ?', [id]);
-      }
-      await tx.run(
-        `UPDATE storage_configs SET name = ?, type = ?, encrypted_payload = ?, is_default = ?, enabled = ?, metadata_json = ?, updated_at = ? WHERE id = ?`,
-        [
-          patch.name || current.name,
-          nextType,
-          JSON.stringify(encrypted),
-          patch.isDefault != null ? (patch.isDefault ? 1 : 0) : (current.isDefault ? 1 : 0),
-          patch.enabled != null ? (patch.enabled ? 1 : 0) : (current.enabled ? 1 : 0),
-          JSON.stringify(patch.metadata || current.metadata || {}),
-          now,
-          id,
-        ]
-      );
-    });
-
-    return this.getById(id, true);
-  }
-
-  async setDefault(id) {
-    await this.d1.transaction(async (tx) => {
-      await tx.run('UPDATE storage_configs SET is_default = 0');
-      await tx.run('UPDATE storage_configs SET is_default = 1, updated_at = ? WHERE id = ?', [Date.now(), id]);
-    });
-    return this.getById(id, true);
-  }
-
-  async delete(id) {
-    const inUse = this.fileRepo.countByStorageConfigId(id);
-    if (inUse > 0) {
-      throw new Error('Storage config is in use by existing files and cannot be deleted.');
-    }
-    const result = await this.d1.run('DELETE FROM storage_configs WHERE id = ?', [id]);
-    return Number(result.changes || 0) > 0;
-  }
-
-  async ensureBootstrapStorage() {
-    const rows = await this.d1.all('SELECT COUNT(1) AS c FROM storage_configs');
-    const count = rows[0] ? Number(rows[0].c) : 0;
-    if (count > 0) return;
-
-    const bootstrap = this.appConfig.bootstrapDefaultStorage;
-    const type = normalizeStorageType(bootstrap.type || 'telegram');
-    const byType = bootstrap[type] || {};
-
-    const hasRequired = {
-      telegram: Boolean(byType.botToken && byType.chatId),
-      r2: Boolean(byType.endpoint && byType.bucket && byType.accessKeyId && byType.secretAccessKey),
-      s3: Boolean(byType.endpoint && byType.bucket && byType.accessKeyId && byType.secretAccessKey),
-      discord: Boolean(byType.webhookUrl || (byType.botToken && byType.channelId)),
-      huggingface: Boolean(byType.token && byType.repo),
-      webdav: Boolean(byType.baseUrl && (byType.bearerToken || (byType.username && byType.password))),
-      github: Boolean(byType.repo && byType.token),
-    };
-
-    if (!hasRequired[type]) {
-      if (!hasRequired.telegram) return;
-      await this.create({
-        name: 'Telegram (Env Bootstrap)',
-        type: 'telegram',
-        config: bootstrap.telegram,
-        enabled: true,
-        isDefault: true,
-        metadata: { source: 'env-bootstrap', envSource: bootstrap.telegram?.envSource || {} },
-      });
-      return;
-    }
-
-    await this.create({
-      name: `${type.toUpperCase()} (Env Bootstrap)`,
-      type,
-      config: byType,
-      enabled: true,
-      isDefault: true,
-      metadata: { source: 'env-bootstrap', envSource: byType?.envSource || {} },
-    });
-  }
-}
-
-module.exports = {
-  StorageConfigRepositoryD1,
-};

server/lib/settings/d1-store.js

@@ -1,80 +0,0 @@
-/**
- * D1-backed app_settings store.
- */
-function serializeValue(value) {
-  return JSON.stringify(value === undefined ? null : value);
-}
-
-function deserializeValue(valueJson) {
-  if (typeof valueJson !== 'string') return null;
-  try {
-    return JSON.parse(valueJson);
-  } catch {
-    return valueJson;
-  }
-}
-
-class D1SettingsStore {
-  constructor(d1Client) {
-    this.d1 = d1Client;
-  }
-
-  async getAll() {
-    const rows = await this.d1.all('SELECT key, value_json FROM app_settings');
-    const output = {};
-    for (const row of rows) {
-      output[row.key] = deserializeValue(row.value_json);
-    }
-    return output;
-  }
-
-  async getMany(keys = []) {
-    if (!Array.isArray(keys) || keys.length === 0) return {};
-    const result = {};
-    for (const key of keys) {
-      const normalizedKey = String(key || '').trim();
-      if (!normalizedKey) continue;
-      const row = await this.d1.get('SELECT value_json FROM app_settings WHERE key = ?', [normalizedKey]);
-      if (row) result[normalizedKey] = deserializeValue(row.value_json);
-    }
-    return result;
-  }
-
-  async setMany(values = {}) {
-    if (!values || typeof values !== 'object' || Array.isArray(values)) return;
-    const now = Date.now();
-    for (const [rawKey, value] of Object.entries(values)) {
-      const key = String(rawKey || '').trim();
-      if (!key) continue;
-      await this.d1.run(
-        `INSERT INTO app_settings(key, value_json, updated_at) VALUES (?, ?, ?)
-         ON CONFLICT(key) DO UPDATE SET value_json = excluded.value_json, updated_at = excluded.updated_at`,
-        [key, serializeValue(value), now]
-      );
-    }
-  }
-
-  async deleteMany(keys = []) {
-    if (!Array.isArray(keys) || keys.length === 0) return;
-    for (const rawKey of keys) {
-      const key = String(rawKey || '').trim();
-      if (!key) continue;
-      await this.d1.run('DELETE FROM app_settings WHERE key = ?', [key]);
-    }
-  }
-
-  async healthCheck() {
-    try {
-      await this.d1.get('SELECT 1');
-      return { backend: 'd1', connected: true, message: 'Cloudflare D1 app settings store enabled' };
-    } catch (e) {
-      return { backend: 'd1', connected: false, message: String(e?.message || e) };
-    }
-  }
-
-  async close() {}
-}
-
-module.exports = {
-  D1SettingsStore,
-};

server/lib/settings/factory.js

@@ -1,12 +1,7 @@
-const { SqliteSettingsStore } = require('./sqlite-store');
-const { D1SettingsStore } = require('./d1-store');
-
-function createSettingsStore({ db, config, d1Client }) {
-  if (d1Client) {
-    return new D1SettingsStore(d1Client);
-  }
-
-  const mode = String(config.settingsStore || 'sqlite').toLowerCase();
+const { SqliteSettingsStore } = require('./sqlite-store');
+
+function createSettingsStore({ db, config }) {
+  const mode = String(config.settingsStore || 'sqlite').toLowerCase();
 
   if (mode === 'sqlite') {
     return new SqliteSettingsStore(db);