8月10日でパソコン版の「Google ドライブ」アプリによる「Googleフォト」へのバックアップ機能が利用出来なくなるようです。Immichの写真をVM上のWindowsで公式クライアントソフトを使ってリアルタイムにクラウドへも同期したりしているのですが（参考記事）、このためだけにVMでWindowsを起動しておくのも無駄だなと感じていたので、この機会にとrcloneへ移行してみることに。
rcloneの使い方は過去に紹介した事がありますが、多数のフォルダやスケジュールを登録していたりすると少し分かりにくいです。公式でGUIも用意されているようですが、自分専用にとrcloneのWeb-UI「EasyRclone」を作ってみました。
ひとまずGoogleドライブとOneDrive限定にしています。
LXDコンテナにインストール
いつものように、LXDコンテナで下記を貼り付けるだけでインストールできます。3348番ポートで公開しています。
#!/bin/bash
set -e
INSTALL_DIR="/opt/easyrclone"
PORT="${PORT:-3348}"
echo "========================================="
echo " EasyRclone Installer v6"
echo "========================================="
echo ""
if [ "$(id -u)" -ne 0 ]; then
echo "エラー: root で実行してください"
echo " sudo bash $0"
exit 1
fi
echo "[1/6] タイムゾーン設定 (JST)..."
if command -v timedatectl &>/dev/null; then
timedatectl set-timezone Asia/Tokyo 2>/dev/null || true
elif [ -f /usr/share/zoneinfo/Asia/Tokyo ]; then
ln -sf /usr/share/zoneinfo/Asia/Tokyo /etc/localtime
echo "Asia/Tokyo" > /etc/timezone
fi
echo " $(date)"
echo ""
if [ -f /etc/os-release ]; then . /etc/os-release; OS=$ID; else OS=$(uname -s | tr '[:upper:]' '[:lower:]'); fi
echo "OS: $OS"
echo ""
echo "[Tailscale] IP / MagicDNS 検出..."
TS_IP=""
TS_HOSTNAME=""
if command -v tailscale &>/dev/null; then
TS_JSON=$(tailscale status --json 2>/dev/null || true)
if [ -n "$TS_JSON" ]; then
TS_IP=$(echo "$TS_JSON" | python3 -c "import json,sys
try:
d=json.load(sys.stdin)
print(d.get('Self',{}).get('TailscaleIPs',[''])[0])
except Exception:
print('')" 2>/dev/null)
TS_HOSTNAME=$(echo "$TS_JSON" | python3 -c "import json,sys
try:
d=json.load(sys.stdin)
print(d.get('Self',{}).get('DNSName','').rstrip('.'))
except Exception:
print('')" 2>/dev/null)
fi
fi
if [ -n "$TS_IP" ]; then
echo " Tailscale IP: $TS_IP"
else
echo " Tailscale 未検出（ローカルURLのみ表示します）"
fi
echo ""
echo "[2/6] Node.js インストール..."
if command -v node &>/dev/null && [ "$(node -v | sed 's/v//' | cut -d. -f1)" -ge 18 ]; then
echo " Node.js $(node -v) は既にインストール済み"
else
case "$OS" in
ubuntu|debian) curl -fsSL https://deb.nodesource.com/setup_22.x | bash - && apt-get install -y nodejs ;;
centos|rhel|rocky|alma|fedora) curl -fsSL https://rpm.nodesource.com/setup_22.x | bash - && yum install -y nodejs ;;
*) curl -fsSL https://deb.nodesource.com/setup_22.x | bash - && apt-get install -y nodejs 2>/dev/null || yum install -y nodejs ;;
esac
fi
echo " Node.js $(node -v)"
echo ""
echo "[3/6] rclone インストール..."
if ! command -v rclone &>/dev/null; then
curl -fsSL https://rclone.org/install.sh | bash
fi
echo " rclone $(rclone version | head -1)"
echo ""
echo "[4/6] プロジェクト作成..."
mkdir -p "$INSTALL_DIR"/{public/css,public/js,config,sync-jobs}
B64_SERVER='const express = require('express');
const { execSync, spawn } = require('child_process');
const fs = require('fs');
const path = require('path');

const app = express();
const PORT = process.env.PORT || 3348;
const RCLONE_CONFIG_DIR = path.join(__dirname, 'config');
const SYNC_JOBS_DIR = path.join(__dirname, 'sync-jobs');
const CONFIG_PATH = path.join(RCLONE_CONFIG_DIR, 'rclone.conf');

if (!fs.existsSync(RCLONE_CONFIG_DIR)) fs.mkdirSync(RCLONE_CONFIG_DIR, { recursive: true });
if (!fs.existsSync(SYNC_JOBS_DIR)) fs.mkdirSync(SYNC_JOBS_DIR, { recursive: true });

process.env.RCLONE_CONFIG = CONFIG_PATH;

app.use(express.json());
app.use(express.static(path.join(__dirname, 'public')));

function readConfig() {
  if (!fs.existsSync(CONFIG_PATH)) return '';
  return fs.readFileSync(CONFIG_PATH, 'utf-8');
}

function writeConfig(content) {
  fs.writeFileSync(CONFIG_PATH, content.trim() + '\n');
}

function parseRemotes() {
  const content = readConfig();
  if (!content.trim()) return [];
  const remotes = [];
  let current = null;
  for (const line of content.split('\n')) {
    const m = line.match(/^\[(.+)\]$/);
    if (m) {
      if (current) remotes.push(current);
      current = { name: m[1], type: '', params: {} };
    } else if (current && line.includes('=')) {
      const eq = line.indexOf('=');
      const key = line.substring(0, eq).trim();
      const val = line.substring(eq + 1).trim();
      current.params[key] = val;
      if (key === 'type') current.type = val;
    }
  }
  if (current) remotes.push(current);
  return remotes;
}

function rclone(args) {
  try {
    const out = execSync(`rclone ${args.join(' ')}`, {
      timeout: 30000,
      encoding: 'utf-8',
      env: { ...process.env, RCLONE_CONFIG: CONFIG_PATH }
    });
    return { ok: true, data: out.trim() };
  } catch (e) {
    return { ok: false, error: (e.stderr || e.message).trim() };
  }
}

// === Config API ===
app.get('/api/remotes', (req, res) => {
  res.json({ remotes: parseRemotes() });
});

app.post('/api/remotes', (req, res) => {
  const { name, type, params } = req.body;
  if (!name || !type) return res.status(400).json({ error: '名前とタイプは必須です' });
  if (!/^[a-zA-Z0-9_-]+$/.test(name)) return res.status(400).json({ error: '名前は英数字、ハイフン、アンダースコアのみ' });

  const remotes = parseRemotes();
  if (remotes.find(r => r.name === name)) return res.status(409).json({ error: `「${name}」は既に存在します` });

  let section = `[${name}]\ntype = ${type}`;
  for (const [k, v] of Object.entries(params || {})) {
    if (v !== '' && v != null) section += `\n${k} = ${v}`;
  }
  const sep = readConfig().trim() ? '\n' : '';
  fs.appendFileSync(CONFIG_PATH, sep + section + '\n');
  res.json({ ok: true });
});

app.delete('/api/remotes/:name', (req, res) => {
  const { name } = req.params;
  let content = readConfig();
  const re = new RegExp(`\\n?\\[${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\][^\\[]*`, 'g');
  if (!re.test(content)) return res.status(404).json({ error: `「${name}」が見つかりません` });
  content = content.replace(re, '').replace(/\n{3,}/g, '\n\n').trim();
  writeConfig(content);
  res.json({ ok: true });
});

app.post('/api/remotes/:name/test', (req, res) => {
  const { name } = req.params;
  const result = rclone(['lsd', `${name}:`, '--max-depth', '1']);
  if (result.ok) {
    res.json({ ok: true, folders: result.data ? result.data.split('\n').filter(Boolean).map(l => l.split(/\s+/).pop()) : [] });
  } else {
    res.json({ ok: false, error: result.error });
  }
});

// === Sync Settings ===
const SYNC_SETTINGS_PATH = path.join(__dirname, 'config', 'sync-settings.json');

app.get('/api/sync-settings', (req, res) => {
  try {
    if (fs.existsSync(SYNC_SETTINGS_PATH)) {
      const data = JSON.parse(fs.readFileSync(SYNC_SETTINGS_PATH, 'utf-8'));
      res.json({ ok: true, settings: data });
    } else {
      res.json({ ok: true, settings: { pairs: [], schedule: [] } });
    }
  } catch (e) {
    res.json({ ok: true, settings: { pairs: [], schedule: [] } });
  }
});

const CRON_MARKER = '# easyrclone-schedule';
const CRON_SCRIPT = path.join(__dirname, 'cron-sync.sh');

function writeCronScript(pairs) {
  let script = `#!/bin/bash
export RCLONE_CONFIG="${CONFIG_PATH}"
JOBS_DIR="${SYNC_JOBS_DIR}"

run_pair() {
  local src="$1" dest="$2" del="$3" name="$4"
  local jid="job_$(date +%s%N | cut -c1-13)_$(shuf -i 1000-9999 -n1)"
  local jfile="$JOBS_DIR/$jid.json"
  local jtmp="$JOBS_DIR/$jid.tmp"
  local args=""
  if [ "$del" = "true" ]; then args="sync"; else args="copy"; fi
  args="$args --stats 2s --stats-one-line -v"
  rclone $args "$src" "$dest" > "$jtmp" 2>&1
  local code=$?
  local status="completed"
  if [ $code -ne 0 ]; then status="failed"; fi
  local logcontent=""
  if [ -f "$jtmp" ]; then logcontent=$(cat "$jtmp" | tr "\\n" " " | head -c 5000); fi
  local ts=$(date -Iseconds)
  printf '{\\n  "id": "%s",\\n  "name": "%s",\\n  "source": "%s",\\n  "dest": "%s",\\n  "mode": "copy",\\n  "deleteExtra": %s,\\n  "status": "%s",\\n  "log": "%s",\\n  "createdAt": "%s",\\n  "completedAt": "%s"\\n}' \\
    "$jid" "$name" "$src" "$dest" "$del" "$status" "$logcontent" "$ts" "$ts" > "$jfile"
  rm -f "$jtmp"
}

`;
  for (let i = 0; i < pairs.length; i++) {
    const p = pairs[i];
    script += `# Pair ${i + 1}: ${p.source} -> ${p.dest}\n`;
    script += `run_pair "${p.source}" "${p.dest}" "${p.deleteExtra || false}" "${p.source} -> ${p.dest}"\n\n`;
  }
  fs.writeFileSync(CRON_SCRIPT, script);
  fs.chmodSync(CRON_SCRIPT, '755');
}

function buildCronLine(schedule) {
  if (!schedule.length) return '';
  const sorted = [...schedule].sort();
  const groups = {};
  sorted.forEach(t => {
    const [h, m] = t.split(':');
    const min = parseInt(m);
    if (!groups[min]) groups[min] = [];
    groups[min].push(parseInt(h));
  });
  return Object.entries(groups).map(([min, hours]) => {
    return `${min} ${hours.join(',')} * * * ${CRON_SCRIPT} >> ${SYNC_JOBS_DIR}/cron.log 2>&1`;
  }).join('\n');
}

app.post('/api/sync-settings', (req, res) => {
  try {
    const settings = req.body;
    fs.writeFileSync(SYNC_SETTINGS_PATH, JSON.stringify(settings, null, 2));

    // Write sync script
    writeCronScript(settings.pairs || []);

    // Update cron - remove ALL old easyrclone entries
    let cronLines = [];
    try {
      const existing = execSync('crontab -l 2>/dev/null', { encoding: 'utf-8', timeout: 5000 });
      cronLines = existing.split('\n').filter(l => !l.includes('cron-sync.sh') && !l.includes(CRON_MARKER) && l.trim());
    } catch {}

    const cronLine = buildCronLine(settings.schedule || []);
    if (cronLine) {
      cronLines.push('');
      cronLines.push(CRON_MARKER);
      cronLines.push(cronLine);
    }

    const newCron = cronLines.join('\n') + '\n';
    const tmpFile = '/tmp/easyrclone_cron_tmp';
    fs.writeFileSync(tmpFile, newCron);
    execSync(`crontab ${tmpFile}`, { timeout: 5000 });
    fs.unlinkSync(tmpFile);

    res.json({ ok: true });
  } catch (e) {
    res.json({ ok: false, error: e.message });
  }
});

app.get('/api/cron-info', (req, res) => {
  try {
    let output = '';

    // Check user crontab first (most relevant)
    output += '=== root の crontab ===\n';
    try {
      const userCron = execSync('crontab -l 2>/dev/null || echo "(crontabなし)"', { encoding: 'utf-8', timeout: 5000 });
      output += userCron;
    } catch { output += '(crontabなし)\n'; }

    // Check rclone related (from all sources)
    output += '\n=== rclone 関連の cron エントリ ===\n';
    try {
      const rcloneCron = execSync('crontab -l 2>/dev/null | grep -i rclone || echo "(rclone関連のcronエントリなし)"', { encoding: 'utf-8', timeout: 5000 });
      output += rcloneCron;
    } catch { output += '(rclone関連のcronエントリなし)\n'; }

    // Check scheduled sync settings
    output += '\n=== EasyRclone スケジュール設定 ===\n';
    try {
      if (fs.existsSync(SYNC_SETTINGS_PATH)) {
        const settings = JSON.parse(fs.readFileSync(SYNC_SETTINGS_PATH, 'utf-8'));
        output += `同期ペア数: ${(settings.pairs || []).length}\n`;
        output += `スケジュール: ${(settings.schedule || []).join(', ') || '未設定'}\n`;
        (settings.pairs || []).forEach((p, i) => {
          output += `  [${i + 1}] ${p.source} → ${p.dest}${p.deleteExtra ? ' (削除あり)' : ''}\n`;
        });
      } else {
        output += '(設定ファイルなし)\n';
      }
    } catch { output += '(設定読み取りエラー)\n'; }

    // System crontab (brief)
    output += '\n=== システム crontab (抜粋) ===\n';
    try {
      const sysCron = execSync('cat /etc/crontab 2>/dev/null | grep -v "^#" | grep -v "^$" || echo "(ファイルなし)"', { encoding: 'utf-8', timeout: 5000 });
      output += sysCron;
    } catch { output += '(読み取り不可)\n'; }

    // Check systemd timers (rclone related)
    output += '\n=== systemd タイマー (rclone関連) ===\n';
    try {
      const timers = execSync('systemctl list-timers --all --no-pager 2>/dev/null | grep -i rclone || echo "(rclone関連のタイマーなし)"', { encoding: 'utf-8', timeout: 5000 });
      output += timers;
    } catch { output += '(rclone関連のタイマーなし)\n'; }

    res.json({ ok: true, output });
  } catch (e) {
    res.json({ ok: false, error: e.message });
  }
});

// === Temp SSH setup ===
app.post('/api/ssh/setup', (req, res) => {
  try {
    const password = 'rclone';
    execSync(`echo "root:${password}" | chpasswd`, { timeout: 5000 });
    execSync(`sed -i 's/^PasswordAuthentication no/PasswordAuthentication yes/' /etc/ssh/sshd_config.d/60-cloudimg-settings.conf 2>/dev/null || sed -i 's/^#*PasswordAuthentication.*/PasswordAuthentication yes/' /etc/ssh/sshd_config 2>/dev/null || true`, { timeout: 3000 });
    execSync(`grep -q "KbdInteractiveAuthentication yes" /etc/ssh/sshd_config.d/60-cloudimg-settings.conf 2>/dev/null || echo "KbdInteractiveAuthentication yes" >> /etc/ssh/sshd_config.d/60-cloudimg-settings.conf 2>/dev/null || true`, { timeout: 3000 });
    execSync(`grep -q "PermitRootLogin yes" /etc/ssh/sshd_config.d/60-cloudimg-settings.conf 2>/dev/null || echo "PermitRootLogin yes" >> /etc/ssh/sshd_config.d/60-cloudimg-settings.conf 2>/dev/null || true`, { timeout: 3000 });
    execSync(`systemctl restart sshd`, { timeout: 5000 });
    const hostname = execSync('hostname -I | awk \'{print $1}\'', { encoding: 'utf-8' }).trim();
    res.json({ ok: true, password, hostname });
  } catch (e) {
    res.json({ ok: false, error: e.message });
  }
});

app.post('/api/ssh/teardown', (req, res) => {
  try {
    execSync(`passwd -d root 2>/dev/null; true`, { timeout: 5000 });
    execSync(`sed -i 's/^PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config.d/60-cloudimg-settings.conf`, { timeout: 3000 });
    execSync(`sed -i '/^KbdInteractiveAuthentication yes$/d' /etc/ssh/sshd_config.d/60-cloudimg-settings.conf`, { timeout: 3000 });
    execSync(`systemctl restart sshd`, { timeout: 5000 });
    res.json({ ok: true });
  } catch (e) {
    res.json({ ok: false, error: e.message });
  }
});

app.post('/api/ssh/status', (req, res) => {
  try {
    const out = execSync('sshd -T 2>/dev/null | grep passwordauthentication', { encoding: 'utf-8' });
    const enabled = out.includes('yes');
    res.json({ ok: true, enabled });
  } catch (e) {
    res.json({ ok: false, error: e.message });
  }
});

// === Auth: run rclone authorize to get token ===
const authSessions = new Map();

app.post('/api/auth/start', (req, res) => {
  const { type, remoteName } = req.body;
  if (!['drive', 'onedrive'].includes(type)) return res.status(400).json({ error: 'サポートされていないタイプです' });

  // Kill any lingering rclone authorize processes
  try { execSync('pkill -9 -f "rclone authorize"', { timeout: 3000 }); } catch {}

  const sessionId = `auth_${Date.now()}`;
  const args = ['authorize', type, '--auth-no-open-browser'];

  const proc = spawn('rclone', args, {
    env: { ...process.env, RCLONE_CONFIG: CONFIG_PATH },
    stdio: ['pipe', 'pipe', 'pipe']
  });

  let authUrl = '';
  let stdoutBuf = '';

  proc.stderr.on('data', d => {
    const text = d.toString();
    const match = text.match(/(https?:\/\/[^\s"']+\/auth\?state=[^\s"']+)/);
    if (match && !authUrl) {
      authUrl = match[1].replace(/["']$/, '');
    }
  });

  const session = { proc, type, remoteName, token: null, done: false, authUrl: '' };
  authSessions.set(sessionId, session);

  proc.stdout.on('data', d => {
    stdoutBuf += d.toString();
  });

  proc.on('close', (code) => {
    const raw = stdoutBuf.trim();
    console.log(`[Auth ${sessionId}] rclone closed code=${code} stdout=${raw.substring(0, 300)}`);
    // rclone authorize wraps JSON in "Paste the following..." text
    const jsonMatch = raw.match(/(\{[\s\S]*\})/);
    if (jsonMatch) {
      try {
        session.token = JSON.parse(jsonMatch[1]);
        console.log(`[Auth ${sessionId}] token parsed OK`);
      } catch (e) {
        console.log(`[Auth ${sessionId}] token parse FAILED: ${e.message}`);
      }
    }
    session.done = true;
  });

  const check = setInterval(() => {
    if (authUrl && !session.authUrl) session.authUrl = authUrl;
    if (session.done && session.token) {
      console.log(`[Auth ${sessionId}] writing token to config`);
      clearInterval(check);
      writeTokenToConfig(session.remoteName || `remote_${Date.now()}`, session.type, session.token);
      authSessions.delete(sessionId);
    } else if (session.done && !session.token) {
      console.log(`[Auth ${sessionId}] done but no token, stdout was: ${stdoutBuf.substring(0, 200)}`);
    }
  }, 500);

  setTimeout(() => {
    clearInterval(check);
    if (authSessions.has(sessionId)) {
      session.proc.kill();
      authSessions.delete(sessionId);
    }
  }, 300000);

  res.json({ ok: true, sessionId, authUrl: null });
});

app.get('/api/auth/poll/:sessionId', (req, res) => {
  const session = authSessions.get(req.params.sessionId);
  if (!session) return res.json({ done: true, success: false, error: 'セッションが見つかりません' });
  if (session.done && session.token) {
    return res.json({ done: true, success: true });
  }
  if (session.done && !session.token) {
    return res.json({ done: true, success: false, error: 'トークン取得に失敗しました' });
  }
  res.json({ done: false, authUrl: session.authUrl || null });
});

function writeTokenToConfig(remoteName, type, token) {
  const tokenStr = typeof token === 'string' ? token : JSON.stringify(token);
  let content = readConfig();

  const sectionRe = new RegExp(`\\[${remoteName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\][^\\[]*`, 'g');
  if (sectionRe.test(content)) {
    content = content.replace(sectionRe, '').replace(/\n{3,}/g, '\n\n').trim();
  }

  let section = `\n[${remoteName}]\ntype = ${type}`;
  if (type === 'drive') {
    section += `\nscope = drive`;
  } else if (type === 'onedrive') {
    section += `\ndrive_type = personal`;
    // Get drive_id from Microsoft Graph API
    try {
      const tokenObj = typeof token === 'string' ? JSON.parse(token) : token;
      const accessToken = tokenObj.access_token;
      if (accessToken) {
        const result = execSync(`curl -s -H "Authorization: Bearer ${accessToken}" "https://graph.microsoft.com/v1.0/me/drive"`, {
          encoding: 'utf-8', timeout: 10000
        });
        const driveInfo = JSON.parse(result);
        if (driveInfo.id) {
          section += `\ndrive_id = ${driveInfo.id}`;
        }
      }
    } catch (e) {
      console.log(`[Config] Failed to get drive_id for ${remoteName}: ${e.message}`);
    }
  }
  section += `\ntoken = ${tokenStr}`;

  const sep = content.trim() ? '\n' : '';
  fs.writeFileSync(CONFIG_PATH, (content.trim() + sep + section + '\n').trim() + '\n');
}

// === File Browser ===
app.get('/api/browse/:remote/*', (req, res) => {
  const remote = req.params.remote;
  const subPath = req.params[0] || '';
  const target = subPath ? `${remote}:/${subPath}` : `${remote}:`;
  const result = rclone(['lsf', `"${target}"`, '--format', 'tp', '--dirs-only']);
  if (!result.ok && !result.data) return res.json({ items: [], error: result.error });

  const lines = (result.data || '').split('\n').filter(Boolean);
  const items = lines.map(l => {
    const isDir = l.endsWith('/');
    return { name: isDir ? l.slice(0, -1) : l, isDir };
  }).sort((a, b) => b.isDir - a.isDir || a.name.localeCompare(b.name));

  res.json({ items, path: subPath });
});

app.get('/api/browse-files/:remote/*', (req, res) => {
  const remote = req.params.remote;
  const subPath = req.params[0] || '';
  const target = subPath ? `${remote}:/${subPath}` : `${remote}:`;
  const result = rclone(['lsf', `"${target}"`, '--format', 'tp']);
  if (!result.ok && !result.data) return res.json({ items: [], error: result.error });

  const lines = (result.data || '').split('\n').filter(Boolean);
  const items = lines.map(l => {
    const isDir = l.endsWith('/');
    return { name: isDir ? l.slice(0, -1) : l, isDir };
  }).sort((a, b) => b.isDir - a.isDir || a.name.localeCompare(b.name));

  res.json({ items, path: subPath });
});

// === Sync Jobs ===
const JOB_RETENTION_DAYS = 30;

function cleanupOldJobs() {
  try {
    const files = fs.readdirSync(SYNC_JOBS_DIR).filter(f => f.endsWith('.json'));
    const cutoff = Date.now() - JOB_RETENTION_DAYS * 24 * 60 * 60 * 1000;
    for (const f of files) {
      try {
        const job = JSON.parse(fs.readFileSync(path.join(SYNC_JOBS_DIR, f), 'utf-8'));
        const created = new Date(job.createdAt || 0).getTime();
        if (created < cutoff) fs.unlinkSync(path.join(SYNC_JOBS_DIR, f));
      } catch {}
    }
  } catch {}
}

app.get('/api/jobs', (req, res) => {
  try {
    cleanupOldJobs();
    const files = fs.readdirSync(SYNC_JOBS_DIR).filter(f => f.endsWith('.json'));
    const jobs = files.map(f => {
      try { return JSON.parse(fs.readFileSync(path.join(SYNC_JOBS_DIR, f), 'utf-8')); }
      catch { return null; }
    }).filter(Boolean);
    jobs.sort((a, b) => new Date(b.createdAt || 0) - new Date(a.createdAt || 0));
    res.json({ jobs });
  } catch (e) {
    res.json({ jobs: [] });
  }
});

app.post('/api/jobs', (req, res) => {
  const { source, dest, mode, exclude, dryRun, verbose, name, deleteExtra } = req.body;
  if (!source || !dest) return res.status(400).json({ error: 'コピー元とコピー先は必須です' });

  const jobId = `job_${Date.now()}`;
  const job = {
    id: jobId,
    name: name || `${source.split(':')[0]} → ${dest.split(':')[0]}`,
    source, dest,
    mode: mode || 'copy',
    exclude: exclude || '',
    dryRun: !!dryRun,
    verbose: !!verbose,
    deleteExtra: !!deleteExtra,
    status: 'running',
    log: '',
    createdAt: new Date().toISOString()
  };
  fs.writeFileSync(path.join(SYNC_JOBS_DIR, `${jobId}.json`), JSON.stringify(job, null, 2));

  const args = [deleteExtra ? 'sync' : 'copy'];
  args.push('--stats', '2s', '--stats-one-line', '-v');
  if (dryRun) args.push('--dry-run');
  if (exclude) args.push('--exclude', exclude);
  args.push(source, dest);

  const jobFile = path.join(SYNC_JOBS_DIR, `${jobId}.json`);
  const proc = spawn('rclone', args, {
    env: { ...process.env, RCLONE_CONFIG: CONFIG_PATH },
    stdio: ['pipe', 'pipe', 'pipe']
  });
  let logBuf = '';
  proc.stdout.on('data', d => { logBuf += d.toString(); });
  proc.stderr.on('data', d => { logBuf += d.toString(); });
  const saveLog = setInterval(() => {
    if (logBuf) {
      job.log = logBuf;
      try { fs.writeFileSync(jobFile, JSON.stringify(job, null, 2)); } catch {}
    }
  }, 500);
  proc.on('close', (code) => {
    clearInterval(saveLog);
    job.status = code === 0 ? 'completed' : 'failed';
    job.completedAt = new Date().toISOString();
    job.log = logBuf || '(no output)';
    job.exitCode = code;
    try { fs.writeFileSync(jobFile, JSON.stringify(job, null, 2)); } catch {}
  });

  res.json({ jobId, status: 'running' });
});

app.delete('/api/jobs/:id', (req, res) => {
  const f = path.join(SYNC_JOBS_DIR, `${req.params.id}.json`);
  if (fs.existsSync(f)) { fs.unlinkSync(f); res.json({ ok: true }); }
  else res.status(404).json({ error: 'ジョブが見つかりません' });
});

app.post('/api/jobs/:id/stop', (req, res) => {
  const f = path.join(SYNC_JOBS_DIR, `${req.params.id}.json`);
  if (!fs.existsSync(f)) return res.status(404).json({ error: 'ジョブが見つかりません' });
  const job = JSON.parse(fs.readFileSync(f, 'utf-8'));
  job.status = 'stopped';
  job.completedAt = new Date().toISOString();
  fs.writeFileSync(f, JSON.stringify(job, null, 2));
  try { execSync(`kill $(pgrep -f "rclone.*${req.params.id}" | head -1) 2>/dev/null`); } catch {}
  res.json({ ok: true });
});

// === Size ===
app.get('/api/size/:remote/*', (req, res) => {
  const target = req.params[0] ? `${req.params.remote}:/${req.params[0]}` : `${req.params.remote}:`;
  const result = rclone(['size', `"${target}"`, '--json']);
  if (result.ok) { try { return res.json(JSON.parse(result.data)); } catch {} }
  res.json({ error: result.error || 'サイズ取得に失敗' });
});

app.get('*', (req, res) => {
  res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

const server = app.listen(PORT, '0.0.0.0', () => {
  console.log(`\n  🚀 EasyRclone GUI 起動`);
  console.log(`  📡 http://localhost:${PORT}\n`);
});
'
B64_HTML='<!DOCTYPE html>
<html lang="ja">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>EasyRclone</title>
  <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><rect rx='20' width='100' height='100' fill='%232563eb'/><text x='50' y='68' font-size='60' text-anchor='middle' fill='white' font-family='Arial' font-weight='bold'>C</text></svg>">
  <link rel="stylesheet" href="/css/style.css">
</head>
<body>
  <header class="app-header">
    <div class="header-left">
      <svg class="logo" width="28" height="28" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
        <path d="M12 2L2 7l10 5 10-5-10-5z"/><path d="M2 17l10 5 10-5"/><path d="M2 12l10 5 10-5"/>
      </svg>
      <h1>EasyRclone</h1>
    </div>
    <div class="header-right">
      <button class="btn btn-ghost" onclick="openAddModal('drive')">+ Googleドライブ</button>
      <button class="btn btn-ghost" onclick="openAddModal('onedrive')">+ OneDrive</button>
      <button class="btn btn-ghost" onclick="exportSettings()">📤 エクスポート</button>
      <button class="btn btn-ghost" onclick="importSettings()">📥 インポート</button>
      <button class="btn btn-ghost nav-btn" data-page="jobs" onclick="showPage('jobs')">📋 履歴</button>
    </div>
  </header>

  <main class="content">
    <div id="page-main" class="page active">
      <div id="remote-cards"></div>

      <div class="schedule-section" id="schedule-section" style="display:none">
        <div class="card">
          <h3>🕐 スケジュール設定（全ペア対象）</h3>
          <div style="display:flex;gap:8px;align-items:center;margin-bottom:8px">
            <select id="schedule-time-select" style="width:60px;padding:6px 4px;border:1px solid var(--border);border-radius:var(--radius-sm);font-size:0.85rem">
              <option value="">時</option>
              <option value="0">0</option><option value="1">1</option><option value="2">2</option>
              <option value="3">3</option><option value="4">4</option><option value="5">5</option>
              <option value="6">6</option><option value="7">7</option><option value="8">8</option>
              <option value="9">9</option><option value="10">10</option><option value="11">11</option>
              <option value="12">12</option><option value="13">13</option><option value="14">14</option>
              <option value="15">15</option><option value="16">16</option><option value="17">17</option>
              <option value="18">18</option><option value="19">19</option><option value="20">20</option>
              <option value="21">21</option><option value="22">22</option><option value="23">23</option>
            </select>
            <select id="schedule-min-select" style="width:70px;padding:6px 10px;border:1px solid var(--border);border-radius:var(--radius-sm);font-size:0.85rem">
              <option value="00">:00</option><option value="15">:15</option><option value="30">:30</option><option value="45">:45</option>
            </select>
            <button class="btn btn-outline btn-sm" onclick="addSyncSchedule()">追加</button>
          </div>
          <div id="sync-schedule-list"></div>
          <button class="btn btn-primary btn-sm" onclick="saveSchedule()" style="margin-top:8px">スケジュール保存</button>
          <button class="btn btn-outline btn-sm" onclick="showCronInfo()" style="margin-top:8px">cron設定確認</button>
          <div id="cron-info-area" style="display:none;margin-top:12px">
            <pre id="cron-info-content" style="background:#1e293b;color:#a5f3fc;padding:12px;border-radius:var(--radius-sm);font-size:0.8rem;overflow-x:auto;white-space:pre-wrap"></pre>
          </div>
        </div>
      </div>
    </div>

    <div id="page-jobs" class="page">
      <div class="page-header">
        <h2>ジョブ履歴</h2>
        <button class="btn btn-outline btn-sm" onclick="showPage('main')">← 戻る</button>
      </div>
      <div id="job-list"></div>
    </div>
  </main>

  <!-- Add Remote Modal -->
  <div id="modal-add" class="modal-overlay" onclick="closeModalBg(event)">
    <div class="modal" onclick="event.stopPropagation()">
      <div class="modal-header">
        <h3 id="modal-title"></h3>
        <button class="modal-close" onclick="closeModal()">×</button>
      </div>
      <div class="modal-body" id="modal-body"></div>
    </div>
  </div>

  <!-- Auth Flow Modal -->
  <div id="modal-auth" class="modal-overlay" onclick="closeModalBg(event)">
    <div class="modal modal-auth" onclick="event.stopPropagation()">
      <div class="modal-header">
        <h3>🔗 アカウント認証</h3>
        <button class="modal-close" onclick="closeModal()">×</button>
      </div>
      <div class="modal-body">
        <p id="auth-status" style="margin:0 0 12px;font-size:0.9rem;color:var(--text2);font-weight:500"></p>
        <div id="auth-url-area" style="display:none">
          <div class="ssh-tunnel-box">
            <div class="ssh-tunnel-label">1. SSHトンネルを接続:</div>
            <div class="ssh-tunnel-cmd"><code id="ssh-cmd"></code><button class="btn btn-outline btn-sm" onclick="copySshCmd()">📋</button></div>
          </div>
          <div class="auth-url-box" style="margin-top:8px">
            <div style="font-size:0.8rem;font-weight:600;color:var(--text2);margin-bottom:4px">2. ブラウザでログイン:</div>
            <div style="display:flex;gap:8px;align-items:center">
              <input type="text" id="auth-url-input" readonly class="auth-url-input">
              <a id="auth-url-link" href="#" target="_blank" class="btn btn-primary btn-sm">開く</a>
              <button class="btn btn-outline btn-sm" onclick="copyAuthUrl()">📋</button>
            </div>
          </div>
        </div>
        <div id="auth-done-area" style="display:none;text-align:center;padding:20px 0">
          <p style="color:var(--success);font-weight:600;font-size:1.1rem">✅ 認証完了</p>
        </div>
      </div>
    </div>
  </div>

  <!-- Sync Pair Add Modal -->
  <div id="modal-sync-pair" class="modal-overlay" onclick="closeModalBg(event)">
    <div class="modal" style="max-width:600px" onclick="event.stopPropagation()">
      <div class="modal-header">
        <h3>同期ペアを追加</h3>
        <button class="modal-close" onclick="closeModal()">×</button>
      </div>
      <div class="modal-body">
        <div class="form-group">
          <label>コピー元（サーバー側）</label>
          <input type="text" id="pair-source" placeholder="/opt/lxd-data/file">
        </div>
        <div class="form-group">
          <label>コピー先（クラウド側）</label>
          <div style="display:flex;gap:0">
            <span class="sync-prefix" id="pair-prefix">gdrive:</span>
            <input type="text" id="pair-dest" class="sync-input-dest" placeholder="/backup">
          </div>
        </div>
        <label class="checkbox" style="margin:8px 0"><input type="checkbox" id="pair-delete"><span style="font-size:0.85rem">コピー元にないファイルをコピー先で削除</span></label>
        <div style="margin-top:16px;display:flex;gap:8px;justify-content:flex-end">
          <button class="btn btn-outline" onclick="closeModal()">キャンセル</button>
          <button class="btn btn-primary" onclick="saveSyncPair()">追加</button>
        </div>
      </div>
    </div>
  </div>

  <div id="toast" class="toast"></div>
  <script src="/js/app.js?v=6"></script>
</body>
</html>
'
B64_JS='let allRemotes = [];
let syncPairs = [];
let syncSchedule = [];
let jobHistory = [];
let authType = '';
let authRemoteName = '';
let authSessionId = '';
let authPollTimer = null;
let addingPairFor = '';
let dismissedErrors = new Set(JSON.parse(localStorage.getItem('easyrclone_dismissed') || '[]'));

async function api(url, opts = {}) {
  const res = await fetch(url, {
    method: opts.method || 'GET',
    headers: opts.body ? { 'Content-Type': 'application/json' } : undefined,
    body: opts.body ? JSON.stringify(opts.body) : undefined
  });
  return res.json();
}

async function loadAll() {
  const data = await api('/api/remotes');
  allRemotes = data.remotes || [];
  const settings = await api('/api/sync-settings');
  syncPairs = settings.settings?.pairs || [];
  syncSchedule = settings.settings?.schedule || [];
  const jobs = await api('/api/jobs');
  jobHistory = jobs.jobs || [];
  renderAll();
}

function showToast(msg, type = 'info') {
  const t = document.getElementById('toast');
  t.textContent = msg;
  t.className = `toast ${type} show`;
  clearTimeout(t._timer);
  t._timer = setTimeout(() => t.classList.remove('show'), 4000);
}

function showPage(name) {
  document.querySelectorAll('.page').forEach(p => p.classList.remove('active'));
  document.getElementById('page-' + name).classList.add('active');
  document.querySelectorAll('.nav-btn').forEach(b => b.classList.toggle('active', b.dataset.page === name));
  if (name === 'main') loadAll();
  if (name === 'jobs') loadJobs();
}

function closeModal() {
  document.querySelectorAll('.modal-overlay').forEach(m => m.classList.remove('open'));
}
function closeModalBg(e) { if (e.target === e.currentTarget) closeModal(); }

function esc(s) { return String(s).replace(/'/g, "\\'").replace(/"/g, '&quot;'); }

function dismissError(source, dest) {
  dismissedErrors.add(`${source}→${dest}`);
  localStorage.setItem('easyrclone_dismissed', JSON.stringify([...dismissedErrors]));
  showPage('jobs');
}

// === Render ===
function renderAll() {
  const container = document.getElementById('remote-cards');
  const schedSection = document.getElementById('schedule-section');

  if (!allRemotes.length) {
    container.innerHTML = '<div class="empty-state"><div class="empty-icon">☁️</div><h3>アカウントが未登録です</h3><p>右上のボタンからクラウドアカウントを追加してください</p></div>';
    schedSection.style.display = 'none';
    return;
  }

  let html = '';
  for (const r of allRemotes) {
    const pairs = syncPairs.filter(p => p.remoteName === r.name);
    html += `
    <div class="card remote-card">
      <div class="remote-card-header">
        <div class="remote-card-left">
          <div class="remote-icon ${r.type}">${r.type === 'drive' ? 'G' : 'O'}</div>
          <div>
            <div class="remote-card-name">${esc(r.name)}</div>
            <div class="remote-card-type">${r.type === 'drive' ? 'Google ドライブ' : 'OneDrive'}</div>
          </div>
        </div>
        <div class="remote-card-actions">
          <button class="btn btn-outline btn-sm" onclick="setupSsh()">🔧 一時SSH設定</button>
          <button class="btn btn-primary btn-sm" onclick="startAuthFlow('${esc(r.name)}','${r.type}')">🔑 認証</button>
          <button class="btn btn-outline btn-sm" onclick="testRemote('${esc(r.name)}')">🔗 テスト</button>
          <button class="btn btn-outline btn-sm" onclick="teardownSsh()">🗑 一時SSH削除</button>
          <button class="btn btn-success btn-sm" onclick="openAddPair('${esc(r.name)}','${r.type}')">＋ 同期ペア追加</button>
          <button class="btn btn-danger btn-sm" onclick="deleteRemote('${esc(r.name)}')">🗑 削除</button>
        </div>
      </div>`;

    if (pairs.length) {
      html += '<div class="sync-pairs-area">';
      for (let i = 0; i < pairs.length; i++) {
        const pi = syncPairs.indexOf(pairs[i]);
        const p = pairs[i];
        const pairJobs = jobHistory.filter(j => j.source === p.source && j.dest === p.dest);
        const errorKey = `${p.source}→${p.dest}`;
        const hasError = pairJobs.some(j => j.status === 'failed') && !dismissedErrors.has(errorKey);
        const errorLink = hasError ? `<span class="sync-error-link" onclick="dismissError('${esc(p.source)}','${esc(p.dest)}')">同期エラーあり</span>` : '';
        html += `
        <div class="sync-pair-row">
          <div class="sync-pair-left">
            <span class="sync-pair-path">${esc(p.source)}</span>
            <span class="sync-arrow">→</span>
            <span class="sync-pair-path">${esc(p.dest)}</span>
            ${p.deleteExtra ? '<span class="tag tag-red">削除あり</span>' : ''}
          </div>
          <div class="sync-pair-right">
            ${errorLink}
            <button class="btn btn-primary btn-sm" onclick="syncPairNow(${pi})">🔄 同期</button>
            <button class="btn btn-outline btn-sm" onclick="editPair(${pi})">✏️ 編集</button>
            <button class="btn btn-danger btn-sm" onclick="deletePair(${pi})">🗑</button>
          </div>
        </div>`;
      }
      html += '</div>';
    }
    html += '</div>';
  }
  container.innerHTML = html;

  if (syncPairs.length) {
    schedSection.style.display = '';
    renderSyncSchedule();
  } else {
    schedSection.style.display = 'none';
  }
}

// === Remote Actions ===
async function testRemote(n) {
  showToast('テスト中...', 'info');
  const d = await api(`/api/remotes/${n}/test`, { method: 'POST' });
  showToast(d.ok ? `✅ ${n} 接続成功` : `❌ 失敗: ${(d.error || '').substring(0, 80)}`, d.ok ? 'success' : 'error');
}

async function deleteRemote(n) {
  if (!confirm(`「${n}」を削除しますか？`)) return;
  const d = await api(`/api/remotes/${n}`, { method: 'DELETE' });
  if (d.ok) { showToast('削除しました', 'success'); loadAll(); }
  else showToast(d.error || '失敗', 'error');
}

// === SSH ===
async function setupSsh() {
  showToast('SSH設定中...', 'info');
  const d = await api('/api/ssh/setup', { method: 'POST' });
  if (d.ok) {
    alert(`SSH一時設定完了\n\nホスト: ${d.hostname}\nユーザー: root\nパスワード: ${d.password}\n\n接続:\nssh -L 53682:127.0.0.1:53682 root@${d.hostname}`);
    showToast('SSH有効', 'success');
  } else showToast('失敗: ' + (d.error || ''), 'error');
}

async function teardownSsh() {
  if (!confirm('一時SSH設定を削除しますか？')) return;
  const d = await api('/api/ssh/teardown', { method: 'POST' });
  showToast(d.ok ? '✅ 削除しました' : '失敗', d.ok ? 'success' : 'error');
}

// === Add Remote ===
function openAddModal(type) {
  authType = type;
  const title = type === 'drive' ? 'Google ドライブを追加' : 'OneDrive を追加';
  document.getElementById('modal-title').textContent = title;
  const defaultName = type === 'drive' ? 'gdrive' : 'onedrive';
  document.getElementById('modal-body').innerHTML = `
    <div class="form-group">
      <label>リモート名</label>
      <input type="text" id="add-name" value="${defaultName}">
    </div>
    <div style="margin-top:16px;display:flex;gap:8px">
      <button class="btn btn-primary" onclick="addRemoteOnly()">追加する</button>
      <button class="btn btn-outline" onclick="closeModal()">キャンセル</button>
    </div>`;
  document.getElementById('modal-add').classList.add('open');
}

async function addRemoteOnly() {
  const name = document.getElementById('add-name').value.trim();
  if (!name) { showToast('名前を入力', 'error'); return; }
  const d = await api('/api/remotes', { method: 'POST', body: { name, type: authType, params: {} } });
  if (!d.ok) { showToast(d.error || '失敗', 'error'); return; }
  showToast(`「${name}」を追加しました`, 'success');
  closeModal();
  loadAll();
}

// === Auth ===
function startAuthFlow(name, type) {
  authRemoteName = name;
  authType = type;
  if (authPollTimer) { clearInterval(authPollTimer); authPollTimer = null; }
  document.getElementById('auth-status').textContent = '認証サーバー起動中...';
  document.getElementById('auth-url-area').style.display = 'none';
  document.getElementById('auth-done-area').style.display = 'none';
  document.getElementById('modal-auth').classList.add('open');

  fetch('/api/auth/start', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ type, remoteName: name })
  }).then(r => r.json()).then(data => {
    if (!data.ok) { document.getElementById('auth-status').textContent = 'エラー: ' + (data.error || ''); return; }
    authSessionId = data.sessionId;
    if (data.authUrl) showUrl(data.authUrl);
    authPollTimer = setInterval(pollAuth, 1500);
    pollAuth();
  }).catch(e => { document.getElementById('auth-status').textContent = 'エラー: ' + e.message; });
}

function pollAuth() {
  if (!authSessionId) return;
  fetch(`/api/auth/poll/${authSessionId}`).then(r => r.json()).then(data => {
    if (data.authUrl) showUrl(data.authUrl);
    if (data.done) {
      clearInterval(authPollTimer); authPollTimer = null;
      if (data.success) {
        document.getElementById('auth-done-area').style.display = '';
        document.getElementById('auth-status').textContent = '';
        setTimeout(() => { closeModal(); showToast(`「${authRemoteName}」認証完了`, 'success'); loadAll(); }, 2000);
      } else {
        document.getElementById('auth-status').textContent = '❌ ' + (data.error || '失敗');
      }
    }
  }).catch(() => {});
}

function showUrl(url) {
  document.getElementById('auth-url-area').style.display = '';
  document.getElementById('auth-url-input').value = url;
  document.getElementById('auth-url-link').href = url;
  const m = url.match(/http:\/\/[\d.]+:(\d+)/);
  const port = m ? m[1] : '53682';
  document.getElementById('auth-status').textContent = 'SSHトンネル接続後、下のURLを開いてください';
  document.getElementById('ssh-cmd').textContent = `ssh -L ${port}:127.0.0.1:${port} root@${location.hostname}`;
}

function copyAuthUrl() {
  const e = document.getElementById('auth-url-input');
  e.select(); e.setSelectionRange(0, 99999);
  try { document.execCommand('copy'); showToast('コピーしました', 'success'); } catch { showToast('失敗', 'error'); }
}

function copySshCmd() {
  const e = document.getElementById('ssh-cmd');
  const t = document.createElement('textarea');
  t.value = e.textContent; document.body.appendChild(t); t.select();
  try { document.execCommand('copy'); showToast('コピーしました', 'success'); } catch { showToast('失敗', 'error'); }
  document.body.removeChild(t);
}

// === Sync Pairs ===
function openAddPair(remoteName, remoteType) {
  addingPairFor = remoteName;
  const prefix = remoteType === 'drive' ? `${remoteName}:` : `${remoteName}:`;
  document.getElementById('pair-prefix').textContent = prefix;
  document.getElementById('pair-source').value = '';
  document.getElementById('pair-dest').value = '';
  document.getElementById('pair-delete').checked = false;
  document.getElementById('modal-sync-pair').classList.add('open');
}

async function saveSyncPair() {
  const source = document.getElementById('pair-source').value.trim();
  const pathOnly = document.getElementById('pair-dest').value.trim();
  const prefix = document.getElementById('pair-prefix').textContent;
  const deleteExtra = document.getElementById('pair-delete').checked;
  if (!source) { showToast('コピー元を入力', 'error'); return; }
  if (!pathOnly) { showToast('コピー先を入力', 'error'); return; }

  if (editingPairIdx >= 0) {
    syncPairs[editingPairIdx] = { source, dest: prefix + pathOnly, deleteExtra, remoteName: addingPairFor };
    showToast('同期ペアを更新しました', 'success');
  } else {
    syncPairs.push({ source, dest: prefix + pathOnly, deleteExtra, remoteName: addingPairFor });
    showToast('同期ペアを追加しました', 'success');
  }
  editingPairIdx = -1;
  await saveSettings();
  closeModal();
  loadAll();
}

async function deletePair(idx) {
  if (!confirm('この同期ペアを削除しますか？')) return;
  syncPairs.splice(idx, 1);
  await saveSettings();
  showToast('削除しました', 'success');
  loadAll();
}

async function syncPairNow(idx) {
  const p = syncPairs[idx];
  if (!p) return;
  showToast('同期開始...', 'info');
  const d = await api('/api/jobs', {
    method: 'POST',
    body: { source: p.source, dest: p.dest, mode: 'copy', name: `${p.source} → ${p.dest}`, deleteExtra: p.deleteExtra }
  });
  if (d.jobId) { showToast(`ジョブ ${d.jobId} 開始`, 'success'); showPage('jobs'); }
  else showToast(d.error || '失敗', 'error');
}

let editingPairIdx = -1;

function editPair(idx) {
  editingPairIdx = idx;
  const p = syncPairs[idx];
  const remoteName = p.remoteName || allRemotes[0]?.name || 'gdrive';
  addingPairFor = remoteName;
  const remoteType = allRemotes.find(r => r.name === remoteName)?.type || 'drive';
  const prefix = `${remoteName}:`;
  let pathOnly = p.dest || '';
  if (pathOnly.startsWith(prefix)) pathOnly = pathOnly.substring(prefix.length);

  document.getElementById('pair-source').value = p.source || '';
  document.getElementById('pair-dest').value = pathOnly;
  document.getElementById('pair-delete').checked = p.deleteExtra || false;
  document.getElementById('pair-prefix').textContent = prefix;
  document.getElementById('modal-sync-pair').classList.add('open');
}

async function saveSettings() {
  await api('/api/sync-settings', { method: 'POST', body: { pairs: syncPairs, schedule: syncSchedule } });
}

// === Schedule ===
function renderSyncSchedule() {
  const el = document.getElementById('sync-schedule-list');
  if (!syncSchedule.length) {
    el.innerHTML = '<div style="padding:8px;color:var(--text3);font-size:0.85rem">未設定</div>';
    return;
  }
  el.innerHTML = syncSchedule.map((t, i) => `
    <div class="sync-schedule-item">
      <span class="sync-schedule-time">🕐 ${t}</span>
      <button class="btn btn-danger btn-sm" onclick="syncSchedule.splice(${i},1);renderSyncSchedule()">🗑</button>
    </div>
  `).join('');
}

function addSyncSchedule() {
  const hourSelect = document.getElementById('schedule-time-select');
  const minSelect = document.getElementById('schedule-min-select');
  const hour = hourSelect.value;
  const min = minSelect.value;
  if (!hour && hour !== '0') { showToast('時間を選択してください', 'error'); return; }
  const h = hour.padStart(2, '0');
  const time = `${h}:${min}`;
  if (syncSchedule.includes(time)) { showToast('重複しています', 'error'); return; }
  syncSchedule.push(time);
  syncSchedule.sort();
  renderSyncSchedule();
  hourSelect.value = '';
  minSelect.value = '00';
}

async function saveSchedule() {
  await api('/api/sync-settings', { method: 'POST', body: { pairs: syncPairs, schedule: syncSchedule } });
  showToast('スケジュールを保存しました', 'success');
}

function exportSettings() {
  const data = { pairs: syncPairs, schedule: syncSchedule, exportedAt: new Date().toISOString() };
  const blob = new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' });
  const url = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = url;
  a.download = `easyrclone-settings-${new Date().toISOString().slice(0,10)}.json`;
  a.click();
  URL.revokeObjectURL(url);
  showToast('設定をエクスポートしました', 'success');
}

function importSettings() {
  const input = document.createElement('input');
  input.type = 'file';
  input.accept = '.json';
  input.onchange = async (e) => {
    const file = e.target.files[0];
    if (!file) return;
    try {
      const text = await file.text();
      const data = JSON.parse(text);
      if (data.pairs && data.schedule) {
        syncPairs = data.pairs;
        syncSchedule = data.schedule;
        await saveSettings();
        showToast('設定をインポートしました', 'success');
        loadAll();
      } else {
        showToast('無効な設定ファイルです', 'error');
      }
    } catch (e) {
      showToast('読み込みエラー: ' + e.message, 'error');
    }
  };
  input.click();
}

async function showCronInfo() {
  const area = document.getElementById('cron-info-area');
  const content = document.getElementById('cron-info-content');
  if (area.style.display === '') { area.style.display = 'none'; return; }
  area.style.display = '';
  content.textContent = '読み込み中...';
  const d = await api('/api/cron-info');
  content.textContent = d.ok ? d.output : 'エラー: ' + (d.error || '');
}

// === Jobs ===
async function loadJobs() {
  const data = await api('/api/jobs');
  const list = document.getElementById('job-list');
  if (!data.jobs?.length) {
    list.innerHTML = '<div class="empty-state"><div class="empty-icon">📋</div><h3>ジョブがありません</h3></div>';
    return;
  }
  list.innerHTML = data.jobs.map(j => {
    const sl = { running: '⏳ 実行中', completed: '✅ 完了', failed: '❌ 失敗', stopped: '⏹ 停止' }[j.status] || j.status;
    const logLines = (j.log || '').split('\n').filter(Boolean);
    const lastLines = logLines.slice(-20).join('\n');
    return `
    <div class="job-card">
      <div class="job-card-top">
        <span class="job-card-name">${esc(j.name || j.id)}</span>
        <span class="job-status ${j.status}">${sl}</span>
      </div>
      <div class="job-card-paths"><span>${esc(j.source)}</span><span>→</span><span>${esc(j.dest)}</span></div>
      <div class="job-card-meta">
        <div>${new Date(j.createdAt).toLocaleString('ja-JP')}${j.completedAt ? ' → ' + new Date(j.completedAt).toLocaleString('ja-JP') : ''}</div>
      </div>
      ${lastLines ? `<div class="job-log"><pre>${esc(lastLines)}</pre></div>` : ''}
    </div>`;
  }).join('');

  if (data.jobs.some(j => j.status === 'running')) setTimeout(loadJobs, 2000);
}

document.addEventListener('DOMContentLoaded', () => loadAll());
'
B64_CSS=':root {
  --primary: #2563eb;
  --primary-hover: #1d4ed8;
  --primary-light: #eff6ff;
  --bg: #f1f5f9;
  --card: #ffffff;
  --text: #0f172a;
  --text2: #334155;
  --text3: #64748b;
  --border: #e2e8f0;
  --border2: #cbd5e1;
  --success: #16a34a;
  --success-bg: #f0fdf4;
  --danger: #dc2626;
  --danger-bg: #fef2f2;
  --warning: #d97706;
  --warning-bg: #fffbeb;
  --drive: #4285f4;
  --onedrive: #0078d4;
  --radius: 10px;
  --radius-sm: 6px;
  --shadow: 0 1px 3px rgba(0,0,0,0.08);
  --shadow-md: 0 4px 12px rgba(0,0,0,0.1);
}

* { margin: 0; padding: 0; box-sizing: border-box; }
body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Hiragino Sans', 'Yu Gothic', sans-serif; background: var(--bg); color: var(--text); min-height: 100vh; }

/* Header */
.app-header {
  background: linear-gradient(135deg, #1e3a5f 0%, #2563eb 100%);
  color: white; padding: 0 24px; height: 56px;
  display: flex; align-items: center; justify-content: space-between;
  position: sticky; top: 0; z-index: 100;
  box-shadow: 0 2px 8px rgba(0,0,0,0.15);
}
.header-left { display: flex; align-items: center; gap: 10px; }
.header-left h1 { font-size: 1.1rem; font-weight: 700; }
.header-left .subtitle { font-size: 0.75rem; opacity: 0.7; }
.header-right { display: flex; gap: 4px; }
.logo { opacity: 0.9; }

.btn-ghost {
  background: rgba(255,255,255,0.1); border: 1px solid rgba(255,255,255,0.2);
  color: white; padding: 6px 14px; border-radius: var(--radius-sm);
  cursor: pointer; font-size: 0.82rem; font-weight: 500; transition: all 0.15s;
}
.btn-ghost:hover { background: rgba(255,255,255,0.2); }
.btn-ghost.active { background: rgba(255,255,255,0.25); border-color: rgba(255,255,255,0.4); }

/* Layout */
.content { max-width: 1100px; margin: 0 auto; padding: 24px 16px; }
.page { display: none; }
.page.active { display: block; }

.page-header { margin-bottom: 20px; }
.page-header h2 { font-size: 1.4rem; font-weight: 700; margin-bottom: 4px; }
.page-header .desc { color: var(--text3); font-size: 0.9rem; }

/* Cards */
.card {
  background: var(--card); border: 1px solid var(--border); border-radius: var(--radius);
  padding: 20px; margin-bottom: 16px; box-shadow: var(--shadow);
}
.card h3 { font-size: 1rem; font-weight: 600; margin-bottom: 14px; }

/* Add Buttons */
.add-buttons { display: flex; gap: 16px; margin-top: 20px; }
.add-card {
  flex: 1; display: flex; align-items: center; gap: 16px;
  padding: 20px 24px; border-radius: var(--radius); cursor: pointer;
  border: 2px dashed var(--border2); background: var(--card);
  transition: all 0.2s; text-align: left;
}
.add-card:hover { border-color: var(--primary); background: var(--primary-light); transform: translateY(-1px); box-shadow: var(--shadow-md); }
.add-card-icon { flex-shrink: 0; }
.add-card-label strong { display: block; font-size: 1rem; color: var(--text); }
.add-card-label span { font-size: 0.8rem; color: var(--text3); }

/* Remote Cards */
.remote-cards { display: grid; gap: 16px; }
.remote-card {
  padding: 16px 20px; background: var(--card); border: 1px solid var(--border);
  border-radius: var(--radius); box-shadow: var(--shadow);
}
.remote-card-left { display: flex; align-items: center; gap: 14px; }
.remote-icon {
  width: 44px; height: 44px; border-radius: 10px;
  display: flex; align-items: center; justify-content: center;
  color: white; font-weight: 700; font-size: 1.1rem;
}
.remote-icon.drive { background: var(--drive); }
.remote-icon.onedrive { background: var(--onedrive); }
.remote-card-name { font-weight: 600; font-size: 0.95rem; }
.remote-card-type { font-size: 0.8rem; color: var(--text3); margin-top: 2px; }
.remote-card-actions { display: flex; gap: 6px; }

/* Empty State */
.empty-state { text-align: center; padding: 40px 20px; color: var(--text3); }
.empty-icon { font-size: 2.5rem; margin-bottom: 8px; opacity: 0.6; }
.empty-state h3 { font-size: 1rem; color: var(--text2); margin-bottom: 4px; }
.empty-state p { font-size: 0.85rem; }

/* Buttons */
.btn {
  padding: 8px 16px; border-radius: var(--radius-sm); font-size: 0.85rem;
  font-weight: 500; cursor: pointer; border: none; transition: all 0.15s;
  display: inline-flex; align-items: center; gap: 6px;
}
.btn-primary { background: var(--primary); color: white; }
.btn-primary:hover { background: var(--primary-hover); }
.btn-danger { background: var(--danger); color: white; }
.btn-danger:hover { background: #b91c1c; }
.btn-success { background: var(--success); color: white; }
.btn-success:hover { background: #15803d; }
.btn-outline { background: transparent; border: 1px solid var(--border2); color: var(--text2); }
.btn-outline:hover { background: var(--bg); }
.btn-sm { padding: 5px 10px; font-size: 0.78rem; }
.btn-lg { padding: 12px 28px; font-size: 0.95rem; }
.btn:disabled { opacity: 0.5; cursor: not-allowed; }

/* Direction */
.direction-card .direction-grid { display: grid; grid-template-columns: repeat(4, 1fr); gap: 10px; }
.dir-btn {
  display: flex; flex-direction: column; align-items: center; gap: 6px;
  padding: 16px 12px; border: 2px solid var(--border); border-radius: var(--radius);
  background: var(--card); cursor: pointer; transition: all 0.15s;
}
.dir-btn:hover { border-color: var(--primary); }
.dir-btn.active { border-color: var(--primary); background: var(--primary-light); }
.dir-arrow { font-size: 1.8rem; color: var(--primary); font-weight: 700; }
.dir-label { font-size: 0.85rem; font-weight: 600; color: var(--text2); line-height: 1.3; }
.dir-label small { font-weight: 400; color: var(--text3); }

/* Browser Panels */
.browser-panels { display: grid; grid-template-columns: 1fr auto 1fr; gap: 0; margin-bottom: 16px; }
.panel { background: var(--card); border: 1px solid var(--border); border-radius: var(--radius); overflow: hidden; box-shadow: var(--shadow); display: flex; flex-direction: column; }
.panel-header { padding: 10px 14px; background: #f8fafc; border-bottom: 1px solid var(--border); display: flex; align-items: center; gap: 10px; }
.panel-title { font-size: 0.82rem; font-weight: 600; color: var(--text2); white-space: nowrap; }
.panel-header select { flex: 1; padding: 5px 8px; border: 1px solid var(--border); border-radius: var(--radius-sm); font-size: 0.82rem; background: white; }
.breadcrumb { padding: 6px 14px; background: #f8fafc; border-bottom: 1px solid var(--border); font-family: monospace; font-size: 0.78rem; color: var(--text3); display: flex; flex-wrap: wrap; gap: 2px; }
.breadcrumb span { cursor: pointer; padding: 1px 4px; border-radius: 3px; }
.breadcrumb span:hover { background: var(--primary-light); color: var(--primary); }
.panel-body { min-height: 250px; max-height: 350px; overflow-y: auto; }
.panel-center { display: flex; align-items: center; justify-content: center; padding: 0 8px; }
.sync-icon { font-size: 1.5rem; opacity: 0.5; }

.browse-item {
  padding: 7px 14px; cursor: pointer; display: flex; align-items: center; gap: 8px;
  border-bottom: 1px solid #f1f5f9; font-size: 0.85rem; transition: background 0.1s;
}
.browse-item:hover { background: #f8fafc; }
.browse-item.selected { background: var(--primary-light); color: var(--primary); }
.browse-item .bi-icon { width: 18px; text-align: center; font-size: 0.9rem; }
.browse-item.is-dir { font-weight: 500; }
.browse-item.is-back { color: var(--text3); }

.panel-empty { padding: 30px; text-align: center; color: var(--text3); font-size: 0.85rem; }

/* Options */
.options-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
.checkbox-row { display: flex; gap: 20px; margin-top: 12px; }
.checkbox { display: flex; align-items: center; gap: 6px; font-size: 0.85rem; cursor: pointer; color: var(--text2); }
.checkbox input { width: 16px; height: 16px; accent-color: var(--primary); }

.form-group label { display: block; font-size: 0.8rem; font-weight: 500; margin-bottom: 4px; color: var(--text2); }
.form-group input, .form-group select, .form-group textarea {
  width: 100%; padding: 8px 12px; border: 1px solid var(--border);
  border-radius: var(--radius-sm); font-size: 0.85rem; transition: border-color 0.15s;
}
.form-group input:focus, .form-group select:focus { outline: none; border-color: var(--primary); box-shadow: 0 0 0 3px rgba(37,99,235,0.1); }

/* Action Bar */
.action-bar {
  display: flex; align-items: center; justify-content: space-between;
  padding: 16px 20px; background: var(--card); border: 1px solid var(--border);
  border-radius: var(--radius); box-shadow: var(--shadow);
}
.action-preview { font-size: 0.82rem; color: var(--text3); font-family: monospace; }

/* Jobs */
.job-card {
  background: var(--card); border: 1px solid var(--border); border-radius: var(--radius);
  padding: 14px 18px; margin-bottom: 10px; box-shadow: var(--shadow);
}
.job-card-top { display: flex; justify-content: space-between; align-items: center; margin-bottom: 6px; }
.job-card-name { font-weight: 600; font-size: 0.9rem; }
.job-status {
  padding: 3px 10px; border-radius: 12px; font-size: 0.72rem; font-weight: 600; text-transform: uppercase;
}
.job-status.running { background: #dbeafe; color: #1e40af; }
.job-status.completed { background: #dcfce7; color: #166534; }
.job-status.failed { background: #fee2e2; color: #991b1b; }
.job-status.stopped { background: #fef3c7; color: #92400e; }
.job-card-paths { font-family: monospace; font-size: 0.8rem; color: var(--text3); display: flex; align-items: center; gap: 8px; margin-bottom: 4px; }
.job-card-meta { font-size: 0.75rem; color: var(--text3); display: flex; justify-content: space-between; }
.job-card-meta .tag { display: inline-block; padding: 1px 6px; border-radius: 4px; font-size: 0.7rem; background: #f1f5f9; color: var(--text3); }
.job-log { margin-top: 8px; background: #1e293b; color: #a5f3fc; border-radius: var(--radius-sm); padding: 10px 12px; max-height: 200px; overflow-y: auto; }
.job-log pre { margin: 0; font-family: 'SF Mono', Menlo, Consolas, monospace; font-size: 0.78rem; white-space: pre-wrap; word-break: break-all; line-height: 1.4; }

/* Modal */
.modal-overlay {
  display: none; position: fixed; inset: 0; background: rgba(0,0,0,0.45);
  z-index: 200; align-items: center; justify-content: center;
}
.modal-overlay.open { display: flex; }
.modal {
  background: var(--card); border-radius: 12px; width: 90%; max-width: 520px;
  max-height: 85vh; overflow-y: auto; box-shadow: var(--shadow-md);
}
.modal-header {
  display: flex; justify-content: space-between; align-items: center;
  padding: 16px 20px; border-bottom: 1px solid var(--border);
}
.modal-header h3 { font-size: 1.05rem; }
.modal-close {
  background: none; border: none; font-size: 1.3rem; cursor: pointer;
  color: var(--text3); padding: 4px;
}
.modal-close:hover { color: var(--text); }
.modal-body { padding: 20px; }

/* Auth Flow */
.modal-auth { max-width: 480px; }
.auth-flow { margin-bottom: 16px; }
.step { padding: 8px 12px; font-size: 0.85rem; color: var(--text2); border-left: 3px solid var(--primary); margin-bottom: 8px; background: var(--primary-light); border-radius: 0 var(--radius-sm) var(--radius-sm) 0; }
.spinner { width: 32px; height: 32px; border: 3px solid var(--border); border-top-color: var(--primary); border-radius: 50%; animation: spin 0.8s linear infinite; margin: 20px auto; }
@keyframes spin { to { transform: rotate(360deg); } }

/* Toast */
.toast {
  position: fixed; bottom: 24px; right: 24px; padding: 12px 20px;
  border-radius: var(--radius); color: white; font-size: 0.85rem; font-weight: 500;
  z-index: 1000; transform: translateY(100px); opacity: 0; transition: all 0.3s;
  box-shadow: var(--shadow-md);
}
.toast.show { transform: translateY(0); opacity: 1; }
.toast.success { background: var(--success); }
.toast.error { background: var(--danger); }
.toast.info { background: var(--primary); }

/* Auth URL */
.auth-url-box {
  display: flex; align-items: center; gap: 8px; padding: 12px 14px;
  background: var(--bg); border: 1px solid var(--border); border-radius: var(--radius-sm);
}
.auth-url-input {
  flex: 1; padding: 6px 10px; border: 1px solid var(--border); border-radius: 4px;
  font-family: monospace; font-size: 0.8rem; background: white; color: var(--text);
  min-width: 0;
}
.auth-url-link { color: var(--primary); font-size: 0.82rem; text-decoration: underline; word-break: break-all; }
.auth-url-link:hover { color: var(--primary-hover); }

.ssh-tunnel-box {
  padding: 12px 14px; background: #fffbeb; border: 1px solid #fbbf24;
  border-radius: var(--radius-sm); margin-bottom: 8px;
}
.ssh-tunnel-label { font-size: 0.8rem; font-weight: 600; color: #92400e; margin-bottom: 6px; }
.ssh-tunnel-cmd {
  display: flex; align-items: center; gap: 8px; background: white;
  padding: 8px 12px; border-radius: 4px; border: 1px solid #fbbf24;
}
.ssh-tunnel-cmd code {
  flex: 1; font-family: monospace; font-size: 0.82rem; color: var(--text);
  word-break: break-all; user-select: all;
}

/* Sync Settings */
.sync-pair-row {
  padding: 12px; background: var(--bg); border: 1px solid var(--border);
  border-radius: var(--radius-sm); margin-bottom: 8px;
}
.sync-pair-fields {
  display: flex; align-items: center; gap: 8px; margin-bottom: 6px;
}
.sync-input {
  flex: 1; padding: 6px 10px; border: 1px solid var(--border);
  border-radius: 4px; font-size: 0.85rem; font-family: monospace;
}
.sync-input:focus { outline: none; border-color: var(--primary); }
.sync-input-dest { border-radius: 0 4px 4px 0; }
.sync-prefix {
  padding: 6px 8px; background: #e2e8f0; border: 1px solid var(--border);
  border-right: none; border-radius: 4px 0 0 4px;
  font-size: 0.8rem; font-weight: 600; color: var(--text2);
  white-space: nowrap; font-family: monospace;
}
.sync-arrow { font-size: 1.2rem; color: var(--primary); font-weight: 700; }
.sync-schedule-item {
  display: flex; align-items: center; justify-content: space-between;
  padding: 6px 10px; background: var(--bg); border: 1px solid var(--border);
  border-radius: 4px; margin-bottom: 4px; font-size: 0.85rem;
}
.sync-schedule-time { font-weight: 500; }

/* Remote Card with Sync Pairs */
.remote-card-header { display: flex; align-items: center; justify-content: space-between; flex-wrap: wrap; gap: 8px; }
.remote-card-name { font-weight: 600; font-size: 0.95rem; }
.remote-card-type { font-size: 0.8rem; color: var(--text3); margin-top: 2px; }
.remote-card-actions { display: flex; gap: 6px; flex-wrap: wrap; }
.sync-pairs-area { margin-top: 12px; padding-top: 12px; border-top: 1px solid var(--border); }
.sync-pair-row {
  display: flex; align-items: center; gap: 8px; padding: 8px 12px;
  background: var(--bg); border: 1px solid var(--border);
  border-radius: var(--radius-sm); margin-bottom: 6px;
  font-size: 0.85rem; justify-content: space-between;
}
.sync-pair-path { font-family: monospace; font-size: 0.82rem; color: var(--text2); word-break: break-all; }
.sync-pair-left { display: flex; align-items: center; gap: 8px; flex: 1; min-width: 0; }
.sync-pair-right { display: flex; align-items: center; gap: 6px; flex-shrink: 0; }
.sync-arrow { color: var(--primary); font-weight: 700; flex-shrink: 0; }
.sync-error-link { font-size: 0.75rem; color: var(--danger); cursor: pointer; text-decoration: underline; white-space: nowrap; }
.tag-red { background: #fee2e2; color: #991b1b; }
.schedule-section { margin-top: 20px; }

/* Responsive */
@media (max-width: 768px) {
  .remote-card-header { flex-direction: column; align-items: flex-start; }
  .remote-card-actions { width: 100%; }
  .sync-pair-row { flex-wrap: wrap; }
  .header-right { gap: 2px; }
  .btn-ghost { padding: 6px 10px; font-size: 0.78rem; }
}
'
printf '%s' "$B64_SERVER" | base64 -d > "$INSTALL_DIR/server.js"
printf '%s' "$B64_HTML" | base64 -d > "$INSTALL_DIR/public/index.html"
printf '%s' "$B64_JS" | base64 -d > "$INSTALL_DIR/public/js/app.js"
printf '%s' "$B64_CSS" | base64 -d > "$INSTALL_DIR/public/css/style.css"
echo " ファイルデコード完了"
cat > "$INSTALL_DIR/package.json" << 'PKGEND'
{
"name": "easyrclone",
"version": "10.0.0",
"description": "EasyRclone - Cloud Sync Web GUI",
"main": "server.js",
"scripts": { "start": "node server.js" },
"dependencies": {
"express": "^4.18.2",
"ws": "^8.16.0"
}
}
PKGEND
echo " package.json 作成完了"
echo ""
echo "[5/6] npm 依存関係インストール..."
cd "$INSTALL_DIR"
npm install --production 2>&1 | tail -3
echo ""
echo "[6/6] systemd サービス作成..."
cat > /etc/systemd/system/easyrclone.service << SVCEOF
[Unit]
Description=EasyRclone Web GUI
After=network.target
[Service]
Type=simple
WorkingDirectory=$INSTALL_DIR
ExecStart=$(which node) server.js
Restart=always
RestartSec=3
Environment=PORT=$PORT
Environment=TZ=Asia/Tokyo
[Install]
WantedBy=multi-user.target
SVCEOF
systemctl daemon-reload
systemctl enable easyrclone
systemctl restart easyrclone
echo " サービス起動完了"
echo ""
echo "========================================="
echo " インストール完了！"
echo "========================================="
echo ""
echo ""
if [ -n "$TS_IP" ]; then
echo " Web UI : http://${TS_IP}:${PORT}"
fi
if [ -n "$TS_HOSTNAME" ]; then
echo " Web UI : http://${TS_HOSTNAME%%.*}:${PORT} (MagicDNS)"
fi
echo " Web UI (local) : http://localhost:$PORT"
echo ""
echo " サービス: systemctl [start|stop|restart|status] easyrclone"
echo " 設定ファイル: $INSTALL_DIR/config/rclone.conf"
echo " ログ: journalctl -u easyrclone -f"
echo " タイムゾーン: $(date)"
echo ""
使い方
GoogleドライブやOneDriveへの接続を許可する
EasyRcloneのページにアクセスしたら、上部のバーから「Googleドライブ」か「OneDrive」ボタンをクリックします。
すると下の画面のようなカードが作られるので最初に「一時SSH設定」ボタンを押します。
まず、この設定が必要な理由ですが、Google DriveやOneDriveをrcloneで使うには、最初に1回だけOAuth認証（ブラウザでGoogle/Microsoftにログインして許可する作業）が必要です。この認証には少しクセがあって、rclone自身がPC上に一時的なWebサーバーを立てて、ブラウザからの認証結果をそこで受け取る、という仕組みになっています。
通常、rcloneをローカルPCで直接動かしている場合はこれで何も問題ないのですが、今回のEasyRcloneは別PC上のLXDコンテナの中で動いています。そうすると次の2つの壁にぶつかります。
1.コンテナ内で立った一時Webサーバー（認証受け取り用）は、コンテナの外から直接アクセスできない
2.このコンテナはrootにパスワードが設定されておらず、SSH接続もデフォルトでは許可されていない
つまり「SSHトンネルでポートを転送すれば認証URLにアクセスできる」はずなのに、そのSSH接続自体ができない、という状態です。
これを解決するための動作が「一時SSH設定」ボタンです。押すと以下を一時的に行います。
・root に固定パスワード（rclone）を設定
・SSHのパスワード認証・root ログインを一時的に有効化
・sshd を再起動して反映
このあと「認証」ボタンを押します。
SSHトンネルのためのコマンド（ssh -L ポート:127.0.0.1:ポート root@ホスト名 の形）が表示されるので、これをローカルPCのターミナルで実行すれば、コンテナ内の認証用一時サーバーにローカルPCからアクセスできるようになり、通常のブラウザ認証フローがそのまま使えるようになります。
そのまま、ブラウザでログインの「開く」ボタンを押す、もしくはURLをコピーしてブラウザに貼り付けます。するとログイン認証画面が表示されるはずです。
これを許可し、下記のように「Success！」と表示されれば完了です。
元の画面に戻り、「アカウント認証」の画面をバツで閉じて、「テスト」ボタンを押します。画面右下に「接続成功」と出ればOKです。
接続設定が問題なければ、「一時SSH削除」ボタンを押して、パスワードを無効化し、SSH設定も元（パスワード認証禁止）に戻しておきましょう。
同期ペアを追加
続いて同期ペアを追加していきます。ひとまず除外設定などはない、シンプルな形にしています。
コピー元は既存のフォルダを指定、コピー先はフォルダが無ければ作られるので、好きな場所にしておけばよいです。
チェックボックスへチェックするかどうかで、動作は下記の違いになります。rclone copy(チェックなし): コピー元の内容をコピー先に反映するが、コピー先にしか無いファイルはそのまま残す → 単純コピー・追加専用 rclone sync(チェックあり): コピー先をコピー元と完全に一致させる。コピー元に無いファイルはコピー先から削除される → ミラーリング
チェックなしならコピー元からコピー先へ、新しいファイル・更新されたファイルを追加していくだけの動作です。コピー先にだけ存在する古いファイルがあっても、それは消されずにそのまま残ります。安全側の動作で、間違って何かを消してしまう心配がありません。
同期ペアが追加されるので、ひとまず「同期」ボタンを押して追加した設定で同期してみましょう。
ジョブ履歴画面が表示され処理中のログが表示され、成功か失敗が表示されます。なお、このジョブ履歴は30日間保存する設定にしています。
またスケジュール実行していた時に同期エラーが発生した場合は、同期ペアカードに「同期エラーあり」という通知が表示されるようにしています。このリンクをクリックすればジョブ履歴ページが開き、この表示は消えるようにしています。
手軽に色々な環境で動作チェック出来ないのと、手間や時間がかかるので、しばらくはこれを試したりしながら、問題なさそうなら本格的に運用してみたいと思います。
アンインストール
一時SSHパスワード認証を「一時SSH設定」機能で有効にしたことがある場合は、先に忘れずにUIの「一時SSH削除」ボタンを押しておいてください（アンインストール後は/api/ssh/teardownが呼べなくなるため、sshd_configの変更が残ります）。
スクリプトの中身は systemd停止・無効化 → crontabの同期スケジュール削除 → /opt/easyrclone 削除、の3ステップです。rclone自体やNode.jsは他アプリと共用の可能性があるため削除していません。
#!/bin/bash
set -e
INSTALL_DIR="/opt/easyrclone"
echo "========================================="
echo " EasyRclone アンインストーラー"
echo "========================================="
echo ""
if [ "$(id -u)" -ne 0 ]; then
echo "エラー: root で実行してください"
echo " sudo bash $0"
exit 1
fi
echo "[1/3] systemd サービス停止・無効化..."
if systemctl list-unit-files | grep -q '^easyrclone.service'; then
systemctl stop easyrclone 2>/dev/null || true
systemctl disable easyrclone 2>/dev/null || true
rm -f /etc/systemd/system/easyrclone.service
systemctl daemon-reload
echo " 停止・無効化・unitファイル削除完了"
else
echo " easyrclone.service は見つかりませんでした（スキップ）"
fi
echo ""
echo "[2/3] crontab のスケジュールエントリ削除..."
if crontab -l 2>/dev/null | grep -q -e 'cron-sync.sh' -e '# easyrclone-schedule'; then
crontab -l 2>/dev/null | grep -v -e 'cron-sync.sh' -e '# easyrclone-schedule' > /tmp/easyrclone_crontab_tmp || true
crontab /tmp/easyrclone_crontab_tmp
rm -f /tmp/easyrclone_crontab_tmp
echo " crontab エントリ削除完了"
else
echo " crontab にエントリは見つかりませんでした（スキップ）"
fi
echo ""
echo "[3/3] ファイル削除..."
if [ -d "$INSTALL_DIR" ]; then
rm -rf "$INSTALL_DIR"
echo " $INSTALL_DIR を削除しました"
else
echo " $INSTALL_DIR は見つかりませんでした（スキップ）"
fi
echo ""
echo "========================================="
echo " アンインストール完了"
echo "========================================="
echo ""
echo " ※ 一時SSH設定（パスワード認証有効化）を使ったことがある場合は、"
echo " /etc/ssh/sshd_config.d/60-cloudimg-settings.conf を確認し、"
echo " 必要に応じて PasswordAuthentication / KbdInteractiveAuthentication を"
echo " 元に戻して 'systemctl restart sshd' を実行してください。"
echo ""